Full-Stack Capstone Project: Build and Present
On this page
Learning Objective
Plan, build, document and defend a complete full-stack system of your own choosing that demonstrates the whole course, using a written brief and rubric, architecture decision records, a security review and a rehearsed presentation, and leave with a concrete plan for continuing to grow as a full-stack engineer.
Concept Explanation
The capstone is where the ninety-nine lessons before it become yours. You will build a system of your own design, deploy it, secure it, test it, and explain it to someone skeptical. The point is not novelty of the idea; a simple product done thoroughly beats an ambitious one done superficially. Good candidates are small but real domains with users, permissions, and shared data: an event booking platform, a clinic appointment scheduler, a tool lending library, a volunteer coordination app, a habit tracker with teams, or an extension of the Task Board with a genuinely new capability such as recurring tasks, attachments, or approvals. Pick something you find interesting enough to finish, and small enough to complete in two focused weeks.
Write a one-page brief before any code. It states the problem and the users, the core user journeys, the functional requirements, the non-functional requirements with numbers, the security and privacy requirements, and what is explicitly out of scope. Then produce a short design document using the framework of Day 91: estimates, API list, data model, architecture diagram, the two or three riskiest parts, failure modes, and the threat model with a STRIDE table. Record significant choices as architecture decision records, one page each, following the format Michael Nygard proposed in 2011: the context, the decision, its status, and the consequences, including what you gave up. These short documents are not bureaucracy; they are how you will explain the system later and how a teammate would understand it without you.
The requirements for the build mirror the course. React with TypeScript on Vite talking to an ASP.NET Core API through a backend-for-frontend, with OIDC sign-in through a real provider. A modular structure with at least two modules that communicate through contracts and events. SQL Server with EF Core, migrations, constraints, and least-privilege logins. An authorization matrix covering every role and endpoint, with object-level checks and tenant or ownership isolation. Validation, ProblemDetails errors, rate limits, security headers, a strict CSP, and safe handling of files or third-party calls if you include them. Tests at every layer: unit tests for domain rules, integration tests with Testcontainers including the security suite, component tests with MSW, and a few Playwright journeys. A pipeline with build, tests, scans, image scanning, infrastructure as code with Bicep, OIDC deployment to Azure, a staged rollout, and a rehearsed rollback. Observability with structured logs, traces, metrics, and at least one alert with a runbook. Finally, a written security review against the OWASP API Top 10 with findings, fixes, and regression tests.
Defending the system is a distinct skill from building it. Plan a ten-minute presentation: the problem and users in one minute, the architecture and why, three key decisions with the alternatives you rejected, the security posture with one real finding you discovered and fixed, a live or recorded demo of the main journey and a failure case, and what you would do next with more time. Expect questions that probe the weakest part of the design, and prepare honest answers, since acknowledging a limitation and describing how you would address it is more convincing than defending everything. Finish by planning your growth: the areas this course only introduced, such as Kubernetes, event sourcing, domain-driven design in depth, advanced performance work, and cloud security specialization, and the reading that supports them. The habit that carries forward is the one the course tried to build throughout: for every design, ask what could go wrong, how you would know, and what you would do about it.
| Deliverable | Contents | Evidence of quality |
|---|---|---|
| Brief and design document | Problem, journeys, requirements, estimates, architecture, threat model | Reviewed by a peer, assumptions stated |
| Decision records | One page per significant choice | Context, decision, consequences and alternatives |
| Working system | React, BFF, modular ASP.NET Core, SQL Server, deployed on Azure | Live URL, repeatable deployment |
| Security review | OWASP API Top 10 table, fixes, regression tests | Failing tests before fixes, passing after |
| Test suite and pipeline | Unit, integration, component, end to end; CI, scans, staged release | Green build, coverage of negative cases |
| Operations | Logs, traces, metrics, alert with runbook, rollback rehearsal | A demonstrated recovery |
| Presentation | Ten-minute defense with demo | Clear decisions and honest limitations |
Worked Example: A Brief, an ADR, a Rubric, a Milestone Plan and a Demo Script
The listings show the artifacts that make a capstone reviewable: the brief, one decision record, the scoring rubric, a two-week plan, and the demo outline.
CAPSTONE BRIEF (one page): "ClinicSlot: appointment scheduling for small clinics"
Problem and users: independent clinics lose revenue to no-shows and phone tag. Patients book and cancel online; staff manage
calendars; clinic admins manage staff, services and reports. Multi-tenant: each clinic is a tenant.
Core journeys: patient books a slot; patient reschedules or cancels; staff sees and updates today's schedule; admin sets availability.
Functional: availability rules, booking with no double-booking, reminders by email, cancellation windows, audit log, GDPR export/delete.
Non-functional: p95 < 300 ms for availability search; 99.9% availability; no double booking under concurrency; 500 clinics, 50 rps peak.
Security and privacy: tenant isolation (query filters + row-level security); roles patient/staff/admin with object-level checks;
health-related data minimized and never logged; MFA for staff; rate limits on booking; audit of every schedule change.
Out of scope: payments, video calls, mobile apps, insurance integrations.
Riskiest parts: double-booking under concurrency; reminder delivery reliability; tenant isolation. (Each gets a deep dive and tests.)# ADR 007: Prevent double booking with a unique constraint and optimistic concurrency, not an application lock
Status: accepted (2026-09-30)
## Context
Two patients can request the same slot within milliseconds. The API runs on several instances, so an in-memory lock cannot
coordinate them. We need a guarantee that survives instance scaling and application bugs.
## Decision
Represent each bookable slot as a row with a unique index on (ClinicId, ProviderId, StartUtc) for non-cancelled appointments
(a filtered unique index), and insert the appointment in one transaction. A violation of the index returns 409 with the
next available slots. Rescheduling uses rowversion and If-Match.
## Consequences
+ The database enforces the invariant for every code path, including scripts and future services.
+ No distributed lock to operate, and the behavior is testable with 50 concurrent requests.
- Cancelled rows must be excluded by the filtered index, and slot generation needs care around time zones.
- Under very high contention on popular slots, some users will see conflicts; the UI must handle 409 gracefully.
## Alternatives considered
Application-level lock (fails across instances); SERIALIZABLE isolation (more deadlocks and lower throughput); Redis lock (extra
infrastructure and failure modes for a guarantee the database already provides).RUBRIC (100 points). Score each area honestly, with evidence, before the defense.
Correctness and product (20) journeys work end to end; edge cases handled; data invariants hold under concurrency
Security (20) authz matrix complete and tested; tenant isolation proven; OWASP API review with fixed findings;
secrets, headers, CSP, cookies verified; threat model current
Architecture and design (15) clear modules and contracts; sound data model; documented decisions with trade-offs
Testing and quality (15) unit, integration (real database), component and e2e tests; negative and security tests; CI green
Operations and delivery (15) IaC, pipeline with scans, staged deploy, rehearsed rollback, logs/traces/metrics, alert and runbook
UX and accessibility (10) loading, empty and error states; forms with server errors; keyboard use; axe checks pass
Communication (5) README, diagrams, decisions, and the ten-minute defense are clear and honest
Bonus (up to 5): an incident drill, a load test with numbers, or a genuinely good extraction plan.TWO-WEEK PLAN
Days 1-2 Brief, design document, threat model, ADRs for the three biggest decisions; repository, CI skeleton, Bicep skeleton
Days 3-4 Data model, migrations, tenant isolation, authentication through the BFF; access matrix tests written FIRST
Days 5-7 Core journeys vertically: endpoints, domain rules, React screens; each slice with its tests and security checks
Days 8-9 Reminders and background work via the outbox; concurrency tests; rate limits; audit log
Days 10-11 Observability, alerts and runbook; load test; accessibility pass; OWASP API review with fixes and regression tests
Day 12 Deploy to Azure through the pipeline; canary or slot release; rehearse a rollback with a deliberately broken change
Day 13 README with architecture diagram, run and test instructions; record the demo; final checklist
Day 14 Rehearse the presentation twice with a listener; fix the weakest answer; write down three things you would do nextDEMO SCRIPT (about 4 of the 10 minutes)
1. Sign in as a patient through the identity provider. Book a slot. Show the appointment and the email in the catcher.
2. Open a second browser as another patient and try to book the same slot: show the graceful conflict and alternatives.
3. Show that patient B cannot open patient A's appointment by URL: 404, and show the test that proves it.
4. Sign in as staff: today's schedule updates live. Change an appointment; show the audit entry with actor and time.
5. Show one trace from browser click to SQL, and the alert firing in staging when an endpoint returns errors.
6. Show the pipeline run, the security scan results, and the rollback of the deliberately broken release.
Close with: the two decisions I am least sure about, and what I would do next.WHAT COMES NEXT: the Advanced Track, Days 101 to 150
React in depth: rendering model, state, performance, React 19 actions, PWAs, frontend observability (Days 101-110)
.NET and data: advanced C#, concurrency, performance, SQL Server internals, search, GraphQL, gRPC, events (Days 111-122)
Distributed design: consistency, strategic DDD, payments, notifications, public APIs, rate limiter, files, collaboration (Days 123-130)
Security and AI: machine identity, passkeys, SSO, authorization, edge security, privacy, secure SDLC, AI features (Days 131-138)
Operations: Kubernetes, Functions, SLOs, disaster recovery, chaos, cost, legacy migration, testing, second capstone (Days 139-150)
Reading: Designing Data-Intensive Applications (Kleppmann), Release It! (Nygard), Accelerate (Forsgren, Humble, Kim),
Threat Modeling (Shostack), Domain-Driven Design Distilled (Vernon), the OWASP Application Security Verification Standard
Habits: publish the capstone repository with a strong README; write one blog post about a hard decision; contribute to an open source
project you use; rotate a secret, restore a backup, and run a tabletop drill twice a year on anything you operateThis capstone closes the 100-day core path, and Days 101 to 150 continue from it. If you completed the capstone, you have a demonstrable, deployed system with tests, a pipeline, observability, and a written security review, and the artifacts to talk about it with credibility. Keep the repository alive: fix findings from your own scans, upgrade dependencies, and use it as the place to try the next thing you learn.
Real-World Examples
- Michael Nygard proposed architecture decision records in a 2011 blog post, describing short documents that capture a single significant decision with its context, the decision, and its consequences, stored with the code. The practice is now widely adopted, including by government digital services and large technology companies, because it preserves the reasoning that code alone cannot show.
- Michael Nygard's book Release It!, first published in 2007 and revised in 2018, catalogued the stability patterns, timeouts, circuit breakers, and bulkheads, and the antipatterns that cause production failures, based on real outages. Its central lesson, that systems must be designed for the failures that will occur, is the same mindset the capstone asks you to demonstrate.
Review Questions & Answers
Evaluators and future employers judge depth and judgment: whether authorization is enforced and tested, concurrency is handled, the system is deployed and observable, and decisions are explained. A small domain leaves time to do all of that properly, while a sprawling one usually ends with missing tests, weak security, and shallow understanding of its own parts.
It records the context, the decision, its status, the consequences including trade-offs, and the alternatives considered. Keeping it beside the code preserves the reasoning for future maintainers and reviewers, who otherwise see only what was built and not why, and it makes changing a decision a visible, deliberate act.
Acknowledge the limitation plainly, explain why the trade-off was made given the requirements and time, describe how you would detect problems, and outline how you would address it with more time or scale. Honesty about limits shows engineering judgment, while insisting that everything is perfect undermines credibility.
For every design, ask what could go wrong, how you would know, and what you would do about it. Applying that question to authorization, concurrency, dependencies, deployment, and operations produces the tests, monitoring, runbooks, and safeguards that distinguish a system that merely works from one that can be trusted.