Advanced Full-Stack Capstone Project
On this page
Learning Objective
Combine skills from the advanced track by taking three features to production quality, each with a design document, threat model, tests, observability, an operational plan and a privacy review, and present the decisions and trade-offs to a review panel.
Concept Explanation
Day 100 asked you to build and defend a whole system. This second capstone is narrower and deeper, because the advanced track was about the qualities that separate a working feature from a production feature. You choose three features from the track and treat each one as if it were going live for paying customers next month. A good set spans the stack and touches security in different ways. For example: passkey sign-in with recovery from Day 132, search with security trimming from Day 115 or billing with webhooks from Day 125, and an offline-capable board from Day 108 or an AI assistant from Day 138. Choose features that interest you and that you can describe honestly, and build on your Day 100 system or on the Task Board from the projects.
Production quality is a checklist, and the Azure Well-Architected Framework provides the pillars to organize it: reliability, security, cost optimization, operational excellence, and performance efficiency. For each feature, produce the same set of artifacts. A design document from Day 147 with goals, non-goals, alternatives, and the mandatory sections. An ADR for the most consequential decision. A threat model using STRIDE from Day 41, with at least five threats and their mitigations, and a security test for each mitigation. Tests across the pyramid: unit tests, an integration test with a real SQL Server in a container, a contract or authorization matrix test, and one property-based or mutation-tested piece of business logic. Observability: an SLI in code and a burn-rate alert from Day 141, with a runbook. An operational plan: rollout behind a feature flag with a rollback path, a cost estimate from Day 144, and disaster recovery objectives from Day 142. And a privacy review: update the data inventory, mark personal data, and show how export and erasure reach the new data from Day 136.
The presentation is where you practice the skill of explaining decisions. Prepare a review as you would for a design committee, of about thirty minutes: thirty seconds on the problem, then for each feature the design, the two most important decisions and the alternatives you rejected, the biggest risk and how you addressed it, and a live demonstration including a failure, such as the search service down or a revoked permission. Expect hard questions: what happens when this fails, who can access this data, how do you know it works, what does it cost at ten times the load, and how would you roll it back. Answers that begin with I measured and I tested carry more weight than answers that begin with I assumed. Treat the review as a place to find gaps, and write down what you would change.
Grade your own work with a rubric before anyone else does. The honest exercise is to look for the parts you skipped because they were hard, since those are the parts production will find. Where you cut scope, say so and list what would be needed to finish. Shipping less with quality and honesty about the rest is more professional than claiming completeness.
| Artifact | Per feature | Evidence of quality |
|---|---|---|
| Design doc and ADR | One design doc, one ADR | Alternatives and honest consequences, security section filled in |
| Threat model | At least five threats | Each mitigation has a test |
| Tests | Unit, integration, contract or matrix, one advanced technique | Negative cases, mutation survivors reviewed |
| Observability | An SLI, a burn-rate alert, a runbook | The alert can be triggered on purpose |
| Operations | Flag, rollback, cost estimate, DR objectives | A rollback was actually performed |
| Privacy | Inventory updated, export and erasure verified | A test that erases a user across the feature's data |
Worked Example: A Feature Readiness Script and a Review Rubric
The script checks that each feature has its artifacts and that the pipeline passes, and the rubric lists how you will be assessed.
#!/usr/bin/env bash
# scripts/verify-capstone.sh: a feature is not "done" until every artifact exists and the checks pass.
set -euo pipefail
features=("passkeys" "search" "billing") # replace with your three features
fail=0
for f in "${features[@]}"; do
for artifact in "docs/design/$f.md" "docs/threat-models/$f.md" "docs/runbooks/$f.md" "docs/privacy/$f.md"; do
[[ -s "$artifact" ]] || { echo "MISSING: $artifact"; fail=1; }
done
ls docs/adr/*"$f"* > /dev/null 2>&1 || { echo "MISSING: an ADR mentioning $f"; fail=1; }
grep -q "## Security and privacy" "docs/design/$f.md" || { echo "design doc for $f lacks the security section"; fail=1; }
grep -qi "rollback" "docs/design/$f.md" || { echo "design doc for $f lacks a rollback plan"; fail=1; }
done
dotnet test --filter "Category=Authorization|Category=Integration" --no-build || fail=1
dotnet test --filter "Category=Contract" --no-build || fail=1
dotnet stryker --since:main --break-at 70 || fail=1
npm run test --silent && npm run test:e2e --silent || fail=1
dotnet list package --vulnerable --include-transitive | grep -q "Severity" && { echo "Vulnerable packages found"; fail=1; } || true
exit $fail## Capstone review rubric (score each 0 to 3; below 2 on any security row means the feature is not ready)
| Area | 0 | 1 | 2 | 3 |
|---|---|---|---|---|
| Design | No document | Describes what was built | Alternatives and trade-offs | Trade-offs plus measured evidence, decision reversible or justified |
| Security | Not considered | Checklist only | Threat model with mitigations | Each mitigation has an automated test, abuse cases demonstrated |
| Reliability | Happy path only | Retries and timeouts | Failure demonstrated and handled | Chaos experiment run, alert fired, runbook used |
| Data and privacy | Personal data unmapped | Inventory exists | Export and erasure work | Erasure verified across search, cache, logs and analytics |
| Operations | Manual deploy | Pipeline deploys | Flag, rollback rehearsed | SLO, burn-rate alert, cost and DR objectives documented |
| Communication | Cannot explain choices | Explains what | Explains why and alternatives | Anticipates questions, names limits and next steps honestly |Panel questions to rehearse
Failure: "Show me what happens when the dependency is down." (demonstrate it live)
Access: "Who can read this data, and how do you prove it?" (show the authorization matrix test)
Evidence: "How do you know it works?" (show the tests, the mutation score, the alert firing)
Scale: "What breaks at ten times the load, and what does it cost?"
Rollback: "Roll it back now." (do it, and show the data is still consistent)
Honesty: "What did you leave out, and what would finishing it require?"Record the review, watch it, and list three things you would change. The recording is uncomfortable to watch and one of the fastest ways to improve how you communicate about technical work.
Real-World Examples
- The Azure Well-Architected Framework organizes design review around five pillars: reliability, security, cost optimization, operational excellence, and performance efficiency. Teams use its assessments and checklists as a structured design review before launches, which is the same purpose as the artifacts required in this capstone.
- Google's Site Reliability Engineering book describes a launch coordination checklist used to review new services before production, covering capacity, failure modes, monitoring, security, and rollout. The idea that a launch must pass a written review by people who have seen failures before is the model for both the checklist here and the panel format.
Review Questions & Answers
The advanced track is about the qualities that make a feature production ready, such as security, resilience, operability, and privacy. Taking a few features to that standard demonstrates those skills more clearly than a broad but shallow build.
A mitigation that is not tested can be broken by a later change without anyone noticing. A test turns the mitigation into an enforced property of the system and gives evidence when you defend the design.
Security gaps can cause harm that other strengths cannot offset, so they act as a gate instead of an average. A polished feature with a serious authorization flaw should not ship.
It shows that the design behaves as claimed under stress and that you tested it, which is stronger evidence than describing it. Reviewers trust demonstrated behavior over assumptions.