Back to blog

AWS Certification: Flashcards for services you have never used

AWS exam questions are scenarios, not definitions. How to write scenario-to-service flashcards, and how to handle the services you will never open.

If you are reading this, you probably have an AWS exam date, a service list, and the uncomfortable realization that most of the names on that list are things you have read about and never once opened.

A little about me first. I'm Daniel, a third year engineering science student at UofT specializing in machine intelligence. I've interned at IBM and Intel. I also work on Nebulearn, a flashcard app, so treat anything I say about study tools as coming from someone with a conflict of interest. I'll point out where other apps beat mine.

Here is the short version of how to study for an AWS certification with flashcards: stop putting the service name on the front of the card. The exam does not hand you a service and ask what it is. It hands you a situation with two or three constraints and asks which service satisfies them. A card that says "Amazon SQS" on the front and "managed message queuing service" on the back rehearses a retrieval you will never be asked to perform. Flip it. The front is the situation. The back is the service, plus the one property that made it the answer.

That flip is the whole argument. The rest is how to write those cards, how to handle the services you will never touch in real work, and what to do when the method stops working.

Your definition cards run the retrieval backwards

The reason "what is X" cards feel productive and then fail is that memory is directional. You practice going from a cue to an answer, and you get good at that specific direction. If your cue is always the service name, the thing you rehearse is name to description. The exam gives you a description and wants the name. You trained the opposite lane.

The failure is easy to picture. You build a deck straight off the service list, one card per service, front is the name, back is what the docs call it. You can recite all of it. Then a practice question describes two tiers of an application where the back end keeps falling behind at peak and requests are getting dropped, and asks what to put between them. You know every word in the answer choices and still pick wrong, because nothing in the deck ever started from "requests are getting dropped."

This is the same failure as the context dependency problem that shows up in every subject: a card is only as useful as the cue it trains, and a cue that never appears on the test is decoration. It also stacks badly with multiple choice, where the answer choices are usually four services that all sort of fit, so recognition gets you nothing. You need the discriminating property, and definition cards do not carry it.

Write the card in the shape of the question

So the card starts from the situation. Take the messaging family, where SQS, SNS, EventBridge and Kinesis all "move data between things." Here is the bad card and the three I would write instead.

CardFrontBack
BadAmazon SQSFully managed message queuing service
GoodTwo tiers are tightly coupled and the consumer tier drops requests at peak. What goes between them, and why?SQS. The queue stores messages durably, so the producer never waits on the consumer and each side scales on its own.
GoodOne event has to reach five independent subscribers at the same time.SNS. Pub/sub fan-out, one publish to many subscriptions. A queue hands a message to one consumer, so SQS is wrong here.
GoodSeveral consumers need to read the same ordered stream, each at its own position, and replay it later.Kinesis Data Streams. Records stay in the stream for a retention window and consumers hold their own position, which a queue does not do.

Notice what the back of a good card contains. Not just a name: a name plus the property that beat the nearest alternative. That second half is the part that survives, because the exam's distractors are exactly those nearest alternatives.

I also write one card per family that runs from a phrase in the question stem to the service it forces. "Strict ordering, processed once" pulls SQS FIFO. "Route events to different targets based on the content of the event" pulls EventBridge and its rules. "Many readers, own position, replayable" pulls Kinesis. These are not exam secrets, just the properties AWS documents, turned into cues that point the direction you need them to point.

One card per service you are never going to open

Now the part nobody tells you how to handle. An AWS certification covers far more services than any one job uses. I have built real things on S3, Lambda, EC2 and DynamoDB. I have never opened Storage Gateway, and no amount of card writing gives me the hands-on feel for it. Pretending otherwise is how a deck reaches 600 cards and stops getting reviewed.

I split the service list into three tiers and card each tier differently.

TierWhat it isHow many cards
Used itServices you have actually built onDeep cards: failure modes, the limits that bit you, why you chose it
Never used, heavily examinedNamed constantly in scenario questions2 to 4 scenario cards, always written against its nearest neighbour
Name onlyExists, might show up once as a distractorExactly one card: what problem does this exist to solve

The tier three card is the one people get wrong. They either skip the service and lose the question, or try to learn it properly and burn an hour. One card, one sentence, phrased as a job to be done. "Which service exists to run SQL queries directly against files sitting in S3?" gives you Athena. That is enough to rule it out as a distractor and enough to recognize it when it is the answer.

For tier two, the rule that moved my practice-question accuracy most was never carding a service alone. Alone, it is a definition again. Against its nearest neighbour, it is a decision, and decisions are what get tested.

PairThe one line that separates them
EBS vs EFSOne volume attached to one instance vs a shared file system many instances mount at once
RDS vs DynamoDBRelational with joins and a fixed schema vs key-value at consistent low latency and very large scale
ALB vs NLBRoutes on HTTP content like paths and headers vs raw TCP and UDP at high throughput with static IPs
CloudFront vs Global AcceleratorCaches content close to the user vs routes traffic over the AWS network to your endpoints

Write the pair on one card, front asking which you pick and why, and you have covered two services with one review. This is the same economy as carding algorithm complexity in pairs instead of memorizing a chart of labels.

Skip the facts that rot before your exam date

The flip side of tiering is knowing what not to card at all, because a deck full of rotting facts is worse than a smaller deck. Three things I leave out.

Quotas and limits. AWS raises default quotas and adjusts soft limits, and the version sitting in your card goes stale without telling you. Unless a limit is the reason a service is or is not the answer, such as a resource being regional rather than global, skip it.

Prices. Same problem, faster. Card the shape of the pricing instead, like the fact that one storage class charges a retrieval fee and another does not, because that shape is what a "most cost effective" question turns on.

Console click paths. Nothing rewards knowing which tab a setting lives under, and those cards are miserable to review. If you want the console, open the console.

That leaves relationships and decisions, the material that is both stable and tested. If your deck is already bloated with the other kind, an exam deck audit is a better use of an hour than adding fifty more cards. Deleting a card is not failure, and easy cards are not free: each one buys a review slot you wanted for something hard.

When this stops working, and what I do about it

Two failure cases show up reliably, and neither of them means the method is wrong.

The first one stings: you can answer every card in your deck and still miss practice questions. Dig into why and it is almost always constraint stacking. The cards ask one thing at a time, and a real scenario stem stacks two or three, something like cheapest, plus no application code changes, plus the least operational overhead. Each constraint on its own points at a different service, and the answer is the one that satisfies all of them at once.

The fix is a small set of stacked cards written from the questions you missed. Strip a missed question down to its constraints and write the front as all of them together. Then write its sibling, the distractor card: front is "in that scenario, why is the plausible wrong answer wrong," back is one sentence. That is where the real learning is, because you are carding the boundary instead of the centre.

The second failure is thinner and harder to notice. For a service you have never touched, the card has no hook. You can recite the discriminating property and still not feel which situation it belongs to, so under time pressure you fall back to guessing. What helps me is ten minutes of contact before writing the card: open that service's FAQ page, find the one paragraph describing the problem it was built for, and write the scenario in my own words. Ten minutes is not experience, but it is enough to make the card mean something instead of being a string of words I can echo. This is the computer science version of the same problem, where the abstraction is easy to memorize and useless until it is attached to a concrete case.

Since the exam date is fixed and the queue is not, front-load the new cards. Anything you add in the last stretch is something the scheduler keeps showing you during the week you wanted for weak material, so I stop adding roughly a week out and review only. The high stakes exam schedule post has the longer version.

Where I would keep this deck

The honest exceptions first. If someone in your study group already has a big community AWS deck and you want to grind volume on shared vocabulary, Anki with that deck is a fine answer, and its add-on ecosystem is still unmatched for anyone who wants to tinker with their own scheduler. Read when premade decks are worth it first, because a stranger's deck is full of that stranger's tier three. And if your group wants one set everybody can hammer the night before a practice test, Quizlet is faster to share than anything else. One thing to know before you commit anywhere: review history does not move between apps, so the schedule you build stays where you built it.

My reason for building an AWS deck in Nebulearn is narrower than a feature list. AWS study material does not live in a PDF, it lives in browser tabs: the docs, the FAQ page for a service you have never used, an architecture diagram in a whitepaper. That is the bottleneck this post creates for you, because writing scenario cards means turning a paragraph of docs into a situation over and over. The Chrome extension exists for exactly that: highlight the paragraph, hit the keybind, the card is made without leaving the tab, and you can snip an architecture diagram off the screen the same way. FSRS is on by default too, which matters when the date is fixed and you want weak cards coming back close together instead of on a fixed ladder. The free tier is 1,000 saved questions and 40 weekly AI credits, which is more than one certification deck needs if you tiered it properly.

So: a deck of service definitions will tell you what everything is and still leave you guessing between four plausible answers, while a deck of scenarios trains the exact retrieval the exam asks for and stays small enough to finish. Build the second kind, keep it somewhere the docs you are reading are one keybind away from being a card, and let the scheduler decide which of your never-used services needs another look tomorrow.

AWSCertificationFlashcardsSpaced Repetition