Portfolio Capstones — PHP Course

What you'll learn

Turn the course into evidence of professional capability. Choose capstones that demonstrate increasing scope, document decisions and tradeoffs, and present working software with tests, security, deployment, and operational thinking—not only screenshots.

By the end of this lesson, you'll be able to:

Select and scope a credible capstone
Plan milestones and quality evidence
Present architecture, tradeoffs, deployment, and reflection professionally

Core mental model

Professional PHP is less about memorizing APIs and more about choosing a clear boundary for each responsibility. Use this table as a decision guide while reading the examples.

Concept	What it protects	Decision rule
Problem statement	Project focus	Name the user, pain, outcome, and explicit non-goals.
Architecture decision record	Reasoning evidence	Capture context, decision, alternatives, and consequences.
Portfolio narrative	Reviewer comprehension	Lead from problem to proof, then explain tradeoffs.

Professional workflow

Build the feature in small, verifiable steps. Each step leaves the system in a state you can test.

Describe the portfolio proof boundary: its inputs, outputs, invariants, and expected failures.
Implement the smallest happy path behind an explicit contract.
Add validation and translate low-level failures into language the caller understands.
Exercise the boundary with realistic data, then inspect output, logs, and resource cleanup.
Refactor only after behavior is protected by a repeatable check.

Make the boundary visible

Name inputs, outputs, side effects, and failure cases before adding framework or infrastructure code. That habit keeps advanced PHP understandable as the application grows.

Guided code lab

Define release milestones

Each milestone produces a demonstrable vertical slice and explicit evidence.

CAPSTONE.md

Problem: Independent instructors need a secure way to publish and sell cohort courses.
Non-goals: video hosting, multi-currency tax automation, native mobile apps.

M1 — Catalog: schema, public search, pagination, accessible UI
M2 — Identity: registration, verification, policies, account security
M3 — Enrollment: transactional checkout simulator, idempotency, receipts
M4 — Operations: queues, cache, tests, container, CI/CD, telemetry

Evidence: threat model, ERD, API contract, test report, ADRs, live demo, runbook.

Record a consequential decision

An ADR demonstrates reasoning and gives future maintainers a point to revisit.

docs/adr/0003-modular-monolith.md

# ADR 0003: Start with a modular monolith
Status: Accepted

Context: A two-person team needs one deployment and strong Catalog, Enrollment, and Billing boundaries.
Decision: One PHP application; modules expose use cases and own persistence access.
Alternatives: Separate services; unstructured layered monolith.
Consequences: Simple transactions and operations now; architecture tests prevent boundary erosion.
Revisit when: independent scaling or team ownership is blocked by the shared release.

Production practice

Contract

Every claimed capability links to inspectable evidence: code, test, decision, metric, deployed behavior, or review note.

Verification

Invite another developer through setup, core workflow, failure paths, and code review; fix every ambiguity they encounter.

Operations

Provide seeded demo access, monitored hosting, safe secrets, backups, cost limits, and a teardown plan.

Common failure mode

A huge unfinished project proves less than a smaller released system with clear scope, tests, security, documentation, and thoughtful tradeoffs.

Independent workshop

Complete one flagship capstone: a secure content platform, learning marketplace, operations dashboard, or API-first team system.

Your finished workshop must include:

Deployed product and five-minute guided demo
README, diagrams, API/schema docs, ADRs, and test evidence
Threat model, CI/CD, telemetry, runbook, and retrospective

Definition of done

Run the happy path and at least two failure paths, explain one design tradeoff in a short README, and leave the code formatted and ready for review.

Recap & quick check

Key takeaways

Scope is a professional engineering skill.
Vertical milestones keep capstones releasable.
Documentation exposes reasoning, not just output.
Operational evidence differentiates production-ready work.

Quick check

1. What makes a portfolio claim credible?

2. What belongs in an ADR?

3. Which project is strongest?

Keep the workshop: later phases deliberately build on these boundaries, so today's small example can become part of your portfolio architecture.