Month 6, Week 4

Final Capstone Project & Professional Portfolio Review

The Architect's Final Exam

Module 1: The Capstone Challenge

From Student to Engineer

The Objective

Your final task is to apply everything you have learned over the past six months. You will work in a team to design, build, test, document, and containerize a complete, production-ready backend system from scratch.

This is not just a coding assignment. This is a simulation of a professional engineering project.

What Does "Production-Ready" Mean?

Your project must meet the standard of a senior-level architect.

  • Correct & Functional: The API works as designed.
  • Well-Architected: Follows NestJS principles (Modules, DI), Separation of Concerns.
  • Secure: Implements robust authentication and authorization (JWT, Guards).
  • Tested: Has a comprehensive suite of unit, integration, and E2E tests.
  • Documented: Features a professional `README.md` and API documentation.
  • Containerized: Can be fully orchestrated with a single `docker-compose up` command.
  • Automated: Includes a CI/CD pipeline in GitHub Actions that runs tests on every push.

Module 2: Capstone Project Ideas

Choose Your Challenge

Project 1: The E-commerce Platform API

A classic but comprehensive challenge that tests every part of the curriculum.

  • Core Features: User registration/login, product catalog, shopping cart, order placement.
  • Key Skills Tested: Complex relational data modeling (Users, Products, Orders, OrderItems), robust authentication, transaction management (ensuring an order only succeeds if payment and inventory checks pass), DTO validation.
  • Advanced Stretch Goals: Implement role-based access (Admins can manage products), integrate a mock payment gateway, use a message queue for order processing emails.

Project 2: The Real-Time Bidding API

A high-performance challenge focused on concurrency and real-time logic.

  • Core Features: Users can list items for auction, users can place bids on items, auctions have a start/end time.
  • Key Skills Tested: Handling concurrent write operations (multiple users bidding at once), managing state changes over time (auction status), database transactions, advanced error handling for failed bids.
  • Advanced Stretch Goals: Use WebSockets to push real-time bid updates to connected clients, use a message queue and a scheduler for closing auctions and notifying winners.

Project 3: The Food Delivery Service API

A complex system with multiple user types and intricate relationships.

  • Core Features: Restaurants can manage their menus, users can browse restaurants and place orders, couriers can accept delivery jobs.
  • Key Skills Tested: Advanced role-based authorization (User vs. Restaurant Owner vs. Courier), complex data relationships (Menus, MenuItems, Orders, Users), state machines (an order's lifecycle: `placed` -> `preparing` -> `out_for_delivery` -> `delivered`).
  • Advanced Stretch Goals: Implement basic geospatial queries (e.g., "find restaurants near me"), use a message queue to notify couriers of new orders, implement a rating system.

Final Exam (Part 1)

Module 3: The Architect's Blueprint

Plan Your Work, Work Your Plan

The Design Document

Before you write a single line of code, your team must produce a high-level design document. This is your master plan.

Your document must include:

  1. Clear Functional & Non-Functional Requirements.
  2. Your complete Database Schema Design (tables, columns, relationships).
  3. Your API Endpoint Design (RESTful routes, expected request/response shapes).
  4. A High-Level Architecture Diagram (boxes and arrows showing your services).

The Professional `README.md`

Your `README.md` is the front door to your project. It must be professional.

It should include:

  • A clear project description.
  • Instructions on how to set up the local development environment (including `.env` setup).
  • Instructions on how to run the application with Docker Compose.
  • Instructions on how to run the tests.
  • API documentation (a list of your endpoints, what they do, and example payloads).

In-Class Practical Exercise

Collaborative Design Session

As a team, you will choose one of the three capstone project ideas. Your task for the remainder of this class is to begin creating your design document on a shared whiteboard or digital tool.

  1. Clarify Requirements (30 mins): Discuss the core features. What is the "Minimum Viable Product" (MVP)? What are the stretch goals? Define your key functional and non-functional requirements.
  2. Design the Schema (45 mins): Whiteboard the database tables you will need. Define the columns, their data types, and the relationships between them (one-to-one, one-to-many, many-to-many). Identify your primary and foreign keys.
  3. Design the API (30 mins): Define the main RESTful endpoints for your MVP. What are the routes? What HTTP verbs will they use? What will the request and response bodies look like (at a high level)?

This session is your architectural blueprint. A strong plan now will save you hundreds of hours of coding later.

Final Exam (Part 2)