Serverless & Event-Driven Architecture
What actually happens between the trigger and your handler. Learn the execution environment lifecycle, who owns the retry, how dead-letter handling and deduplication really behave, and where scale-to-zero stops paying — remembered with spaced repetition.
- flashcards
- 111
- flashcards
- per day
- ~10 min
- per day
- level
- Intermediate → Advanced
- level
- modules
- 6
- modules
What this track is for
Most serverless material teaches you how to deploy a function. This track is about everything that happens around it: which phase your initialization code runs in and why that is billed, whether the platform or your caller owns the retry, what happens to the other messages in a batch when one of them fails, and how long a message stays invisible before someone else picks it up.
The through-line is that a function is the easy part — the delivery semantics are the system. Event source mappings deliver at least once, so consumer idempotency is not optional. A dead-letter queue keeps the original enqueue timestamp, so it needs longer retention than the queue it protects. Exactly-once exists, but only for pull subscriptions in one region, and never for publish-side duplicates. Every card here is written around a documented behaviour that decides how your system fails.
Six modules span the execution model, triggers and invocation, event-driven patterns, orchestration and state, container and edge platforms, and the quotas, identity and cost model that answer the last question honestly: when serverless is the wrong choice.
6 modules, seed to bloom
Each module is a set of flashcards — 111 in total. Answer, review, and watch your knowledge grow from seed to full bloom.
Execution Model
Init/Invoke/Shutdown lifecycle, cold starts, environment reuse and the concurrency controls that shape them
19 cardsTriggers & Invocation
Synchronous, asynchronous and poll-based invocation — who owns the retry, how batches are formed and how failures are captured
18 cardsEvent-Driven Patterns
CloudEvents, queues and streams, dead-letter handling, deduplication and the exact boundaries of exactly-once
19 cardsOrchestration & State
Step Functions and Durable Functions, saga compensation, choreography versus orchestration, and where state can safely live
17 cardsContainers & Edge
Knative and Cloud Run autoscaling, Fargate task isolation, and the isolate model that changes what a cold start even means
19 cardsLimits, Security & Economics
The quotas that shape a design, the identity and network model around a function, and what serverless actually costs
19 cardsSample questions
A taste of the real flashcards. Pick an answer, then reveal the explanation.
Which three phases make up the AWS Lambda execution environment lifecycle?
- AInit, Invoke and Shutdown — each begins with an event sent to the runtime and every extension
- BProvision, Execute and Terminate — each begins with a control message sent by the scheduler
- CDownload, Warm and Freeze — each begins with a state change reported by the billing system
- DRegister, Handle and Drain — each begins with a handshake performed over the Runtime API
What delivery guarantee does AWS document for Lambda event source mappings?
- AAt least once, so duplicate processing can occur and function code must be idempotent
- BExactly once, so records are guaranteed to reach the function only a single time
- CAt most once, so a record is dropped rather than delivered twice after a failure
- DOrdered once per shard, which rules out duplicates as long as batching is disabled
Which Pub/Sub subscription types support exactly-once delivery?
- APull subscriptions only — push and export subscriptions do not support it
- BPush subscriptions only — pull and export subscriptions do not support it
- CPull and push subscriptions — only export subscriptions are excluded from it
- DEvery subscription type — provided the topic has message ordering switched on
Which execution model does Cloudflare Workers use to run code?
- AV8 isolates, with one runtime instance hosting thousands of them at once
- BMicro virtual machines, with one hypervisor hosting thousands of them at once
- COCI containers, with one node's runtime hosting thousands of them at once
- DWebAssembly sandboxes, which are the only supported unit of isolation there
Learn it once, keep it for good
Answer a question
Each card is one practical concept with multiple options. Pick what you think is right.
Get the full answer
See the correct option plus a clear explanation, and a link to deeper docs when one is available.
Review at the right time
A spaced-repetition engine (SM-2 or FSRS) resurfaces each card just before you would forget it.
Why this material is worth your time
Cold starts stop being folklore
Init, Invoke and Shutdown are documented phases with documented limits. Once you know which code runs where, latency becomes something you can design against.
Delivery semantics you can defend
At-least-once, exactly-once and at-most-once each have precise boundaries. Knowing them is the difference between an idempotent consumer and a duplicated payment.
Failure paths that actually catch things
Retries, dead-letter queues, destinations and partial batch responses do different jobs. Most production surprises come from assuming one of them covers another.
The economics, not just the mechanics
Provisioned concurrency and minimum instances are billed while idle. Judging when always-on is simply cheaper is a senior-level call.
Common questions
Is this only about AWS Lambda? +
No. Lambda is the most thoroughly documented reference point, so it anchors the execution model, but the track also covers Google Cloud Pub/Sub and Cloud Run, Knative, Azure Durable Functions, Cloudflare Workers and Lambda@Edge — and it teaches the differences between them rather than one vendor's vocabulary.
Do I need the AWS Cloud Practitioner track first? +
Not required, but it helps. This track deliberately skips "what is Lambda" definitions and starts at the level of behaviours, limits and trade-offs, so some prior exposure to a cloud provider makes it land faster.
Does it cover Kafka and Redis? +
Only where they meet the serverless boundary — queue versus stream semantics, dead-letter handling and idempotency. Broker internals belong to a messaging track, not this one.
Is it free? +
Yes, completely free. No registration or credit card is required, and all your progress is stored locally in your browser.
Ready to learn serverless properly?
Plant your first seed today. Ten minutes a day turns platform documentation into design judgment you can defend.