Skip to Content
Cloud Engineering Academy
17. Daily-Work Playbooks & Career

Portfolio guide: presenting your seven capstones

Turn the seven capstone projects into a portfolio a hiring manager can assess in ten minutes: a landing page, a README, diagram, ADR, cost and teardown standard for each capstone, a three-minute demo script, a blameless incident report and a hygiene checker for secrets and compliance claims.

intermediate⏱ 2 h 30 min🟢 FreeSAA-C03DVA-C03SCS-C03

Assumes: .NET 10 LTS · AWS CLI v2 · Git · Region us-east-1. Verified against official sources on 2026-11-18.

Learning objectives

By the end of this lesson you can:

  • Explain who reads a portfolio, what they look for in the first two minutes and what makes them stop reading.
  • Structure a portfolio repository: a landing page that links to seven capstone repositories, each with the same README skeleton.
  • Write a capstone README that covers the problem, architecture, security controls, cost estimate, teardown, limitations and a demo, using only claims you can back with evidence.
  • Draw a readable architecture diagram and write at least two architecture decision records (ADRs) per capstone.
  • Record and rehearse a three-minute demo, and write a blameless incident report for a playbook scenario you reproduced.
  • Run an automated hygiene check for secrets, real account IDs, missing sections and compliance claims before you publish anything.

Prerequisites

Why this matters in banking

A hiring manager at a bank may read forty applications for one role. Most CVs list services. A good portfolio lets a busy reader answer the questions they actually have: Can this person build something that works? Do they think about security and failure? Can they explain a decision? Are they honest about limits? The portfolio is evidence for all four, and it works only if it is easy to read and safe to publish.

Safety matters here more than in most fields. A public repository is permanent in practice, and the mistakes people make are costly: a committed access key, a real account ID in a screenshot, a diagram copied from an employer, a README that says "PCI compliant" when nobody assessed anything. Any of those can end an application, and the last two can also create legal and professional trouble. A banking-aware candidate shows judgement by what they leave out as much as what they include.

Market and salary claims

This lesson makes no claims about the job market, hiring volumes or salary. If a number matters to you, check current postings and surveys for your market and be sceptical of any single source. ⚠ VERIFY anything you read.

The idea in plain language

A portfolio is a small set of well-explained things you built, arranged so a stranger can understand them quickly. Three principles:

  1. Show, then explain. A reader should see a diagram, a table of controls and a short demo before they read any prose.
  2. Evidence, not adjectives. "Secure" is an adjective. "Public access blocked, KMS-encrypted, least-privilege role with a policy test, GuardDuty enabled" is evidence. Numbers appear only if you measured them.
  3. Name the limits. A section titled "What I would do next" or "Known limitations" is a strength. It shows you can see the gaps in your own work.

Analogy: A portfolio is a shop window, not a warehouse. The window displays the best seven items, clearly lit, with price tags and honest descriptions. The warehouse behind it (your full repositories) is available to anyone who walks in, but the window decides whether they do.

The reader's ten minutes

MinuteWhat the reader doesWhat they need from you
0 to 1Opens the landing pageA one-paragraph summary, a table of seven capstones with one line each and links
1 to 3Opens one capstone READMEA diagram, a statement of the problem and a table of security controls
3 to 6Skims the repositoryA clear folder structure, tests, IaC and ADRs
6 to 8Looks for honestyCost estimate, teardown steps, limitations
8 to 10Decides whether to call youA short demo, an incident report and a clear next step

What problem the portfolio solves

It converts "I did a course" into "here is what I built and how I think". Honest limits:

  • A portfolio built from a course is not the same as production experience. Say so, and let the quality of the work and the reasoning carry the weight.
  • Reviewers do not run your code. They scan. Design for scanning.
  • Employers differ. Some will never open a repository. The portfolio still helps you in interviews, because every capstone becomes a story with evidence (see the interview lessons).

The seven capstones and how to present each

Use the same skeleton for every capstone, and let each one demonstrate something different.

#CapstoneWhat it provesThe one diagram to showThe ADRs worth writing
1Secure Digital Banking REST APILayered security, private networking, authorisation testsRequest path from client to database with trust boundariesFargate versus Lambda; Aurora versus DynamoDB; authorisation model
2Event-Driven Transaction ProcessingIdempotency, saga with compensation, DLQ and redriveSequence of a payment with a failing step and its compensationSQS versus EventBridge; saga orchestration versus choreography
3Banking Data Engineering PipelineData quality, PII masking, governed analyticsRaw to curated to Athena flow with the quarantine pathParquet and partitioning; masking approach; retention
4Complete .NET CI/CDSafe delivery: OIDC, scanning, approvals, rollbackPipeline stages with the approval gate and rollback pathDeployment strategy; secrets in the pipeline
5Highly Available Banking ApplicationMulti-AZ design, backup, tested DRMulti-AZ layout and the DR path with RTO and RPODR strategy choice; database failover design
6Legacy .NET Framework MigrationAssessment, migration, cut-over and rollback planningThe 7 Rs decision and the cut-over timelineRehost versus replatform; data migration approach
7Secure Multi-Account Landing Zone (lite)Guardrails as code, central logging, identityOU structure with SCPs and log archiveAccount structure; guardrail design

You do not need all seven to be equally polished. Two or three excellent capstones beat seven thin ones. Mark each honestly as complete, designed and partially built or design only.

Microsoft / Azure comparison

If you have a developer portfolio from the Microsoft world, most of it carries over. What changes is the platform vocabulary and the evidence a cloud reader expects.

You know (Microsoft/Azure)AWS equivalentWhat to show
GitHub repo with an Azure DevOps or Actions pipelineThe same repository with GitHub Actions deploying to AWS through OIDCThe workflow file, the role trust policy and no stored keys
Bicep or ARM templatesCDK (C#) or TerraformThe infrastructure code plus a cdk diff or terraform plan summary
Architecture diagram in VisioMermaid in the README, or an exported diagramA diagram that renders in the browser and lives in version control
Azure Well-Architected reviewAWS Well-Architected Tool reviewA short review record with findings and what you changed
Azure Cost Management estimateAWS Pricing Calculator estimate and a teardownA table of cost drivers with assumptions flagged, and a verified teardown
Azure Policy and Defender recommendationsSCPs, Config rules, Security HubA table of controls: prevent, detect, respond
Runbooks in the wikiPlaybooks in docs/A runbook plus one incident you reproduced and wrote up

Architecture

The shape of the portfolio

The repository layout for each capstone

Step-by-step implementation

Decide what goes in and what stays out

Choose the capstones that are complete enough to demonstrate. Decide what stays private: anything derived from a current or former employer, real data, real account details, screenshots of consoles that show account IDs, and personal contact details beyond what you want public. If in doubt, leave it out or redo it with fictional data.

Write the landing page

One screen: who you are in two sentences, what the portfolio shows, a table of the seven capstones with status (complete, partial, design only) and a link each, a link to the incident report, and how to contact you. No logos of services as decoration, and no skills bar charts. A table of what you built beats a cloud of buzzwords.

Apply the README skeleton to each capstone

Use the skeleton below. Fill every heading, even if the answer is "not covered". The headings are what the checker script verifies and what a reviewer scans for.

Add diagrams and ADRs

One diagram in the README (context level) and one or two in docs/architecture.md (detail, failure path). At least two ADRs per capstone, each with alternatives and consequences. Use the template from the architect interview lesson.

Write the cost and teardown sections

State the estimated cost to deploy and run for one hour and for one month, the assumptions, and the top three cost drivers. Show the exact teardown commands and how you verified nothing was left billing. If you did not deploy it, say "design only" and give the estimate with the pricing assumptions flagged ⚠ VERIFY.

Record a three-minute demo

Use the script below. Record the screen with fictional data only. Host the video where you control access, or include a GIF and a transcript in the README.

Write the blameless incident report

Take one playbook scenario you reproduced and write it up with the template below. It is the best single piece of evidence that you think like an operator.

Run the hygiene checker, then ask a person to review

Run the script in the Complete code section on your capstone folders and fix every failure. Then ask a colleague who did not build it to read one README for ten minutes and tell you what they understood. Fix what confused them.

The capstone README skeleton

README.md
# Capstone 1: Secure Digital Banking REST API

> Status: complete | partial | design only. Fictional data only.

One paragraph: the problem, who the (fictional) users are, and what the system does.

## Architecture
(Context diagram, in mermaid. Two or three sentences explaining the data flow.)

## What this demonstrates
- Three or four bullets, each tied to evidence in the repository (a test, a policy, a diagram).

## Security controls
| Layer | Control | Evidence in this repo |
|---|---|---|
| Identity | Cognito, least-privilege task role | infra/iam.cs, tests/AuthorisationTests.cs |
| Network | Private subnets, VPC endpoints | infra/network.cs |
| Data | KMS encryption, TLS only | infra/data.cs |
| Logging | CloudTrail, structured logs, correlation IDs | docs/runbook.md |

## Decisions
Links to docs/adr/0001-... and docs/adr/0002-...

## Cost
Estimate for one hour and one month, the assumptions (flagged where unverified) and the top three drivers.

## Teardown
The exact commands, and how I confirmed nothing was left running.

## Demo
Link to the three-minute recording and a short transcript.

## Known limitations and next steps
What this does not do, what I would do with another week, and what a real bank would still need (review by security and compliance).

The three-minute demo script

TimeWhat you showWhat you say
0:00 to 0:20The README diagram"This is a fictional bank's account API. The goal was a customer who can see only their own accounts, safely."
0:20 to 1:20The system working"Here is a request as customer A; now the same request as customer B returns nothing. This is the authorisation test."
1:20 to 2:00A failure being handled"I send the payment twice with the same key. Only one is created. Here is the audit event."
2:00 to 2:30The evidence"Security controls are in this table and each links to code or a test. Costs and teardown are here."
2:30 to 3:00The honest limits"It does not handle X. With more time I would do Y. A bank would also need a security and compliance review."

Rehearse it twice, record it once, and cut anything that does not appear in the timetable.

The blameless incident report template

Use this for the module project. It is a real operating document, so write it as if you were handing it to a manager and an auditor.

incident-report.md
# Incident report: duplicate payment on client retry (reproduced in a lab)

- **Status:** Resolved (lab reproduction). **Severity (fictional):** High, customer money affected.
- **Author:** (you). **Date written:** 2026-11-18.
- **Note:** This was reproduced with fictional data in a lab environment, not a production incident.

## Summary
Two sentences: what happened, who or what was affected, how it was resolved.

## Impact
What the customer saw, how many payments were affected (in the reproduction), for how long.

## Timeline (UTC)
| Time | Event |
|---|---|
| 10:00 | Client submits payment P-1; response times out |
| 10:01 | Client retries; a second payment is created |
| 10:15 | Duplicate is detected by a reconciliation query |
| 10:40 | Idempotency key and conditional write added; test passes |

## Root cause
The API created a payment on every request, so a retry created a second payment. No idempotency key existed.

## What went well
Detection by reconciliation; clear logs with correlation IDs.

## What went badly
No automated test covered the retry path; no alert on duplicate business keys.

## Where we got lucky
The duplicate was caught before settlement in this scenario.

## Actions
| Action | Owner | Due | Status |
|---|---|---|---|
| Add idempotency key with conditional write | (you) | done | Done |
| Add retry test to the pipeline | (you) | done | Done |
| Add alarm on duplicate business keys | (you) | next | Open |

## Evidence kept
Links to the logs, the test, the ADR and the change record.

"Blameless" means the report describes what the system and process allowed, not who to blame. It names roles and decisions, not people.

AWS Console instructions

Not applicable: the portfolio itself needs no console steps. When you capture evidence for a capstone, use Console → AWS Pricing Calculator for the estimate (it bills nothing) and Console → Billing and Cost Management to confirm costs after a deployment. Never publish screenshots that show account IDs, email addresses or ARNs with real account numbers.

AWS CLI

Not applicable for the portfolio. Two commands help you prove a clean teardown for the README.

# List anything in the account still tagged for a capstone (should return nothing after teardown).
aws resourcegroupstaggingapi get-resources --tag-filters Key=Project,Values=capstone-1 \
  --query 'ResourceTagMappingList[].ResourceARN' --profile learn-sandbox

# Check yesterday's cost by service to confirm nothing is still billing (Cost Explorer data lags up to about a day).
aws ce get-cost-and-usage --time-period Start=2026-11-17,End=2026-11-18 \
  --granularity DAILY --metrics UnblendedCost \
  --group-by Type=DIMENSION,Key=SERVICE --profile learn-sandbox --region us-east-1

Infrastructure as Code

Not applicable to the portfolio page itself. Each capstone's infra/ folder holds its CDK or Terraform code, and its README should show how to run cdk diff or terraform plan without deploying, so a reviewer can see what would be created. If you add a repository-level check, run the hygiene script in a GitHub Actions workflow on every push.

Complete code

A portfolio hygiene checker. Point it at the folder that contains your capstone repositories. For each immediate subfolder it checks that the README has the required headings, that an ADR, a diagram and a LICENSE exist, that no AWS access key or private key appears, that no real-looking 12-digit account IDs appear and that the README does not claim to be "compliant" or "certified". It returns exit code 1 if anything fails, so you can run it before each publish or in CI. It needs only Bash and grep.

check-portfolio.sh
#!/usr/bin/env bash
# Portfolio hygiene checker. Usage: ./check-portfolio.sh <folder-containing-capstone-repos>
# Each immediate subfolder is treated as one capstone repository.
# Exit code 0 = all checks passed, 1 = at least one problem found, 2 = bad usage.
set -u

root="${1:-}"
if [ -z "$root" ] || [ ! -d "$root" ]; then
  echo "usage: $0 <folder-containing-capstone-repos>" >&2
  exit 2
fi

problems=0
fail() { echo "  FAIL  $1"; problems=$((problems + 1)); }
pass() { echo "  ok    $1"; }

# Headings every capstone README must contain (case-insensitive).
required_headings=("architecture" "security" "cost" "teardown" "demo" "limitations")

# Patterns that must never appear in a public repository.
# AKIA/ASIA are the prefixes of AWS access key IDs; the second pattern catches a pasted secret key assignment.
secret_regex='(AKIA|ASIA)[A-Z0-9]{16}|aws_secret_access_key[[:space:]]*[=:][[:space:]]*[A-Za-z0-9/+=]{30,}|-----BEGIN (RSA |EC |OPENSSH )?PRIVATE KEY-----'

for repo in "$root"/*/; do
  [ -d "$repo" ] || continue
  name=$(basename "$repo")
  echo "== $name"

  readme="$repo/README.md"
  if [ ! -f "$readme" ]; then
    fail "README.md is missing"
  else
    pass "README.md exists"
    for h in "${required_headings[@]}"; do
      if grep -qiE "^#{1,3} .*${h}" "$readme"; then pass "README has a '${h}' section"
      else fail "README has no '${h}' heading"; fi
    done
    if grep -qiE 'compliant|certified' "$readme"; then
      fail "README uses 'compliant' or 'certified': describe controls, never claim compliance"
    fi
  fi

  if ls "$repo"/docs/adr/*.md >/dev/null 2>&1; then pass "at least one ADR in docs/adr"
  else fail "no ADR found in docs/adr/*.md"; fi

  if grep -rqE '```mermaid' "$repo" --include='*.md' 2>/dev/null \
     || ls "$repo"/docs/*.png "$repo"/docs/*.svg >/dev/null 2>&1; then pass "an architecture diagram is present"
  else fail "no diagram (mermaid block, docs/*.png or docs/*.svg)"; fi

  if [ -f "$repo/LICENSE" ]; then pass "LICENSE present"; else fail "LICENSE missing"; fi

  # Look for secrets in files; skip build output and .git.
  hits=$(grep -rEn "$secret_regex" "$repo" \
         --exclude-dir=.git --exclude-dir=bin --exclude-dir=obj --exclude-dir=node_modules 2>/dev/null | head -3)
  if [ -n "$hits" ]; then fail "possible secret found:"; echo "$hits" | sed 's/^/          /'
  else pass "no obvious secrets"; fi

  # Real account IDs are not secrets, but a portfolio should use the documentation placeholders.
  ids=$(grep -rEoh '\b[0-9]{12}\b' "$repo" --include='*.md' --include='*.json' --include='*.yml' \
        --exclude-dir=.git --exclude-dir=bin --exclude-dir=obj 2>/dev/null \
        | grep -vE '^(111122223333|123456789012)$' | head -1)
  if [ -n "$ids" ]; then fail "12-digit number found ($ids): if it is an account ID, replace it with 111122223333"
  else pass "no real-looking account IDs"; fi
done

echo
if [ "$problems" -eq 0 ]; then echo "All checks passed."; exit 0; fi
echo "$problems problem(s) found."; exit 1

Run it:

chmod +x check-portfolio.sh
./check-portfolio.sh ~/portfolio

Example output for one capstone that is missing several things (abridged):

== capstone-2-events
  ok    README.md exists
  FAIL  README has no 'security' heading
  FAIL  README uses 'compliant' or 'certified': describe controls, never claim compliance
  FAIL  no ADR found in docs/adr/*.md
  FAIL  LICENSE missing

4 problem(s) found.

Code explained line by line

  1. set -u makes the script stop on an unset variable instead of quietly continuing. root="${1:-}" provides an empty default so the usage message can run.
  2. fail and pass helpers print a result and keep a count of problems. The final exit code depends on that count, so the script works in CI.
  3. required_headings is the list from the README skeleton. The grep -qiE "^#{1,3} .*${h}" pattern matches a Markdown heading of level 1 to 3 that contains the word, ignoring case.
  4. The compliant|certified check is deliberately crude. It also flags "non-compliant" and "not certified", so read each hit: the point is to make you look at every place you use those words and ensure none claims your project meets a standard.
  5. ADR, diagram and LICENSE checks look for files in the places a reviewer expects. A Mermaid block in any Markdown file counts as a diagram.
  6. secret_regex matches AWS access key ID prefixes (AKIA and ASIA followed by 16 uppercase letters or digits), a pasted secret key assignment and private key headers. It is a safety net, not a scanner: a dedicated secret-scanning tool in your pipeline is better, and any key that was ever committed must be treated as leaked and rotated, even after you delete it.
  7. Account ID check. An AWS account ID is a 12-digit number. IDs are not secrets in the cryptographic sense, but they help an attacker and identify your environment. The script allows the documentation placeholders 111122223333 and 123456789012 and flags any other 12-digit number so you can check it. It will also flag unrelated 12-digit numbers; that is an acceptable false positive.
  8. Exit codes. 0 for success, 1 for problems, 2 for bad usage. That makes it safe to use as a pre-publish step.

Security considerations

⚠ Learning shortcut — not for production

The checker is a basic safety net built from grep. It does not understand file types, encodings or history. It cannot see secrets already committed in earlier Git commits, secrets in images or screenshots, or personal data in a PDF. Before publishing, also run a dedicated secret-scanning tool over the full Git history, and if a credential was ever committed, revoke and rotate it first, then clean the history.

  • Secrets. Never commit access keys, tokens or private keys. Use SSO profiles locally and OIDC from pipelines. If one slips in, treat it as compromised: deactivate it in IAM, create a replacement, then deal with the repository.
  • Account IDs and ARNs. Replace with 111122223333 in READMEs, screenshots and logs. Crop console screenshots so they do not show account names, emails or IDs.
  • Employer material. Do not publish architecture, diagrams, code, runbooks, vendor names or incident details from a current or past employer. Your contract and professional standing depend on it. Describe patterns using fictional data.
  • Personal data. Use only synthetic data. For card numbers, use only official test ranges.
  • Never claim compliance. Write "this design applies these controls" and "would need review by security and compliance". Do not write "PCI compliant", "GDPR compliant" or "bank-grade". A badge you did not earn is a risk to you.
  • Cloud accounts. Do not publish links to live endpoints of deployed capstones unless you intend them to receive traffic and cost. Tear down, and provide a recorded demo instead.
  • Licensing. Add an explicit LICENSE. Respect the licences of any sample code you reused, and credit the source in the README.

Banking use case

Lena, a fictional candidate with a .NET banking background, publishes a portfolio. Her landing page has a two-sentence introduction, a table of seven capstones with status, and a link to a blameless incident report. Capstones 1, 2 and 4 are complete; 3 and 5 are partial; 6 and 7 are design only, and she says so in the table.

A hiring manager at a bank opens Capstone 2. In the first screen she sees a sequence diagram of a payment with a failing step and its compensation, a short statement that the demo uses fictional data and a table of controls linking to the tests that prove each one. She reads the ADR that chose SQS over EventBridge for the payment work queue, with two rejected options and the switch condition. In the cost section she sees an hourly estimate with the pricing assumptions flagged, the three cost drivers and the exact teardown commands, plus a line confirming that nothing tagged capstone-2 remained. The limitations section says the design has no multi-Region failover and that a bank would still need a security and compliance review.

Nothing in the README says "compliant". No account IDs appear. The incident report describes a duplicate payment reproduced in a lab, and its action table has one open item. The manager notes the honesty, forwards Lena to the engineering lead, and the interview begins with her demo. The portfolio did not pass any test of volume; it passed a test of judgement.

Common mistakes

  • A wall of buzzwords. Why: wanting to look broad. Avoid: a table of what you built and the evidence for it.
  • No limitations section. Why: it feels like admitting weakness. Avoid: write it; it reads as maturity.
  • Claiming compliance. Why: sounds reassuring. Avoid: describe controls and name who would need to review.
  • Publishing a repository with a key in history. Why: deleting the file does not delete the commit. Avoid: scan history, rotate any exposed key and rewrite or recreate the repository.
  • Screenshots with account IDs or emails. Why: console pages show them. Avoid: crop or use diagrams and text output.
  • Inflated numbers. Why: wanting to impress. Avoid: only state numbers you measured and say how.
  • Seven shallow capstones. Why: completeness anxiety. Avoid: do two or three well and mark the others honestly.
  • Diagrams that do not render. Why: image exports that are out of date. Avoid: Mermaid in Markdown, versioned with the code.
  • Leaving resources running. Why: forgetting teardown. Avoid: script the teardown, run it, and check cost the next day.

Troubleshooting

SymptomLikely causeFix
The checker reports every README heading missingHeadings use different wording (for example "Safety" instead of "Security")Rename the headings to the required words
The checker flags a number that is not an account IDAny 12-digit number triggers the checkConfirm it is not an account ID, or reformat it (for example with separators)
The checker flags "compliant" in your honest disclaimerThe pattern is crudeReword ("meets the bank's review requirements" is also a claim), or accept the hit after reading it
A Mermaid diagram does not render on GitHubSyntax error or unsupported featureTest it in the Mermaid live editor, simplify the labels and avoid special characters in node text
An old key appears in Git historyCommitted earlier and deletedRotate the credential first, then remove it from history or recreate the repository
The demo video is too longTrying to show everythingCut to the timetable; put detail in the README
A reviewer says they could not tell what you builtThe README starts with setup instructionsStart with the problem, the diagram and what it demonstrates
The teardown leaves chargesResources outside the stack (log groups, snapshots, buckets with versioning)List by tag, check Cost Explorer after a day and add those items to the teardown script

Cost and cleanup

Cost: free. Writing a portfolio costs nothing. Publishing repositories on GitHub is free for public repositories under normal use ⚠ VERIFY current plan limits, and GitHub Pages is optional ⚠ VERIFY. Deploying capstones costs money only if you deploy them; use the recorded demo instead of leaving anything running.

# Confirm nothing tagged for any capstone is still deployed.
for n in 1 2 3 4 5 6 7; do
  echo "capstone-$n:"
  aws resourcegroupstaggingapi get-resources --tag-filters Key=Project,Values=capstone-$n \
    --query 'ResourceTagMappingList[].ResourceARN' --profile learn-sandbox
done

# Remove local build output before you publish a repository.
find . -type d \( -name bin -o -name obj -o -name node_modules \) -prune -exec rm -rf {} +

Exercises

  • 🟢 Guided: Create the landing page and one capstone README from the skeleton. Run the checker on that capstone and fix every failure.
  • 🟡 Challenge: Write two ADRs for a second capstone, a three-minute demo script and a cost table with the assumptions flagged. Ask a colleague to read the README for ten minutes and tell you what they understood and what confused them.
  • 🔴 Live problem: You find that a repository you published last week contains a committed access key in an early commit. Nobody has noticed. Describe the order of actions, what you check afterwards (CloudTrail for use of the key) and what you would write in a short incident note.

Assignment

Publish the portfolio and incident report (the module project): a landing page covering your completed capstones (1 to 7, with honest status), each with architecture, security controls, a cost estimate and teardown notes, plus a blameless incident report for one playbook scenario you reproduced. Include the hygiene checker's output. Use fictional data only.

Solutions

Knowledge check

Interview questions

  • Walk me through one project in your portfolio. Start with the problem, show the diagram, explain two decisions with their alternatives, describe a failure you handled and state what you would do next.
  • How do you make sure what you publish is safe? Fictional data, no employer material, secret scanning over the history, placeholder account IDs, cropped screenshots, no compliance claims and a review by another person.
  • What did you learn from your incident report? The cause, the detection gap, the test that would have caught it, and what you changed so it cannot recur.
  • How do you decide what to include? By what demonstrates judgement: security, failure handling, cost awareness and clear communication, in a few complete projects rather than many shallow ones.
  • What would you improve first? Name a specific limitation from a capstone and the first step you would take to address it.

Certification practice

Completion checklist

  • I wrote a landing page with an honest status for each capstone
  • Each published capstone has the README skeleton, a diagram, two ADRs, a cost section and teardown commands
  • I recorded and rehearsed a three-minute demo
  • I wrote a blameless incident report for a reproduced scenario
  • The hygiene checker passes, and I scanned the Git history for secrets
  • No employer material, real data, account IDs or compliance claims appear anywhere

Key takeaways

  • A portfolio is a shop window: a few well-explained, safe, honest projects, easy to scan.
  • Use one README skeleton for every capstone, and show evidence rather than adjectives.
  • Name the limits, flag unverified assumptions and never claim compliance.
  • Treat any committed credential as leaked: rotate first, clean up second.
  • Check before you publish: script it, then ask a person to read it.

Further reading

Independent learning resource — not affiliated with, endorsed or sponsored by Amazon Web Services. AWS and related marks are trademarks of Amazon.com, Inc. or its affiliates. All banking data in examples is fictional. Sample architectures are for learning and are not automatically compliant with GDPR, PCI DSS or any banking regulation.

On this page