Capstone Projects

The capstone is the final proof that the learner can turn concepts into a working, explainable, operable system.

Do not accept a slideshow. Do not accept a toy demo with no tests. The capstone must include a running product path, design artifacts, tests, operational notes, agentic workflow evidence, and a retrospective.

Required Standard

Every capstone must prove:

A real user workflow.
A component diagram.
A data model.
An API contract.
A working feature path.
Error and failure handling.
Tests.
Deployment or realistic local operation.
Logs or observability notes.
Agentic workflow with human verification.
Demo script.
Retrospective.

Capstone A: Support Desk Copilot

User Problem

Support agents waste time reading long ticket histories and drafting repetitive responses. They need help understanding context quickly, but humans must stay in control of what gets sent.

Required Features

Create support tickets.
Add comments to tickets.
Change ticket status.
View ticket history.
Generate or simulate a ticket summary.
Generate or simulate a draft response.
Require human approval before marking response as sent.
Store audit events.
Show loading, success, error, and rejected states.

Required Architecture

frontend -> backend API -> business service -> database
                          -> summary/draft provider
                          -> audit log

Optional advanced path:

ticket updated -> queue -> worker -> summary generated -> human review

Failure Cases To Handle

User submits empty ticket.
User tries to approve someone else’s draft.
Summary provider fails.
Draft is rejected by human.
Database write fails.
Duplicate approval request is submitted.

Evidence

API contract.
Schema.
Tests for approval requirement.
Test for provider failure.
Debugging log for one induced bug.
Runbook.
Demo script.

Capstone B: Content Operations Console

User Problem

A small marketing team needs one place to plan content, generate drafts, review, approve, and track publishing state.

Required Features

Create a content brief.
Generate or simulate a draft.
Review and edit draft.
Approve or reject draft.
Show calendar or queue.
Track status history.
Show simple metrics from sample data.

Required Architecture

frontend -> content API -> database
                    -> draft generator
                    -> review workflow
                    -> analytics query

Failure Cases To Handle

Empty content brief.
Draft provider returns bad output.
User tries to publish unapproved content.
Metrics query fails.
Two reviewers update the same draft.

Evidence

Workflow map.
Data model.
API contract.
UI state screenshots or notes.
Tests for approval gate.
Runbook.
Agentic log.

Capstone C: Internal Analytics Assistant

User Problem

Operators want to ask questions about business data without writing SQL, but the system must protect data and avoid dangerous queries.

Required Features

Import sample CSV data.
Store data in a database.
Show table schema.
Ask natural-language questions.
Generate or simulate SQL.
Show SQL before execution.
Block unsafe SQL.
Save question history.
Show result table.

Required Architecture

frontend -> question API -> SQL guard -> database
                       -> model or simulated translator
                       -> audit history

Failure Cases To Handle

Unsafe query tries to delete data.
Question references a missing column.
Query is too expensive.
User lacks permission for a table.
Generated SQL is invalid.

Evidence

Safe-query policy.
Tests for blocked SQL.
Schema docs.
Query examples.
Audit log.
Runbook.

Capstone D: Workflow Automation Agent

User Problem

A team repeats a manual operational workflow: collect inputs, validate data, create tasks, notify people, and track completion. Automate it with human approval and auditability.

Required Features

Intake form.
Validation rules.
Task creation.
Assignment.
Approval gate.
Notification simulation.
Audit timeline.
Admin view for failed workflow steps.

Required Architecture

frontend -> workflow API -> workflow state machine -> database
                         -> notification provider
                         -> audit log

Failure Cases To Handle

Invalid intake data.
Approver rejects request.
Notification fails.
Workflow step is retried.
User lacks permission.

Required Deliverables

Create a capstone/ folder with:

capstone/
├── problem-statement.md
├── workflow-map.md
├── architecture.md
├── data-model.md
├── api-contract.md
├── test-plan.md
├── verification.md
├── runbook.md
├── agentic-log.md
├── demo-script.md
└── retrospective.md

Demo Script

The demo must show:

User problem.
Main happy path.
One validation failure.
One system failure.
Test output.
Runbook start command.
Log or database evidence.
Agentic workflow evidence.
What is not production-ready yet.

Grading Rubric

Area	Pass	Strong
Workflow	Clear user path	Based on interview or realistic field notes
Architecture	Components named	Boundaries and failure modes included
Data	Schema exists	Constraints, audit, and migration plan included
API	Endpoints documented	Errors, auth, idempotency included
Product	Main path works	Empty/loading/error/permission states handled
Quality	Some tests	Tests catch meaningful failures
Ops	Start instructions	Health, logs, config, rollback included
ADLC	Agent use mentioned	Agent tasks, review, rejected output, verification shown
Communication	Demo works	Handoff lets someone else run it

Final Question

After the capstone, the learner must answer:

If this ran for a real user tomorrow, what would you still be worried about?

The quality of that answer tells you whether they are becoming an engineer.