Memorystore Redis Tiers vs Memcached for the PDE Exam

Memorystore questions on the Professional Data Engineer exam usually come down to a small set of choices. Do you pick Redis or Memcached? If Redis, do you pick the Basic tier or the Standard tier? The exam likes to wrap those choices inside a scenario about latency, availability, persistence, or budget, and the correct answer is usually one keyword away. I want to walk through how I keep these straight when I am sitting in the exam.

The Basic tier is the cheap, single-node Redis

The Basic tier of Memorystore for Redis is the budget option. It runs as a single node with no replication, no cross-zone failover, and no high availability story. If the node has an issue, the cache is unavailable until it recovers, and any data sitting in memory can be lost. That is fine for a dev or test environment, or for a production cache where a cold restart is acceptable.

For the Professional Data Engineer exam, look for these signals that point to the Basic tier:

• Development or test workload, or a non-critical environment
• Cost is the dominant constraint and downtime is tolerable
• The cache can be rebuilt from a source of truth without business impact
• No mention of availability SLAs, failover, or zonal outages

The Basic tier is easy to spin up. You pick a size, point your app at the endpoint, and you have a Redis cache. There is not much to configure, which is part of the appeal and also part of the limitation.

The Standard tier is HA Redis with automatic failover

The Standard tier adds a replica in a different zone and gives you automatic failover. If the primary node fails, Memorystore promotes the replica without you writing any orchestration. You pay more and you have a couple more knobs to tune, but you get continuity through zonal failures and node failures.

Exam signals that point to the Standard tier:

• High availability, failover, or uptime appears anywhere in the prompt
• The cache is on the hot path for a production application
• The scenario calls out a zonal outage or a multi-zone resilience requirement
• Read replicas are needed for read scaling, which is only available on Standard

A short way to remember it. Basic is one node. Standard is two zones. If the question mentions failover or HA at all, the answer is Standard.

Memcached is the simple, scale-out key-value cache

Memorystore for Memcached sits in a different lane. It is a pure in-memory, key-value cache with no persistence and no built-in replication or failover. What it does have is horizontal scaling. You can run a cluster of Memcached nodes and add or remove nodes to handle changing load. The trade-off is that you lose Redis features like rich data structures, persistence to disk, and the HA story that Standard tier Redis provides.

Exam signals that point to Memcached:

• The use case is simple key-value caching, such as session storage or database query results
• The workload needs to scale horizontally across many nodes
• Data is transient and loss on restart is acceptable
• No mention of lists, sets, sorted sets, hashes, pub/sub, or leaderboards

If a question mentions any Redis data structure or feature, like a sorted set for a leaderboard or pub/sub for messaging, the answer is Redis, not Memcached. Memcached only knows how to store keys and values.

The decision tree I use on exam day

When a Memorystore question shows up, I run through this in my head:

1. Does the scenario need anything beyond a flat key-value store? If yes, Redis. If no, keep going.
2. Does it need to scale to many nodes, with data that can disappear on restart? If yes, Memcached.
3. If Redis, does the scenario mention high availability, failover, replicas, or production uptime? If yes, Standard tier. If no, Basic tier.

That ordering matters. Memcached only wins on the simplest scenarios with horizontal scale. The moment persistence, data structures, or HA shows up, you are in Redis territory, and then you pick the tier based on whether continuity is required.

A few traps to watch for

The exam likes to test edges. A few I have seen catch people off guard:

• Persistence on Redis. Redis can persist to disk, which means you can survive a restart. Memcached cannot. If the prompt says cache state should outlive a restart, that is Redis.
• Performance phrasing. Memcached is slightly faster for plain key-value access because it is simpler. Redis is still fast, but it carries more features. Do not let raw latency claims push you to Memcached if the scenario actually needs Redis features.
• Automatic scaling. Memcached scales horizontally. Redis does not auto-scale the same way. If a prompt emphasizes elastic scaling without HA needs, that nudges toward Memcached.
• HA on Memcached. There is no Memcached equivalent of the Standard tier. If the question wants HA and you are stuck with Memcached, that is a wrong-tool scenario, and the answer is usually to switch to Redis Standard.

Memorystore is a small slice of the Professional Data Engineer exam, but it is one where the right answer comes from matching keywords in the prompt to features in the product. Get the Basic versus Standard versus Memcached mapping memorized and these questions become quick wins.

My Professional Data Engineer course covers Memorystore alongside the rest of the caching, storage, and pipeline topics on the exam, with the scenario framing you need to pick the right service under time pressure.