Launch
Capstone Project 2
Capstone Project 2 steps up from the personal-scale build in Project 1 to a full, multi-user product: a complete Education Platform, built with the exact stack a real product team would use — Next.js on the frontend, NestJS on the backend, deployed to the cloud with a real CI/CD pipeline, and covered by real tests from day one.
Topic Map
Everything in this module, at a glance
In Depth
Every topic, explained — with real-world industry context
Capstone Project 2 — Frontend (Next.js)
The student- and instructor-facing side of the platform — course pages, enrollment, the learning dashboard, and live class access — built as a real Next.js application, not a static mockup.
Core Build
- Next.js App Router — pages, layouts & nested routes for the whole platform
- Server components vs. client components — choosing correctly for each screen
- Public course catalog & marketing pages (SSG/ISR for speed & SEO)
- Calling the NestJS API from the frontend, with typed requests/responses
Product Features
- Authenticated student dashboard — enrolled courses & progress tracking
- Course player UI — video/content playback & lesson navigation
- Enrollment & checkout flow
- Instructor-facing views — managing a course & viewing student progress
Production Polish
- Protected routes & role-aware UI (student vs. instructor vs. admin)
- Client-side state/data-fetching (React Query or equivalent) for live progress data
- Image & asset optimization for course thumbnails & video posters
- Performance — code splitting, caching & Core Web Vitals for public pages
Real-World Industry Use Case
Next.js is the deliberate choice here because this exact platform needs both a fast, SEO-friendly public course catalog (built with SSG/ISR) and a dynamic, authenticated dashboard — one framework, two very different rendering needs, exactly the trade-off covered in the Frontend Development module.
Capstone Project 2 — Backend (NestJS)
The API and business logic powering the platform — courses, enrollments, users, and roles — built with NestJS's structured, modular architecture instead of a single unorganized Express app.
Core Build
- NestJS modules, controllers & providers — organizing the app by domain (users, courses, enrollments)
- REST API endpoints with DTOs & validation (class-validator)
- Database integration via an ORM (TypeORM or Prisma) connected to PostgreSQL
- Core data models — users, courses, lessons, enrollments & progress
Product Features
- Authentication — JWT strategy with Passport.js
- Authorization — guards & role-based access control (student/instructor/admin)
- Enrollment & progress-tracking business logic
- File/video upload handling for course content
Production Polish
- Background jobs (BullMQ) — sending enrollment emails & generating certificates
- WebSocket/real-time layer — live class notifications & presence
- Centralized error handling & request validation across every module
- API documentation with Swagger/OpenAPI, generated directly from the NestJS code
Real-World Industry Use Case
NestJS is chosen specifically for this project because its Angular-inspired, dependency-injection-based structure keeps a growing codebase (users, courses, payments, notifications, live classes) organized as separate, testable modules — exactly the kind of "server fundamentals → structured framework" progression covered in the Backend Development module.
Capstone Project 2 — Cloud Deployment
Taking the platform from "runs on my laptop" to a real, reachable production deployment — applying the exact provider services covered in the Cloud Computing module to a real project.
Core Build
- Deploying the Next.js frontend (Vercel or equivalent static/edge hosting)
- Deploying the NestJS backend (Railway, Render, or a cloud VM/container service)
- Provisioning a managed PostgreSQL database (Neon, RDS or Cloud SQL)
- Connecting frontend, backend & database with correct environment configuration
Product Features
- Object storage for course videos & assets (S3 or Cloudflare R2)
- CDN in front of static assets & video content for fast global delivery
- A custom domain with DNS & HTTPS configured correctly
- Separate staging & production environments
Production Polish
- Containerizing the NestJS backend with Docker for portable deployment
- Auto-scaling the backend for enrollment spikes (e.g. a popular cohort launch)
- Cost monitoring & basic budget alerts on the cloud account
- A documented disaster-recovery/backup plan for the production database
Real-World Industry Use Case
This phase is where the Domains & DNS, Storage, and Managed Databases sections from the Cloud Computing module stop being theory — this project needs a real domain, real object storage for video content, and a real managed database, chosen and configured exactly the way a small real product team would.
Capstone Project 2 — CI/CD Pipeline
Automating the path from a pushed commit to a safely deployed change — no manual deploys, no "it worked on my machine" surprises.
Core Build
- A GitHub Actions workflow triggered on every push & pull request
- Linting & type-checking as an automated gate before merge
- Running the full test suite automatically in the pipeline
- Automatic deployment to a staging environment on merge to main
Product Features
- A separate, manually-approved production deployment step
- Running database migrations automatically & safely as part of deploy
- Secrets & environment variables managed securely in CI, never hardcoded
- Build caching to keep pipeline runs fast as the codebase grows
Production Polish
- A rollback strategy for a bad production deploy
- Blue-green or canary deployment for the backend API
- Pipeline notifications (Slack/email) on failed builds or deploys
- Tracking deployment frequency & failure rate as real engineering metrics
Real-World Industry Use Case
This is the Version Control and DevOps modules applied directly — the same GitHub Actions, staging/production separation, and rollback thinking covered there, now protecting a real database of real students' course progress instead of a toy repo.
Capstone Project 2 — Testing & Maintenance
Proving the platform actually works, catching regressions before students do, and keeping it healthy long after the "build" phase ends.
Core Build
- Unit tests for NestJS services — enrollment logic, progress calculation, auth guards
- Component/unit tests for key Next.js UI (Vitest + React Testing Library)
- Integration tests for critical API routes (enrollment, auth, course data)
- A basic CI-enforced code coverage baseline
Product Features
- End-to-end tests (Playwright) for the flows that matter most — sign up, enroll, watch a lesson, track progress
- Manual QA checklist for anything not worth automating yet
- Error tracking in production (Sentry) surfacing real user-facing failures
- Uptime & basic performance monitoring on both frontend & backend
Ongoing Maintenance
- A dependency-update & security-patch cadence (not "update never")
- Versioning the API as new features are added without breaking existing clients
- Triaging & fixing real bugs reported after the cohort starts using the platform
- A lightweight incident-response process for a live production issue
Real-World Industry Use Case
This phase is a direct, applied continuation of the Testing & Debugging module — the same testing pyramid, the same Playwright/Vitest stack — except now the tests are protecting a real platform that real students in this very program depend on.
Ready to learn this — live?
See how this module fits into the complete curriculum.