Shelf · AWS · Chapter 12

Chapter 12: Talking AWS in an interview

Deployed infrastructure and real decisions are necessary but not sufficient in an AWS interview; the deciding factor is whether you can turn what you actually did into a specific, defensible story under follow-up questions. This chapter is the method for whiteboarding, narrating and honestly scoping what you have, plus a clear-eyed look at what a certification can and cannot buy you.

Difficulty
Priority
aws-12-01Card 1 of 6

Whiteboard a defensible AWS architecture

HardP3 · Role-dependentTalk about it8 min
system-designwhiteboardinginterview-methodtradeoffs
Needs: Design interview method: the eight-step flow, AWS compute choice

Why you care

Most candidates fail the AWS whiteboard round not from missing service knowledge, but because they draw boxes before agreeing what the system needs to do, then can't defend a choice under pressure. Interviewers watch you reason under changing constraints, not count service names. If your design looks identical before and after "now assume 10x write volume," that's the clearest tell the first answer was memorised.

Explain like I'm 5

A building inspector doesn't care how many brick types you can name; they care about load paths and exits, and whether the building stands when something unexpected happens. Structure beats inventory.

Core concept

A repeatable five-step method, in order:

  1. Clarify requirements: scale, latency, consistency, failure tolerance, as rough numbers, before drawing.
  2. Draw the topology top-down: client, edge, compute, data, async paths.
  3. Call out IAM boundaries: which role touches which resource, and the trust boundary.
  4. State the data path and consistency model: synchronous vs eventual, partial-failure behaviour.
  5. Name failure modes and rough cost, reusing AWS compute choice's compute table instead of re-deriving it live.

Decision rule: answer "why not Y" with the requirement Y fails, not a feature list; use the fewest parts the constraints demand.

Under the hood

Interviewers grade against a rubric: requirements gathering, trade-off articulation, failure-mode coverage, and whether the design changes when a constraint lands mid-answer. That's the sharpest signal, because a memorised answer can't fake it: a candidate who's reasoned it through names exactly which component breaks first under 10x load; one reciting a blog post redraws everything, or nothing.

Minimal example A design-review checklist flags what you skipped

PythonA design-review checklist flags what you skippedruns
REQUIRED = ["requirements", "topology", "iam_boundary", "data_consistency", "failure_mode", "cost_shape"]


def missing_sections(notes):
    return [key for key in REQUIRED if not notes.get(key)]


draft = {
    "requirements": "100k orders/day, p99 under 500ms, single region ok",
    "topology": "ALB -> Lambda -> RDS Postgres",
    "cost_shape": "pay-per-request, low idle cost",
}
print(missing_sections(draft))
print(len(REQUIRED) - len(missing_sections(draft)), "of", len(REQUIRED), "sections covered")
Output
['iam_boundary', 'data_consistency', 'failure_mode']
3 of 6 sections covered

In production Scoring three rounds of the same whiteboard answer

A mock interview rarely stays static: the interviewer adds constraints, and a defensible design responds to each one instead of staying frozen.

PythonScoring three rounds of the same whiteboard answerruns
from dataclasses import dataclass

REQUIRED = ["requirements", "topology", "iam_boundary", "data_consistency", "failure_mode", "cost_shape"]


@dataclass
class Round:
    name: str
    notes: dict
    constraint_added: str = ""


def score(notes):
    covered = [k for k in REQUIRED if notes.get(k)]
    return len(covered), REQUIRED


rounds = [
    Round("baseline", {
        "requirements": "orders-api, 100k orders/day",
        "topology": "ALB -> Fargate -> RDS Postgres",
    }),
    Round("interviewer: what if a write fails halfway?", {
        "requirements": "orders-api, 100k orders/day",
        "topology": "ALB -> Fargate -> RDS Postgres",
        "failure_mode": "idempotent write with order_id unique key, retried from SQS",
        "iam_boundary": "Fargate task role: write to orders table only, no admin",
    }, constraint_added="partial-failure handling"),
    Round("interviewer: now assume 10x write volume", {
        "requirements": "orders-api, 1M orders/day",
        "topology": "ALB -> Fargate -> SQS -> workers -> RDS Postgres (write-behind)",
        "failure_mode": "idempotent write with order_id unique key, retried from SQS, DLQ after 5",
        "iam_boundary": "Fargate task role: write to orders table only, no admin",
        "data_consistency": "eventual: API returns 202, status polled separately",
        "cost_shape": "SQS + worker fleet scales with queue depth, not request rate",
    }, constraint_added="10x write volume"),
]

for r in rounds:
    covered, total = score(r.notes)
    print(f"{r.name}: {covered}/{len(total)} sections, added for: {r.constraint_added or 'n/a'}")
Output
baseline: 2/6 sections, added for: n/a
interviewer: what if a write fails halfway?: 4/6 sections, added for: partial-failure handling
interviewer: now assume 10x write volume: 6/6 sections, added for: 10x write volume

See it happen A design that grows only when a constraint forces it

writesenqueueafter 5 failspullwrite-behindclientALBFargateRDS Postgres(write-behind)SQSDLQworkers
  1. Baseline answer: client to ALB to Fargate to RDS, nothing else drawn yet.
  2. Interviewer asks what happens if a write fails halfway: the Fargate node gets an IAM boundary label, scoped to one table.
  3. Failure mode added: SQS and a DLQ appear between the API and the write path, so a failed write becomes retryable instead of lost.
  4. 10x volume constraint: workers now pull from SQS and write behind, instead of Fargate writing directly on every request.
Notice: the diagram only grows when a new constraint forces it; a design that looks identical in every frame is the sign of a memorised answer.
Scenario A

In your world

The situation

You get asked in a phone screen to design "a service that ingests supplier price files and serves current price lookups" on AWS.

What actually breaks

You answer "S3, Lambda, DynamoDB" in twenty seconds, no clarifying questions. The interviewer asks what happens when two files for the same SKU land in the same minute, and you have nothing.

What you'd do on Monday

Rehearse the five-step method on a timer, so a skipped section becomes visible first:

PythonSelf-timed rehearsal: did you cover every section before the clock ran out?runs
BUDGET_SECONDS = {"requirements": 120, "topology": 180, "iam_boundary": 60, "data_consistency": 120, "failure_mode": 120, "cost_shape": 60}

elapsed = {"requirements": 95, "topology": 160, "iam_boundary": 0, "data_consistency": 40, "failure_mode": 0, "cost_shape": 0}

for section, budget in BUDGET_SECONDS.items():
    status = "covered" if elapsed[section] > 0 else "SKIPPED"
    print(f"{section}: {elapsed[section]}s / {budget}s budget -> {status}")
Output
requirements: 95s / 120s budget -> covered
topology: 160s / 180s budget -> covered
iam_boundary: 0s / 60s budget -> SKIPPED
data_consistency: 40s / 120s budget -> covered
failure_mode: 0s / 120s budget -> SKIPPED
cost_shape: 0s / 60s budget -> SKIPPED
Scenario B

Imagine you work at Postman

2M scheduled API monitors

The numbers

Illustrative: 2M monitors every 5 minutes average 6,667 checks/second. Firing on the exact boundary clusters 400,000 checks into one second, ~60x the average rate.

What the Scenario-A answer does here

The checklist-driven design still works, but "schedule on the round mark" is what most candidates whiteboard, creating a thundering herd every five minutes.

What flips at this scale

A fixed, random offset per monitor spreads the same 400,000 checks evenly instead of bursting. Name this when asked how it scales to millions.

The trade-off you'd defend

I'd defend jittered scheduling over round-time scheduling, trading a tidy "exactly on the mark" for a load profile flat instead of spiky.

Illustrative numbers; not Postman-published.

Gotchas

Freezing on the first follow-up

Symptom

The candidate repeats the same diagram verbatim when asked "what if X."

Cause

The design was memorised, not derived from requirements.

Fix

Practise adjusting one component at a time, naming which requirement changed.

Service-name dumping

Symptom

Eight AWS services named in the first thirty seconds, before any clarifying question.

Cause

Signalling breadth instead of reasoning.

Fix

Name two or three services per layer and justify each against a requirement.

No numbers anywhere

Symptom

Asked requests-per-second, the candidate has no answer, and the design doesn't change once given one.

Cause

Scale was never converted into a number during clarification.

Fix

Do the back-of-envelope math out loud, and let it drive one design choice.

Tricky questions

Does drawing more AWS services signal seniority?
Most people say

Yes, naming EventBridge, Step Functions, DynamoDB, ElastiCache, SQS and three Lambda functions shows breadth.

Actually

No, it signals components weren't matched to requirements. A senior answer uses the fewest parts the constraints need.

Should you ask every clarifying question you can think of before drawing anything?
Most people say

Yes, more clarification always looks more rigorous.

Actually

No, open-ended clarification reads as stalling. Ask the few questions that change the architecture and move on.

Scenario question

You're handed 20 minutes to design "a service that lets support agents search customer order history," and the interviewer says "just go." What do you do first?

Model answer

I wouldn't start drawing. I'd spend sixty seconds stating assumptions out loud: scale (read-heavy, tens of thousands of agents), consistency (a few seconds of staleness is fine), and region scope. Only after confirmation would I draw a search-optimised read path behind an API layer, and say why not a graph database or streaming pipeline: nothing asked for it. The trade-off is a dedicated search index versus an indexed Postgres replica, picked on data volume.

Interview corner

CommonWalk me through how you'd approach an AWS system design question.
“I'd clarify requirements first, scale, latency, consistency, failure tolerance, then sketch the topology, call out IAM boundaries, and only then talk failure modes and cost.”
TrickWhat's the biggest mistake candidates make in these rounds?
“Listing services instead of reasoning: naming eight in the first minute looks like breadth but shows no judgment. I'd rather use three and explain why each earns its place.”
Experience checkTell me about a real architecture decision you've made, even a small one.
“I'd describe choosing between a direct write and a queue-backed write for a pipeline I built, and the failure mode I was defending against.”
DesignHow would you handle the interviewer adding a 10x scale constraint mid-answer?
“I'd name exactly which part breaks first, usually the write path, and change only that, stating the number that triggers it.”

Memory hook

A whiteboard round is a building inspection, not a bricks inventory: the inspector cares about load paths and exits, not how many brick types you can name.

If you remember only one thing:

A design that doesn't change when a constraint changes was memorised, not reasoned.

Self-check

  1. What are the five steps of the method, in order?

    Clarify requirements, draw the topology, call out IAM boundaries, state the data/consistency model, name failure modes and cost shape.

  2. What's the strongest tell of a memorised answer?

    The design doesn't change when the interviewer adds a new constraint.

  3. Why name only two or three services per layer?

    Justifying each against a requirement is the skill graded; more names dilute that signal.

Prove it

Pick one AWS service you've touched. Set a 10-minute timer and whiteboard "ingest daily CSVs, serve the latest row per key" using the five-step method, out loud. Then inject "10x the file size" and time how long it takes to say what changes. Paste the before/after notes and elapsed seconds.

aws-12-02Card 2 of 6

One end-to-end portfolio proof

HardP5 · SkippableKnow it exists8 min
portfolioevidenceiacleast-privilege

Why you care

"Walk me through something you built end-to-end" filters resumes from reality, because a bullet proves nothing and only specific, inspectable detail does. A candidate who can give the exact IAM action they had to add, the real error that broke a deploy, and a real billing figure is unmistakably different from one describing a tutorial. This card is awareness depth on purpose: a planning aid, not something you can answer if you haven't built anything.

Explain like I'm 5

A recipe card and a kitchen that still smells like you cooked tonight are different things. Anyone can recite a recipe; only the cook can tell you it needed ten more minutes than the card said.

Core concept

What counts as evidence versus a tutorial clone:

  • A git repo with commits over real time, not one squashed "initial commit."
  • IaC that applies cleanly, a terraform plan/apply you can show, not "I used Terraform."
  • A least-privilege policy you can defend line by line, not AdministratorAccess left "for now."
  • Tests that actually ran in CI, a log, not "I wrote tests."
  • An observable pipeline: real logs and metrics, not "it worked once."
  • A budget artifact: an actual Cost Explorer figure, however small.
  • A restore drill: deleted on purpose, proven back, timestamped.

Decision rule: if a follow-up number stops you cold, that section is a plan, not proof.

Under the hood

Interviewers probe by asking for a number that only exists if you ran the thing: a retention setting, an IAM error you fixed, a bill line. A plan, or an AI-assisted scaffold, can produce a plausible description but not a specific error from a specific afternoon, because that error only exists if the thing actually failed at a real time. That's why "tell me about a bug" filters sharper than "describe your architecture."

Minimal example A claim with no evidence artifact is a plan, not a proof

PythonA claim with no evidence artifact is a plan, not a proofruns
EVIDENCE_TYPES = ["repo_commits", "iac_apply_log", "iam_policy_file", "ci_run_log", "cost_artifact", "restore_drill_log"]


def score_claim(evidence):
    have = [e for e in EVIDENCE_TYPES if evidence.get(e)]
    missing = [e for e in EVIDENCE_TYPES if not evidence.get(e)]
    return have, missing


claim = {
    "repo_commits": "14 commits over 9 days",
    "iac_apply_log": "terraform apply output, 2026-08-12",
    "iam_policy_file": None,
    "ci_run_log": "GitHub Actions run #47, green",
    "cost_artifact": None,
    "restore_drill_log": None,
}

have, missing = score_claim(claim)
print(f"{len(have)}/{len(EVIDENCE_TYPES)} evidence types present")
print("still a plan for:", missing)
Output
3/6 evidence types present
still a plan for: ['iam_policy_file', 'cost_artifact', 'restore_drill_log']

In production A weekly portfolio-readiness report

Each capability is graded by how much of its required evidence actually exists, not by whether the capability sounds plausible.

PythonWeekly portfolio-readiness report, graded against required evidenceruns
from dataclasses import dataclass


@dataclass
class Capability:
    name: str
    required_evidence: list
    have: set


CAPABILITIES = [
    Capability("ETL pipeline runs end to end", ["source_to_s3_log", "s3_to_postgres_log", "row_count_match"], {"source_to_s3_log", "s3_to_postgres_log"}),
    Capability("Infra is code, not console clicks", ["terraform_plan", "terraform_apply", "state_backend_remote"], {"terraform_plan", "terraform_apply", "state_backend_remote"}),
    Capability("Access is least privilege", ["scoped_iam_policy", "denied_action_test"], set()),
    Capability("Pipeline is observable", ["cloudwatch_dashboard", "alarm_fired_once"], {"cloudwatch_dashboard"}),
    Capability("Cost is known, not guessed", ["cost_explorer_screenshot"], set()),
    Capability("Recovery is proven, not assumed", ["deleted_on_purpose", "restore_timestamp", "data_matched_after"], set()),
]

for cap in CAPABILITIES:
    pct = round(100 * len(cap.have) / len(cap.required_evidence))
    status = "PROOF" if pct == 100 else f"PLAN ({pct}% evidenced)"
    print(f"{cap.name}: {status}")
Output
ETL pipeline runs end to end: PLAN (67% evidenced)
Infra is code, not console clicks: PROOF
Access is least privilege: PLAN (0% evidenced)
Pipeline is observable: PLAN (50% evidenced)
Cost is known, not guessed: PLAN (0% evidenced)
Recovery is proven, not assumed: PLAN (0% evidenced)

See it happen The label on each box is the proof, not the box

uploadtriggerwriteloadmetricsvendor CSVS3 rawtransformS3 curatedPostgres(restore drill: 2026-08-02, 11m)CloudWatch
  1. The topology alone, drawn the way a tutorial draws it, proves nothing about who built it.
  2. Attach the IaC apply log to every box AWS actually created.
  3. Attach the least-privilege IAM boundary to the one edge each role actually needs.
  4. Attach the CloudWatch alarm and dashboard link to the observability edge.
  5. Attach the actual billing line and the restore-drill timestamp, the two evidence types most candidates skip.
Notice: the diagram looks identical in frame one whether you built it or not; the label on each box is the proof, not the box.
Scenario A

In your world

The situation

You tell an interviewer "I built a serverless ETL pipeline with Lambda, S3 and Postgres, following least-privilege IAM."

What actually breaks

They ask "what's the exact IAM action you had to add?" and you have nothing: you copied an AdministratorAccess role from a tutorial and never hit a permission error. The interviewer now discounts the rest of the answer too.

What you'd do on Monday

Build the smallest real version first, from a near-empty IAM policy, so you hit at least one real denial:

PythonTrigger a real AccessDenied, then narrow the fix to exactly that action (needs boto3 + an AWS account)
import boto3

s3 = boto3.client("s3")
try:
    s3.put_object(Bucket=BUCKET, Key="raw/test.csv", Body=b"id,amount\n1,10\n")
except s3.exceptions.ClientError as e:
    print("AccessDenied, exact action to add:", e.response["Error"]["Message"])
# Add exactly the denied action to the policy, not a wildcard, and retry.
Scenario B

Imagine you work at Flipkart

100x your weekend-project volume

The numbers

Illustrative: your project processes one 50 MB CSV/day in one Lambda invocation, ~40s. At 100x Flipkart-style volume that's 5 GB/day; one invocation would need ~100x the time, ~67 minutes, past Lambda's 15-minute ceiling before 100x.

What the Scenario-A answer does here

The scoped role, IaC and tests don't change, since it was never about scale. What breaks: one file, one invocation.

What flips at this scale

You split the file upstream into N files and fan out N invocations, or one Fargate task. Survival evidence is naming the ceiling and the flip, not guessing it "already scales."

The trade-off you'd defend

I'd defend naming the real constraint over claiming the design already scales, trading a less impressive answer for one that survives.

Illustrative, from the Lambda duration limit; your real numbers come from your own CloudWatch logs.

Gotchas

An AI-polished answer sounds too smooth

Symptom

Zero hesitation, zero specific numbers, a textbook-perfect architecture.

Cause

Generated or memorised, not lived.

Fix

Ground every claim in one artifact, a timestamp, an error, a dollar figure.

Everything is AdministratorAccess

Symptom

Can't name a single IAM action the project needs.

Cause

A tutorial attached a broad policy "for now," never narrowed.

Fix

Start from zero permissions, add exactly the action each AccessDenied names.

No cost evidence

Symptom

Can't say what the project cost last month.

Cause

Never opened Cost Explorer or set a budget.

Fix

Tag resources and pull one month of real spend.

Tricky questions

Does using Terraform or CDK for the project automatically count as "infrastructure as code" evidence?
Most people say

Yes, if the files exist in the repo.

Actually

Only if it actually ran and you can show resource IDs. Unapplied files are a draft, not evidence.

If an AI assistant helped write the Terraform, does that disqualify it as "your" project?
Most people say

Yes, any AI assistance means you can't claim it.

Actually

No. What disqualifies it is not being able to explain a decision the tool made.

Scenario question

You're handed a resume bullet: "Built a serverless data pipeline on AWS using Lambda, S3 and IAM least privilege." You have 20 minutes before an interview to decide what to actually be able to defend. What do you do?

Model answer

I'd pick the piece most likely to get a follow-up, usually the IAM claim, and make sure I can state the exact policy and the denied action I hit. If I never hit one, I'd say so rather than invent it; one caught fabrication makes the interviewer re-examine everything else.

Interview corner

CommonWalk me through something you built end-to-end.
“I'd pick the project where I can give exact detail, a specific error, a cost number, a recovery test, rather than the one that sounds most impressive.”
TrickWhat was the hardest bug in this project?
“I'd describe one real failure with the actual error text and fix, not 'debugging was challenging.'”
Experience checkHow do you know your IAM policy is least privilege?
“I started from no permissions, added exactly the action each AccessDenied named, and can list every action and what it's for.”
DesignWhat would you add first if this had to run in production?
“I'd add the restore drill and the cost tag first, since they're what separates a demo from something I'd trust with real data.”

Memory hook

A tutorial clone is a recipe card; a portfolio proof is a kitchen that still smells like you cooked tonight, with a dish you can describe going wrong.

If you remember only one thing:

If a specific follow-up number stops you cold, that section is a plan, not proof.

Self-check

  1. Name three evidence types the checklist treats as proof, not plan.

    An applied IaC log, a real CI run log, a timestamped restore drill.

  2. Why is "I used AI to help write it" not disqualifying?

    What matters is whether you can explain and defend the result.

  3. What's the single question most likely to expose a tutorial clone?

    A request for one number only present if it actually ran.

Prove it

Pick your most-claimed project, even unfinished. For each evidence type here, write the actual artifact you have today, or "none." Run the scoring function against your answers and paste the output. Turn your weakest "none" into evidence this week.

aws-12-03Card 3 of 6

From deployed Lambda to decision story

MediumP2 · Very likelyTalk about it8 min
storytellinglambdafargatedecision-record

Why you care

"Tell me about something you deployed" is the most common real interview moment at this level, and where candidates lose credibility fastest with a vague "I deployed a Lambda function" that collapses under one follow-up. Interviewers ask it to filter "clicked the button in Jenkins" from "made and can defend a decision." The gap isn't lacking a deployment; it's never turning it into a structured story.

Explain like I'm 5

Anyone can say "I won"; a lawyer who can walk the judge through the evidence and the alternative they rejected is credible. Your deployment story needs the same structure: constraint, alternatives, decision, what you tested.

Core concept

The six-part shape of a defensible decision story, in order:

  1. Constraint - what forced a decision: traffic shape, a 15-minute job limit, a cost ceiling.
  2. Alternatives considered - one real alternative and why it lost, reusing AWS compute choice's table instead of reinventing it live.
  3. Decision - the one you picked, in one sentence.
  4. Mechanics touched - packaging, the exact IAM role and scope, the network path.
  5. Release - how it got there: Jenkins, a CI pipeline, a manual call, honestly.
  6. Failure test and evidence - what broke, on purpose or not, and what the logs showed.

Decision rule: if any of the six is missing, say what you have and name the gap; a partial honest story beats a complete-sounding one that falls apart on question two.

Being honest that you clicked "deploy" in a pipeline someone else wrote is defensible if you can describe what it does. Claiming you "built the CI/CD pipeline" when you only triggered it is the fabrication that gets caught. Same with AI: say what you changed or decided yourself.

Minimal example Length isn't the signal; the six-part shape is

PythonLength isn't the signal; the six-part shape isruns
MARKERS = {"constraint": "timeout", "decision": "lambda won", "failure_test": "checkpoint"}


def covered(text):
    return [k for k, kw in MARKERS.items() if kw in text.lower()]


rambling = "so basically what happened is we had this job and after a lot of back and forth lambda seemed fine and it has been running ok since then i believe"
structured = "the constraint was a 15-minute timeout; lambda won because it is fast; i tested it and the checkpoint caught duplicates"

for name, text in [("rambling", rambling), ("structured", structured)]:
    print(f"{name} ({len(text.split())} words): {len(covered(text))}/3 -> {covered(text)}")
Output
rambling (30 words): 0/3 -> []
structured (20 words): 3/3 -> ['constraint', 'decision', 'failure_test']

In production A decision record you can defend versus one that collapses

PythonA decision record you can defend versus one that collapses on follow-upruns
from dataclasses import dataclass


@dataclass
class DecisionRecord:
    constraint: str
    alternatives: dict
    decision: str
    mechanics: dict
    release: str
    failure_test: str

    def defensible(self):
        gaps = []
        if not self.constraint:
            gaps.append("constraint")
        if len(self.alternatives) < 1 or any(not reason for reason in self.alternatives.values()):
            gaps.append("alternatives (need a named reason each lost)")
        if not self.decision:
            gaps.append("decision")
        if not all(self.mechanics.get(k) for k in ("packaging", "iam_role", "network")):
            gaps.append("mechanics")
        if "jenkins" not in self.release.lower() and "pipeline" not in self.release.lower():
            gaps.append("release (name the actual pipeline)")
        if not self.failure_test:
            gaps.append("failure_test")
        return gaps


real = DecisionRecord(
    constraint="15-minute Jenkins timeout on the nightly settlement job",
    alternatives={"EC2 cron": "idle cost 24/7 for a 3-minute job", "Fargate": "slower cold start, no benefit at this frequency"},
    decision="Lambda, triggered by EventBridge Scheduler once nightly",
    mechanics={"packaging": "container image (pandas dependency)", "iam_role": "settlement-loader: s3:GetObject on one prefix, secretsmanager:GetSecretValue on one secret", "network": "no VPC; talks to RDS over a public endpoint, SSL enforced"},
    release="Jenkins job calls aws lambda update-function-code after tests pass",
    failure_test="Killed the invocation mid-run; checkpoint table resumed the retry without duplicate rows",
)

clicked = DecisionRecord(
    constraint="",
    alternatives={"something else": ""},
    decision="We used Lambda",
    mechanics={"packaging": "zip"},
    release="the pipeline deployed it",
    failure_test="",
)

for name, rec in [("real deployment", real), ("button-click retell", clicked)]:
    gaps = rec.defensible()
    print(f"{name}: {'defensible' if not gaps else 'gaps: ' + ', '.join(gaps)}")
Output
real deployment: defensible
button-click retell: gaps: constraint, alternatives (need a named reason each lost), mechanics, failure_test

See it happen Each follow-up targets a different part of the story

InterviewerCandidateTell me about something you deployedConstraint: 15-min Jenkins timeoutWhy not EC2?Idle host costs more for a 3-min daily jobWhat can that role actually do?Two actions: read one S3 prefix, read one secretWhat have you seen break?Killed it mid-run; checkpoint prevented duplicates
  1. The opening question is deliberately vague; it rewards structure, not length.
  2. Leads with the constraint, not the service name.
  3. The first follow-up tests whether an alternative was really considered.
  4. Names the specific reason the alternative lost.
  5. The second follow-up tests mechanics, not the diagram.
  6. A specific, checkable answer, not the phrase 'least privilege'.
  7. The final follow-up tests whether this was ever actually run and watched fail.
  8. Only answerable if the failure was actually tested.
Notice: each follow-up targets a different one of the six parts; the interview isn't random, it's probing for whichever part most answers skip.
Scenario A

In your world

The situation

You deployed a small Lambda function for your learning project, reading a CSV from S3 into Postgres, triggered once manually to test it.

What actually breaks

In an interview you say "I deployed a Lambda function to process CSVs," and the first follow-up, "why not your existing Jenkins script," exposes you never compared the two.

What you'd do on Monday

Write down the actual constraint that would justify Lambda, and refuse to claim the story until it's filled in:

PythonA story with missing fields refuses to be told until they're filled inruns
class IncompleteStory(Exception):
    pass


REQUIRED_FIELDS = ["constraint", "alternative_considered", "iam_scope", "failure_test"]


def claim_story(fields):
    missing = [f for f in REQUIRED_FIELDS if not fields.get(f)]
    if missing:
        raise IncompleteStory(f"missing: {missing}")
    return "ready to tell"


draft = {"constraint": "", "alternative_considered": "", "iam_scope": "", "failure_test": ""}
try:
    claim_story(draft)
except IncompleteStory as e:
    print("IncompleteStory:", e)

draft["constraint"] = "existing Jenkins script already runs this nightly in 40s, no new constraint found"
draft["alternative_considered"] = "none needed; current script already satisfies the job"
draft["iam_scope"] = "n/a, no new deployment"
draft["failure_test"] = "n/a"
print(claim_story(draft))
Output
IncompleteStory: missing: ['constraint', 'alternative_considered', 'iam_scope', 'failure_test']
ready to tell
Scenario B

Imagine you work at Razorpay

500,000 merchant settlement files per night

The numbers

Illustrative: your real job is one file nightly. At Razorpay-style volume, 500,000 files in a 2-hour window, that's ~69 invocations/second, each wanting a Postgres write.

What the Scenario-A answer does here

One Lambda, one scoped role, a checkpoint-retry is still correct per invocation, but "let it scale to however many executions it needs" means tens of thousands of Postgres connections, which no pool survives.

What flips at this scale

The honest answer names a pooler, like RDS Proxy, or a queue-backed worker pool, with concurrency capped to what the pool serves, not "Lambda scales automatically."

The trade-off you'd defend

I'd defend naming the exact break point, connection count not invocation count, over claiming the architecture handles any scale.

Illustrative, not Razorpay-published; your actual deployment never ran at this volume, say so if asked.

Gotchas

Can't name the alternative

Symptom

Asked "why not EC2 or Fargate," the candidate says "I just picked Lambda."

Cause

Never compared the options; defaulted rather than decided.

Fix

Name one concrete reason the alternative loses, from AWS compute choice's table: duration, state, or cost.

The IAM role is AdministratorAccess

Symptom

Can't state what the role can actually do.

Cause

Copied from a tutorial, never scoped.

Fix

State the two or three actions the role actually needs.

Claims a CI/CD pipeline you only triggered

Symptom

Says "I built the deployment pipeline" but can't explain one stage of it.

Cause

Conflating running a job with authoring it.

Fix

Say precisely what you did, "I added a step to an existing pipeline," versus what existed already.

Tricky questions

Is it bad to say Jenkins just ran one CLI command and that's the whole pipeline?
Most people say

Yes, it sounds too simple to be a real deployment.

Actually

No, simple and honestly described beats complex and vague. A one-line step you fully understand beats a pipeline you can't explain.

If you can't remember the exact IAM actions, is it fine to say "least privilege" and move on?
Most people say

Yes, the term proves you know the concept.

Actually

No, specifics-free jargon invites the follow-up you can't answer.

Scenario question

You're handed 2 minutes to answer "tell me about an AWS service you've deployed," and the only thing you've actually deployed is a toy Lambda function triggered once manually from the console, with a role you copied from a tutorial. What do you say?

Model answer

I wouldn't inflate it. I'd state the real constraint, reading a CSV without a 24/7 host, mention I compared it mentally to our EC2-cron pattern, and be upfront the role is broader than it should be and say what I'd narrow it to. The trade-off I'd name is a toy project trading realism for fast iteration. That's smaller than "I deployed a production Lambda," but it survives a follow-up.

Interview corner

CommonTell me about something you deployed on AWS.
“I'd state the constraint that drove the decision, the alternative I ruled out, and one detail I can defend, rather than a summary that invites a follow-up I can't answer.”
TrickWhy Lambda and not just keep using your Jenkins box?
“I'd give the actual reason, like paying for an idle host versus a function running seconds a day, and say so if my real project doesn't have that constraint.”
Experience checkWhat was the actual IAM role scoped to?
“I'd name the exact actions, s3:GetObject on one prefix, one secret read, since 'least privilege' with no specifics gets picked apart next.”
DesignHow would this change if it had to run per-merchant at thousands of merchants a night?
“The per-invocation logic probably still works, but the connection count to Postgres doesn't, so I'd put a pooler or queue in front of it.”

Memory hook

A deployment story is a court case, not a verdict: "I won" proves nothing until you can walk through the evidence and the alternative that lost.

If you remember only one thing:

If any of the six parts is missing, say what you have and name the gap.

Self-check

  1. What are the six parts of a defensible decision story?

    Constraint, alternatives with a reason each lost, decision, mechanics, release, and a failure test with evidence.

  2. Why doesn't a short answer that just mentions Lambda, S3, IAM and Jenkins automatically pass?

    Mentioning names isn't covering the six parts with specifics.

  3. What should you say if you genuinely never hit a real IAM denial or failure while building the project?

    Say so honestly, and describe what you'd test next.

Prove it

Take one thing you've actually deployed, even console-only. Write the six-part shape as plain text, then time yourself saying it unscripted. Paste the version and your spoken time.

aws-12-04Card 4 of 6

DR and real release talk track

HardP3 · Role-dependentTalk about it8 min
disaster-recoveryrelease-processterminologyaudit-evidence

Why you care

In many enterprises, especially regulated ones, "DR" is release-process jargon for "Deployment Request," a ticket that clones a release across environments, unrelated to AWS disaster recovery (RTO/RPO, failover). If your real experience is deployment-request approvals and you call that "DR" to an interviewer who means disaster recovery, they'll ask about RTO/RPO, and the mismatch surfaces within one question. This card teaches you to scope precisely what you did.

Explain like I'm 5

"DR" is like "charge": a battery charge and a criminal charge are both real, and using one when someone meant the other gets noticed immediately.

Core concept

Two separate skill sets hide behind one abbreviation:

  • Deployment-request DR: a release ticket that clones configuration between environments, usually with approvals, a config-transformation step, validation, and a rollback plan if the clone fails. Real release-engineering experience.
  • Disaster recovery, in the AWS sense (Disaster recovery): RTO/RPO targets, backup/restore or failover between unhealthy and healthy environments, drilled, usually triggered by an outage.

If you've only done the first, say exactly that: "my DR experience is release-process cloning, I haven't run an actual failover drill." If asked about the second and you don't have it, say so and pivot to what you understand about the mechanics.

Decision rule: before answering "tell me about your DR experience," ask one clarifying question, failover or release-clone, a fair, senior-sounding move.

Under the hood

A deployment-request clone copies artifacts into a target that's already healthy; the test is "did the new version work," not "can the system survive the primary dying." A real DR drill tests the failure path: traffic moving to a secondary that wasn't serving a moment ago, under time pressure, with a stopwatch on RTO. A clone-release has no equivalent of "the primary is gone." This is why DR and clone-release operations draws the line that a release-ticket clone is not a proven DR drill: the config match isn't the hard part DR actually tests, whether the secondary serves correctly after sitting unused.

Minimal example One word, two meanings - a quick classifier shows the ambiguity

PythonOne word, two meanings - a quick classifier shows the ambiguityruns
RELEASE_WORDS = {"approval", "ticket", "clone", "deploy", "config", "rollback"}
RECOVERY_WORDS = {"rto", "rpo", "failover", "outage", "restore", "standby"}


def classify(sentence):
    words = set(sentence.lower().replace(",", "").replace(".", "").split())
    release_hits = words & RELEASE_WORDS
    recovery_hits = words & RECOVERY_WORDS
    if release_hits and not recovery_hits:
        return "deployment-request DR", sorted(release_hits)
    if recovery_hits and not release_hits:
        return "disaster-recovery DR", sorted(recovery_hits)
    return "ambiguous", sorted(release_hits | recovery_hits)


for s in [
    "I raised a DR ticket to clone the release config with approval from two teams.",
    "We measured RTO during the failover test when the primary went into outage.",
    "My DR work was the deployment ticket.",
]:
    print(classify(s))
Output
('deployment-request DR', ['approval', 'clone', 'config', 'ticket'])
('disaster-recovery DR', ['failover', 'outage', 'rto'])
('deployment-request DR', ['ticket'])

In production Flagging a DR answer that borrows recovery vocabulary without evidence

PythonFlag a DR answer that borrows disaster-recovery vocabulary without evidenceruns
RECOVERY_CLAIM_WORDS = {"rto", "rpo", "failover", "restore"}
RELEASE_EVIDENCE = ["approval_recorded", "config_transform_diff", "validation_result", "rollback_plan"]
RECOVERY_EVIDENCE = ["measured_downtime_seconds", "secondary_served_traffic", "data_matched_after_failover"]


def audit(answer_text, evidence):
    claims_recovery = bool(set(answer_text.lower().replace(",", "").replace(".", "").split()) & RECOVERY_CLAIM_WORDS)
    if claims_recovery:
        missing = [e for e in RECOVERY_EVIDENCE if not evidence.get(e)]
        kind = "disaster-recovery"
    else:
        missing = [e for e in RELEASE_EVIDENCE if not evidence.get(e)]
        kind = "deployment-request"
    return kind, missing


answer_a = "I own the DR ticket: approval, config transform, validation and rollback plan for every clone release."
evidence_a = {"approval_recorded": True, "config_transform_diff": True, "validation_result": True, "rollback_plan": True}

answer_b = "I have done DR, including RTO and failover testing."
evidence_b = {"measured_downtime_seconds": None, "secondary_served_traffic": None}

for name, text, ev in [("honest release-process claim", answer_a, evidence_a), ("borrowed recovery vocabulary", answer_b, evidence_b)]:
    kind, missing = audit(text, ev)
    print(f"{name}: scoped as {kind}, missing evidence: {missing}")
Output
honest release-process claim: scoped as deployment-request, missing evidence: []
borrowed recovery vocabulary: scoped as disaster-recovery, missing evidence: ['measured_downtime_seconds', 'secondary_served_traffic', 'data_matched_after_failover']

See it happen Only one row ever has an unhealthy node

if it failsDeploymentticketApprovalsClone +config transformValidateRollback planPrimary(healthy)Primary failsFailovertriggeredSecondaryserves trafficRTO: measured
  1. Both rows start identically plausible: steps and arrows under the same word, 'DR'.
  2. Walk the release-process row: a ticket, approvals, then a clone with config transformed for the target environment.
  3. Validation passes; nothing in this row was ever unhealthy, and rollback is a plan on paper, not something executed.
  4. Walk the recovery row instead: the primary actually fails first, the node this row needs that the top row never has.
  5. The secondary, which was not serving traffic a moment ago, takes over, and the time to do so is measured.
Notice: the release-process row never has a failed node; the recovery row's entire point is the bad node in the middle. If your story has no bad node, it is not a disaster-recovery drill.
Scenario A

In your world

The situation

You tell an interviewer "I have hands-on DR experience" because you manage deployment-request tickets weekly, cloning release config between environments with sign-offs.

What actually breaks

The interviewer, hiring SRE-adjacent, asks "what was your measured RTO on your last DR test," and you have nothing: you've never run a failover.

What you'd do on Monday

Write one sentence scoping exactly which DR you mean, and lead with it unprompted. Audit your own draft first:

PythonAudit your own draft sentence before you say it out loudruns
RECOVERY_CLAIM_WORDS = {"rto", "rpo", "failover", "restore"}


def claims_recovery_vocab(text):
    return bool(set(text.lower().replace(",", "").replace(".", "").split()) & RECOVERY_CLAIM_WORDS)


draft = "When I say DR, I mean the deployment-request release process, approvals, config transformation, validation, rollback plan, not disaster-recovery failover, which I haven't run myself."
print("uses recovery vocabulary it can't back up:", claims_recovery_vocab(draft) and "failover" in draft.lower() and "haven't run" not in draft.lower())
print("scoped honestly:", "haven't run" in draft.lower())
Output
uses recovery vocabulary it can't back up: False
scoped honestly: True
Scenario B

Imagine you work at Juspay

40 deployment-request tickets per week

The numbers

Illustrative: 40 tickets/week, each needing a config transform across ~15 environment-specific values, is ~600 substitutions a week. A 1% transcription error rate is six wrong values a week reaching approval undetected.

What the Scenario-A answer does here

The scope-and-vocabulary discipline still applies, but "two humans review the diff" doesn't scale at this volume; manual review is where errors slip through.

What flips at this scale

The flip is a templated config transform, checked by an automated diff before any human approval, turning "did I clone correctly" into a machine-checkable gate.

The trade-off you'd defend

I'd defend an automated diff-gated transform over manual review at this volume, trading templating effort for catching a bad clone before approval.

Illustrative, not Juspay-published.

Gotchas

Using "DR" without qualifying it

Symptom

The interviewer's next question doesn't match your answer at all.

Cause

Two unrelated concepts share one abbreviation.

Fix

State which DR you mean in your first sentence.

Calling a clone a disaster-recovery drill

Symptom

Can't answer "what was unhealthy" or "what was your RTO."

Cause

A deployment-request clone has no failure injected, nothing to measure recovery against.

Fix

Describe it as release-process cloning, and separately say what you know about real DR mechanics, from Disaster recovery.

No audit trail for the approvals

Symptom

Can't name who approved what, or what was validated.

Cause

Treated the approval step as a formality to click through.

Fix

Know one approval you've actually seen rejected and why.

Tricky questions

If your job title or team is called "DR," does that mean you have disaster-recovery experience?
Most people say

Yes, obviously, it's in the name.

Actually

Not necessarily. In many enterprises "DR" in release tooling means Deployment Request, a different skill from AWS disaster recovery.

Is a config-transform diff the same thing as a disaster-recovery validation?
Most people say

Yes, both check that the target environment matches expected.

Actually

No. A config-transform diff checks a planned clone matches intent before anything runs. A DR validation checks a system that wasn't serving traffic can serve correctly after taking over.

Scenario question

You're handed the question "walk me through a disaster recovery you've been part of." Your actual experience is managing deployment-request tickets with approvals and config clones, no failover drills. What do you say?

Model answer

I wouldn't pretend the ticket process is a disaster-recovery drill. I'd say my hands-on experience is release-process: tickets, approvals, config transformation, validation, and a rollback plan if validation fails, and that I haven't run an RTO/RPO failover test. I'd pivot to what I understand about backup-restore versus standby failover, to show I'm honest about where my evidence stops. It's less flashy than claiming full DR ownership, but it survives every follow-up.

Interview corner

CommonTell me about your disaster recovery experience.
“I'd ask first whether they mean a failover or a release-clone process, since I've seen both called 'DR,' then answer precisely for whichever applies to me.”
TrickWhat was your RTO on your last DR exercise?
“If I don't have a real number, I'd say so rather than estimate one, and explain my DR experience is the release-clone process, not a measured failover.”
Experience checkWhat's the hardest part of the release-clone process you've run?
“I'd point to a config value that didn't transform correctly between environments, and how the validation step, or its absence, let it through.”
DesignHow would you make a manual config-transform process safer at higher ticket volume?
“I'd template the environment-specific values and gate the ticket on an automated diff before approval.”

Memory hook

"DR" is like "charge": a battery charge and a criminal charge are both real, and using one when someone meant the other gets noticed immediately.

If you remember only one thing:

State which DR you mean before you answer, deployment-request clone, or disaster-recovery failover.

Self-check

  1. What's the key structural difference between a deployment-request DR process and a disaster-recovery drill?

    The DR drill has an actual unhealthy or failed component and measures recovery; a deployment-request clone has nothing unhealthy.

  2. What question should you ask before answering "tell me about your DR work"?

    Which DR they mean: release cloning, or disaster-recovery failover.

  3. Name one piece of evidence that makes a deployment-request DR claim credible.

    A specific approval you've seen rejected and why, or a config value a validation step caught.

Prove it

Write one paragraph describing your actual deployment-request experience using only this card's vocabulary, no disaster-recovery words. Then write a second paragraph on what DR mechanics you know only from reading. Mark every claim you could defend with a specific example.

aws-12-05Card 5 of 6

Migration narratives with cutover evidence

HardP3 · Role-dependentTalk about it9 min
migrationdmscutoverreconciliationcdc

Why you care

"Tell me about a migration you've done" is easy to fabricate badly: migrations have a predictable shape, assess, migrate, validate, cutover, easy to describe without living it. Interviewers who've run real migrations ask about the two hardest parts, reconciliation and cutover, because those are what a blog-post reader tends to skip. If you've never run one, reason through it, marked explicitly as a design, not a performed project.

Explain like I'm 5

Moving house while the family still eats dinner every night: furniture first (full load), a notepad for what changes after (CDC), a side-by-side check before anyone sleeps there (reconciliation), then cancel the lease (cutover), with a plan to move back if the plumbing's broken.

Core concept

The shape of a credible migration narrative:

  1. Source/target constraints - the engine each side, and the specific incompatibility: a data type, a procedure, case-sensitivity.
  2. Full load, then CDC where justified - DMS does a one-time full load, then switches to change data capture so the target stays in sync while the source keeps serving (DMS and database selection). CDC earns its complexity only when the source can't be frozen.
  3. Reconciliation - checksums, run repeatedly during CDC, not once at the end.
  4. Shadow or dual-run - both systems against the same input, comparing outputs; name the edge case this catches.
  5. Cutover and rollback - the moment traffic moves, a named abort trigger, how long that window stays open.
  6. Ownership - who pulls the trigger, what evidence closed it out.

Decision rule: if asked for a migration you haven't run, reason through this shape and say so.

Under the hood

DMS CDC replicates with lag; cutting over reads requires the target to have caught up past every write, or a user won't see their own write next. A real cutover needs a drain step: stop source writes, wait for lag to hit zero via sequence comparison, then flip. Rollback is asymmetric: reads are easy; writes already moved mean the source is stale, and reconciling target-only writes back is a harder migration in reverse.

Minimal example A reconciliation check during the CDC window, not just at the end

PythonA reconciliation check during the CDC window, not just at the endruns
import hashlib


def checksum(rows):
    return hashlib.sha256(repr(sorted(rows)).encode()).hexdigest()[:8]


source = [(1, "paid"), (2, "pending"), (3, "paid")]
target_after_full_load = [(1, "paid"), (2, "pending"), (3, "paid")]
target_mid_cdc = [(1, "paid"), (2, "paid"), (3, "paid")]  # row 2 changed on source, CDC hasn't caught up

print("right after full load:", checksum(source) == checksum(target_after_full_load))
print("mid-CDC, before drain:", checksum(source) == checksum(target_mid_cdc))

source[1] = (2, "paid")  # source catches up: row 2 is now paid everywhere
print("after drain, source updated:", checksum(source) == checksum(target_mid_cdc))
Output
right after full load: True
mid-CDC, before drain: False
after drain, source updated: True

In production A cutover gate that refuses to flip until lag reaches zero

PythonA cutover gate that refuses to flip reads until CDC lag reaches zeroruns
from dataclasses import dataclass


@dataclass
class MigrationState:
    source_writes: int = 0
    target_applied: int = 0
    cutover_done: bool = False

    @property
    def lag(self):
        return self.source_writes - self.target_applied

    def apply_cdc_batch(self, n):
        self.target_applied = min(self.source_writes, self.target_applied + n)

    def write_to_source(self, n=1):
        if self.cutover_done:
            raise RuntimeError("writes should go to target after cutover")
        self.source_writes += n

    def attempt_cutover(self):
        if self.lag != 0:
            return False, f"lag={self.lag}, drain first"
        self.cutover_done = True
        return True, "cutover complete, reads and writes now point at target"


m = MigrationState()
m.write_to_source(1200)        # full load snapshot taken here conceptually
m.apply_cdc_batch(1150)
print("attempt 1:", m.attempt_cutover())

m.write_to_source(0)           # stop new writes to source: the drain step
m.apply_cdc_batch(1200)
print("attempt 2:", m.attempt_cutover())

try:
    m.write_to_source(1)
except RuntimeError as e:
    print("RuntimeError:", e)
Output
attempt 1: (False, 'lag=50, drain first')
attempt 2: (True, 'cutover complete, reads and writes now point at target')
RuntimeError: writes should go to target after cutover

See it happen Cutover gated on measured lag, not a timer

AppSource DBDMSTarget DBwrites continuefull load readfull load writechange streamCDC applydrain: stop new writesfinal CDC applycutover: writes now here
  1. The app keeps writing to the source throughout the migration.
  2. DMS takes a one-time snapshot of the data that already exists.
  3. The target now has everything that existed at snapshot time, nothing since.
  4. Every write after the snapshot is captured as a change event, not re-read in full.
  5. Changes replay on the target; lag is the gap between what's written and what's applied.
  6. Drain: new writes to the source stop so lag can reach exactly zero.
  7. The last changes land; lag hits zero, confirmed by comparing sequence numbers, not a timer.
  8. Only now does the app's write path move to the target.
Notice: the app only moves to the target after lag is confirmed zero, not after a fixed wait; that confirmation step is what separates a real cutover from a guess.
Scenario A

In your world

The situation

Your team proposes migrating a reporting Postgres table to Aurora by "just dumping and restoring over a weekend."

What actually breaks

The table backs a job writing late corrections for up to 36 hours after the original row, so the dump misses corrections landing after cutover, silently diverging the databases.

What you'd do on Monday

Name the write pattern explicitly and extend CDC to cover that window, verified with a reconciliation query:

PythonChecking DMS CDC lag before declaring a cutover safe (needs boto3 + a running DMS task)
import boto3

dms = boto3.client("dms")
stats = dms.describe_replication_tasks(
    Filters=[{"Name": "replication-task-id", "Values": [TASK_ID]}]
)["ReplicationTasks"][0]["ReplicationTaskStats"]
print("full load done:", stats["FullLoadProgressPercent"] == 100)
print("cdc latency (s):", stats.get("CDCLatencySource"))
Scenario B

Imagine you work at BookMyShow

600,000 seat-state updates per day

The numbers

Illustrative: 500 screens x 8 shows a day x 150 seats a show = 600,000 seat-state rows updated a day, bursting around each showtime.

What the Scenario-A answer does here

Checksumming the whole table still works, but running it every few minutes before a release-weekend cutover adds load exactly when you can least afford it.

What flips at this scale

You reconcile incrementally, comparing only rows touched since the last check via an updated-at column, and schedule cutover for the lowest-traffic hour, not "whenever lag hits zero."

The trade-off you'd defend

I'd defend incremental reconciliation plus a scheduled low-traffic window over full-table reconciliation, trading logic complexity for a check cheap enough to run continuously.

Illustrative, not BookMyShow-published; I haven't run this migration.

Gotchas

No incompatibility named

Symptom

The candidate can't say what's actually hard about this migration beyond "moving data."

Cause

Never engaged with a real source/target mismatch: a data type, a procedure, a case-sensitivity rule.

Fix

Name one specific incompatibility and how you'd detect it: a failed schema conversion, a truncation warning.

Reconciliation only at the end

Symptom

The plan checks correctness once, after everything is "done."

Cause

Treats migration as copy-then-verify instead of continuously verifying.

Fix

Reconcile repeatedly during the CDC window.

Cutover with a fixed wait instead of a lag check

Symptom

The plan says "wait five minutes, then cut over."

Cause

Treats CDC lag as roughly constant instead of measuring it.

Fix

Gate cutover on measured zero lag, not a timer.

Treating App Runner's new-customer closure as a crisis to migrate away from immediately

Symptom

The candidate claims an urgent, already-completed migration off App Runner.

Cause

Confusing a documented restriction on new customers and new features with an imminent shutdown of the existing service.

Fix

State precisely what AWS has published, closed to new customers, existing customers continue, ECS Express Mode as the suggested path, and reason through the migration design without claiming you've already executed it.

Tricky questions

Does DMS guarantee the migration is correct once the full load finishes?
Most people say

Yes, DMS copying all rows means the migration succeeded.

Actually

No. Full load gets historical rows; only an explicit reconciliation step tells you whether source and target agree.

Is a "shadow run" the same as just testing the new system before go-live?
Most people say

Yes, running the new system in a test environment first.

Actually

Not quite. A shadow run means both systems run against the same live input and you compare outputs, catching edge cases sample data won't.

Scenario question

You're handed "we're migrating off a database AWS is restricting for new customers, tell me about a migration you'd run." You've never performed a cross-engine migration. What do you say?

Model answer

I'd be upfront I haven't run this exact migration, then reason through it rather than refuse. I'd name the likely incompatibility first, a schema gap Schema Conversion would flag, describe a full load followed by CDC, continuous reconciliation, and a cutover gated on measured lag reaching zero. The trade-off is CDC-based near-zero-downtime versus a simpler maintenance-window migration, picked on whether the source can tolerate being frozen.

Interview corner

CommonTell me about a database migration you've worked on.
“If I've run one, I'd give the source/target constraint and cutover trigger with specifics. If I haven't, I'd say so and reason through a credible design.”
TrickHow do you know the migration is correct?
“Not from the full load finishing. I'd reconcile with checksums repeatedly during CDC, and gate cutover on measured lag reaching zero.”
Experience checkWhat's the riskiest part of a cutover?
“I'd say the moment writes move to the target, since rollback stops being symmetric: reads are easy, target-only writes mean a second migration under worse conditions.”
DesignWould you use DMS for every migration?
“I wouldn't. CDC earns its complexity when the source can't be frozen; for a small dataset a full load in a maintenance window is simpler.”

Memory hook

Moving house while the family still eats dinner every night: furniture first, a notepad for what changes after, a side-by-side check before anyone sleeps there, and a plan to move back if the plumbing's broken.

If you remember only one thing:

Reconcile continuously during CDC, and gate cutover on measured lag, not a timer.

Self-check

  1. What does CDC add on top of a full load?

    Ongoing replication of changes made after the snapshot, so the source keeps serving traffic.

  2. Why is rollback harder after writes move to the target than after only reads move?

    Target-only writes must be migrated back, a harder migration; reads can simply point back.

  3. What should gate the actual cutover moment?

    Measured replication lag reaching zero, not a fixed wait.

Prove it

Using MigrationState from the production example, track a reconciliation checksum and print whether source and target match at three points: after full load, mid-CDC, and after drain. Paste the outputs and say which point your real plan actually checks.

aws-12-06Card 6 of 6

SAA certification or deliberate skip

EasyP5 · SkippableKnow it exists8 min
certificationsaaopportunity-costevidence

Why you care

"Should I get the AWS Solutions Architect Associate certification" sounds like yes/no, but it depends on what you're optimising for: a recruiter screen filtering by keyword, versus an interview that cares what you can defend. With a fixed study budget, every hour on flashcards is an hour not building the project that produces the evidence One end-to-end portfolio proof asks for. This card sits at awareness depth on purpose; it's personal time allocation, not a mechanic to execute.

Explain like I'm 5

A certificate is a parking permit, not a car. It gets you past some gates, recruiter keyword filters, but doesn't drive anywhere in the interview, where someone wants to see you drive.

Core concept

What the certification is, and isn't, per what AWS publishes:

  • The current exam is SAA-C03: 65 questions, 130 minutes, valid 3 years, with "one year of hands-on experience" recommended, not required.
  • Multiple-choice and multiple-response. It validates recognising a correct answer's shape, not that you've deployed or debugged anything, exactly the evidence Whiteboard a defensible AWS architecture through Migration narratives with cutover evidence ask for.
  • Where it helps: clearing a resume filter that lists it, or giving a forced syllabus with no other structure.
  • Where it doesn't: a hands-on round, a design round, or "tell me about something you built."

Decision rule: pursue it only if a target posting lists it, or you'd otherwise flounder with no structure. Defer it if your gap is "I haven't built anything," since that's what interviews test. Check AWS's exam guide for the exact weighting before committing time.

Minimal example Same weekly hours, two different kinds of evidence after 8 weeks

PythonSame weekly hours, two different kinds of evidence after 8 weeksruns
WEEKLY_HOURS = 10
WEEKS = 8
TOTAL_HOURS = WEEKLY_HOURS * WEEKS

CERT_HOURS_ILLUSTRATIVE = 90          # illustrative prep estimate, not AWS-published
PROJECT_HOURS_PER_EVIDENCE_UNIT = 15  # illustrative: one checklist item from aws-12-02 per ~15 focused hours

cert_progress = min(1.0, TOTAL_HOURS / CERT_HOURS_ILLUSTRATIVE)
project_evidence_units = TOTAL_HOURS // PROJECT_HOURS_PER_EVIDENCE_UNIT

print(f"{TOTAL_HOURS} hours over {WEEKS} weeks")
print(f"cert path: {cert_progress:.0%} through exam-ready prep, 0 deployable evidence units")
print(f"project path: {int(project_evidence_units)} deployable evidence units, 0 certificate")
Output
80 hours over 8 weeks
cert path: 89% through exam-ready prep, 0 deployable evidence units
project path: 5 deployable evidence units, 0 certificate

In production A decision rule applied to three different candidates

PythonA decision rule applied to three different candidatesruns
def recommend(job_requires_cert, has_study_structure, has_deployed_project):
    if job_requires_cert:
        return "pursue now", "target posting explicitly lists it"
    if not has_study_structure and not has_deployed_project:
        return "pursue as structure", "no other forcing function for AWS breadth yet"
    if has_deployed_project:
        return "defer", "deployed evidence answers more interview questions per hour spent"
    return "defer", "build study structure around a project instead of flashcards"


candidates = {
    "targeting a posting that lists SAA": recommend(True, False, False),
    "no project yet, no study plan": recommend(False, False, False),
    "has a deployed least-privilege pipeline": recommend(False, True, True),
}

for name, (decision, reason) in candidates.items():
    print(f"{name}: {decision} - {reason}")
Output
targeting a posting that lists SAA: pursue now - target posting explicitly lists it
no project yet, no study plan: pursue as structure - no other forcing function for AWS breadth yet
has a deployed least-privilege pipeline: defer - deployed evidence answers more interview questions per hour spent
Scenario A

In your world

The situation

You're deciding between two months of SAA flashcards or finishing the least-privilege IaC pipeline from One end-to-end portfolio proof's checklist.

What actually breaks

You pass a mock exam at 85% but still can't answer "walk me through something you built," because the certification taught recognition, not debugging a real AccessDenied error.

What you'd do on Monday

Apply the decision rule honestly; if no target posting lists the certification, redirect the hours to the project:

PythonApply the decision rule to your own situation, not a hypothetical oneruns
def recommend(job_requires_cert, has_study_structure, has_deployed_project):
    if job_requires_cert:
        return "pursue now"
    if not has_study_structure and not has_deployed_project:
        return "pursue as structure"
    return "defer"


# Fill these in honestly before deciding where your next weekend goes.
my_situation = recommend(
    job_requires_cert=False,
    has_study_structure=False,
    has_deployed_project=False,
)
print("recommendation:", my_situation)
Output
recommendation: pursue as structure
Scenario B

Imagine you work at Groww

400 applicants per posting

The numbers

Illustrative: a recruiter screen for one posting at Groww-scale gets ~400 applications. If the ATS filters out resumes missing a preferred keyword, removing ~60% regardless of skill, 240 never reach a human. Of the 160 that do, certification has no effect on the rounds that follow.

What the Scenario-A answer does here

The job-posting-driven decision rule still applies, but "always get certified in case a filter needs it" ignores that the filter only matters for that first stage.

What flips at this scale

At hundreds of applicants, the flip is to check the postings you're targeting for the literal keyword first, and only pay the time cost if it's there; otherwise the hours buy more via the deployable project.

The trade-off you'd defend

I'd defend targeted certification over blanket certification, trading the risk of a keyword filter for hours spent on evidence that survives every later round.

Illustrative, not Groww-published.

Gotchas

Certification as a substitute for a portfolio

Symptom

The resume lists SAA-C03, but the first follow-up, "show me something you built," gets a blank.

Cause

Treated the exam as the finish line instead of a syllabus.

Fix

Use study time to also deploy one real artifact per domain, not just answer practice questions.

Assuming the exam proves hands-on experience

Symptom

A hiring manager asks a mechanics question the exam doesn't cover, and the candidate conflates "I'm certified" with "I know this."

Cause

Multiple-choice recognition isn't the same depth as having debugged the real thing.

Fix

Say what you know from the syllabus versus what you've actually run.

Letting the cert expire without noticing

Symptom

The resume claims a certification no longer valid under its renewal terms.

Cause

The credential has a stated validity period candidates forget to track.

Fix

Check the current validity period on AWS's own page, and recertify or remove it on time.

Tricky questions

Will a certification get you shortlisted for a product-company role over someone with a deployed project but no certification?
Most people say

Yes, certifications are usually weighted higher since they're official.

Actually

Usually not past the first filter. Most interviewers weight demonstrated work over a credential, since it doesn't test debugging a real failure.

If the job posting doesn't mention certification, is it still worth getting "just in case"?
Most people say

Yes, more credentials can only help.

Actually

Not against a fixed hours budget. Prep hours for a filter that isn't there are hours not spent on defensible work.

Scenario question

You're handed two job postings: one explicitly requires "AWS Certified Solutions Architect - Associate," the other says "AWS experience preferred" with no certification mentioned. You have a fixed weekly hours budget and no certification yet. How do you split your time?

Model answer

I'd check which posting I'm more likely to apply to and qualify for first. If the certification-required one is a real target, I'd prioritise exam prep, treating the syllabus as a forcing function while still deploying one real example per domain. For every round after any screen, I'd put my hours into the deployable project from One end-to-end portfolio proof, since that's what the technical rounds actually test. If neither is a near-term target, I'd skip certification entirely.

Interview corner

CommonDo you have any AWS certifications?
“I'd answer honestly, and pivot immediately to something specific I've deployed, since that's usually what the rest of the interview is testing.”
TrickIsn't a certification proof you know AWS?
“It proves I can recognise correct answers on a broad syllabus, useful breadth, but it doesn't prove I've debugged a real failure, which I'd rather demonstrate with specifics.”
Experience checkWhy didn't you pursue certification earlier?
“I weighed it against building a deployable project with limited hours, and chose the project because it survives follow-ups, not just a resume keyword.”
DesignIf you had to recommend certification or a project to a junior engineer with limited time, which would you pick?
“I'd ask whether a specific posting requires it. If not, I'd recommend the project, since it answers 'tell me about something you built,' which comes up far more often.”

Memory hook

A certificate is a parking permit, not a car: it gets you past some gates, but nobody at the technical round wants to see your permit, they want to see you drive.

If you remember only one thing:

Get certified only when a specific posting requires it, or when you have no other structure for AWS breadth; otherwise, build the deployable project.

Self-check

  1. What two conditions does the decision rule say justify pursuing certification now?

    A target posting lists it, or you have no other forcing function and would otherwise flounder.

  2. What can the SAA-C03 exam format not prove about you?

    That you've deployed, debugged or paid for anything; it tests recognition, not execution.

  3. Per the exam's own recommended background, how much hands-on experience does AWS suggest before attempting it?

    At least one year, recommended, not required.

Prove it

Pull up two real job postings you'd apply to. Note whether each lists certification as required or preferred. Run recommend() with honest answers for each, and paste both outputs plus what you'll do with your next two weekends.