Catalog My learning Blog
Full-Stack Developer Course: React, .NET and SQL Server · Phase 15 · Lesson 149 · 7 min read

Advanced Full-Stack Capstone Project

On this page
  1. Learning Objective
  2. Concept Explanation
  3. Worked Example: A Feature Readiness Script and a Review Rubric
  4. Real-World Examples
  5. Review Questions & Answers

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.

ArtifactPer featureEvidence of quality
Design doc and ADROne design doc, one ADRAlternatives and honest consequences, security section filled in
Threat modelAt least five threatsEach mitigation has a test
TestsUnit, integration, contract or matrix, one advanced techniqueNegative cases, mutation survivors reviewed
ObservabilityAn SLI, a burn-rate alert, a runbookThe alert can be triggered on purpose
OperationsFlag, rollback, cost estimate, DR objectivesA rollback was actually performed
PrivacyInventory updated, export and erasure verifiedA 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.

Code
#!/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
Code
## 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 |
Code
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.

Each of the three capstone features needs the same artifacts: a design document with an ADR, a threat model with tests, layered tests, an SLI with an alert and runbook, an operational plan, and a privacy review. The example shows one feature with a missing recovery plan that blocks shipping.
Each of the three capstone features needs the same artifacts: a design document with an ADR, a threat model with tests, layered tests, an SLI with an alert and runbook, an operational plan, and a privacy review. The example shows one feature with a missing recovery plan that blocks shipping.

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.
Key TakeawaysTurn three advanced features into production-quality work by producing the same set of artifacts for each one of them. Produce a design document, ADR, threat model with tests, layered tests including an advanced technique, SLI and alert with a runbook, rollout, cost and recovery plans, and a privacy review. Verify readiness with a script and a rubric, present decisions and trade-offs to a panel with live failure demonstrations, and be honest about what you left out.

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.