Full-Stack Web Development

Feature scoping, data modelling, wireframing at a basic level.

Write a feature list and sketch a wireframe for the capstone app.

Turn an app idea into a scoped, wireframed plan.

Project scaffolding, routing/pages, base layout.

Scaffold the frontend project and set up routing between pages.

Stand up a navigable multi-page frontend shell.

Applying a consistent base style/theme across pages.

Style the shared layout (nav, containers, typography).

Apply a consistent visual base across the app.

Building UI screens against mock/placeholder data.

Build the app's 1–2 primary screens with mock data.

Build functional-looking UI ahead of real data.

Completing secondary screens/components.

Build remaining screens/components needed for the app.

Have a complete frontend shell ready for real data.

Schema design specific to the capstone app's data.

Design and create the database schema.

Design a schema matching real app requirements.

Server setup, connecting to the database.

Stand up the backend server and connect it to the DB.

Run a backend server wired to a live database.

Defining the app's core routes.

Implement the initial route structure.

Define a working route structure for the app.

Implementing Create/Read for the app's main resource.

Build and test Create/Read endpoints.

Persist and fetch the app's core data.

Implementing Update/Delete for the main resource.

Build and test Update/Delete endpoints.

Complete full CRUD for the app's core resource.

Implementing auth across frontend and backend together.

Build signup/login and protect relevant routes/screens.

Implement end-to-end authentication in a full-stack app.

Replacing mock data with real API calls.

Wire the primary screen to fetch real data from the backend.

Connect a real frontend screen to live backend data.

Handling loading and error states properly.

Add loading/error handling across the connected screens.

Build a frontend that handles real-world data states gracefully.

Pagination/filtering, or a secondary integration (e.g. file upload).

Implement one advanced API feature relevant to the app.

Extend an API beyond basic CRUD.

Keeping frontend state in sync with backend data after updates.

Ensure create/update/delete actions reflect immediately in the UI.

Keep UI and backend data in sync reliably.

Reviewing code structure for clarity and maintainability.

Refactor a messy part of the codebase together.

Recognize and clean up structural code issues.

Systematic manual testing of an app's flows.

Test the app end-to-end and log bugs found.

Run a structured test pass on their own app.

Prioritizing and fixing bugs.

Fix the bugs logged in Hour 18.

Triage and resolve real bugs in their app.

Preparing an app for deployment (env vars, build steps).

Prepare production-ready build configuration.

Get an app deployment-ready.

Deploying frontend, backend, and database live.

Deploy the full app to a live environment.

Independently deploy a full-stack app.

Extended hands-on time to close feature gaps.

Implement any remaining planned features.

Close out remaining scope on the capstone.

Continued feature completion / edge-case handling.

Handle edge cases and rough spots identified during testing.

Harden the app against real-world edge cases.

Final feature integration.

Integrate and test the last remaining pieces together.

Confirm the full app works end-to-end.

UI polish techniques, writing project documentation.

Polish the UI and write a README/project write-up.

Present a finished, documented, professional-feeling project.

Presenting a technical project clearly.

Demo the live app and walk through the codebase.

Confidently demo and explain a full-stack project they built.