Full-Stack Applications with Next.js
Extend your React skills into server-rendered applications with persistent data, protected mutations, deliberate caching, and observable deployment.
What you will build
A full-stack team workspace
Build public pages and an authenticated workspace around supplied database and authentication integrations. Explain your rendering, data, security, and caching decisions.
- Persistent task CRUD with server validation.
- Authenticated member/admin access and team isolation.
- Pending, optimistic, error, and not-found states.
- Public caching with mutation revalidation and private-data boundaries.
- Accessible public pages, a critical browser test, and Vercel deployment.
- An architecture walkthrough and a log-based failure investigation.
What you will be able to do
- Explain and choose Server and Client Component boundaries.
- Read and mutate persistent data through a supplied database layer.
- Validate and authorize operations on the server, including team ownership.
- Keep public caching and private user data separate.
- Test, deploy, and investigate failures in a Next.js application.
Is this course right for you?
Comfortable with React, TypeScript, routing, forms, API integration, and basic testing. Complete the React course or pass the entry exercise.
Entry readiness exercise
Build a typed React form connected to an API, handle loading and errors, and explain local versus server state. Start with a prepared UI and sample data.
The curriculum
6 modules · 24 sessions
Expand a module to explore outcomes, topics, and guided exercises. Each session is 90 minutes; extensions are independent work.
01App Router and rendering4 sessions · 6 hours
SESSION 01 · 90 MIN
App Router setup and layouts
Outcome: Create a workspace using pages, shared layouts, and Link navigation.
- Project structure
- Pages and shared layouts
- Link navigation
Guided exercise: Create the workspace shell and navigate between home and a task page.
Completion check: Demonstrate the outcome and explain one decision without following the worked example.
SESSION 02 · 90 MIN
Dynamic routes and route parameters
Outcome: Resolve dynamic route parameters and handle missing records.
- Dynamic segments
- Awaiting params
- Missing records
Guided exercise: Add task detail routes and verify an unknown ID reaches the not-found state.
Completion check: Demonstrate the outcome and explain one decision without following the worked example.
SESSION 03 · 90 MIN
Server Components
Outcome: Explain where Server Components execute and where data belongs.
- Server rendering
- Server-owned data
- Terminal versus browser execution
Guided exercise: Render dashboard content on the server and identify where its logs appear.
Completion check: Demonstrate the outcome and explain one decision without following the worked example.
SESSION 04 · 90 MIN
Client Components, hydration, and boundaries
Outcome: Keep interactive islands small and pass serializable data across boundaries.
- The use-client boundary
- Interactive state
- Hydration
- Serializable props
- Small interactive islands
- Composition across boundaries
Guided exercise: Add a client counter inside the server page without moving the whole page to the client. Pass plain task data to an interactive child and explain why ordinary callbacks cannot cross the boundary.
Completion check: Demonstrate the outcome and explain one decision without following the worked example.
02Server data and resilience4 sessions · 6 hours
SESSION 05 · 90 MIN
Server data and persistent storage
Outcome: Read persisted tasks through a supplied server-only database layer.
- Async Server Components
- Server-only data access
- Supplied database schema and migrations
- Reading persisted records
Guided exercise: Run the prepared database migration, read tasks through its data-access layer, and verify that records survive a server restart.
Completion check: Demonstrate the outcome and explain one decision without following the worked example.
SESSION 06 · 90 MIN
Parallel requests and data-access boundaries
Outcome: Load independent data concurrently and protect private server modules.
- Independent promises
- Promise.all
- Avoiding request waterfalls
- Private server modules
- Public response shapes
- Data source failures
Guided exercise: Add an independent summary data source and load it concurrently with tasks. Prevent server-only code from entering the client bundle and handle an unavailable data source.
Completion check: Demonstrate the outcome and explain one decision without following the worked example.
SESSION 07 · 90 MIN
Suspense and streaming
Outcome: Stream a slow region without blocking the page shell.
- Slow async regions
- Streaming fallback
- Route loading UI
Guided exercise: Keep the page shell visible while a slow dashboard region loads.
Completion check: Demonstrate the outcome and explain one decision without following the worked example.
SESSION 08 · 90 MIN
Error and not-found boundaries
Outcome: Distinguish missing data from unexpected failures and offer recovery.
- Expected missing records
- Unexpected failures
- Retry behavior
Guided exercise: Trigger the supplied error and missing-record scenarios and explain their different boundaries.
Completion check: Demonstrate the outcome and explain one decision without following the worked example.
03Mutations and HTTP interfaces4 sessions · 6 hours
SESSION 09 · 90 MIN
Server Actions and validation
Outcome: Persist a validated task through a Server Action.
- Server mutation functions
- FormData
- Server-side input checks
- Persisting validated writes
Guided exercise: Create a persisted task through a Server Action that rejects whitespace and oversized titles.
Completion check: Demonstrate the outcome and explain one decision without following the worked example.
SESSION 10 · 90 MIN
Action state and pending feedback
Outcome: Show accessible action results and prevent duplicate submissions.
- useActionState
- Accessible feedback
- Preventing duplicate submissions
Guided exercise: Show validation results and disable submission while saving.
Completion check: Demonstrate the outcome and explain one decision without following the worked example.
SESSION 11 · 90 MIN
Optimistic UI updates
Outcome: Show optimistic feedback and recover when saving fails.
- useOptimistic
- Temporary UI state
- Failure recovery
Guided exercise: Display a pending task immediately and restore consistent UI if the save fails.
Completion check: Demonstrate the outcome and explain one decision without following the worked example.
SESSION 12 · 90 MIN
Route Handlers
Outcome: Build a validated HTTP endpoint with meaningful status codes.
- HTTP methods
- JSON responses
- Request validation and status codes
Guided exercise: Add a task endpoint and compare its HTTP interface with a Server Action.
Completion check: Demonstrate the outcome and explain one decision without following the worked example.
04Caching and consistency3 sessions · 4.5 hours
SESSION 13 · 90 MIN
Public data caching
Outcome: Observe public cache lifetimes in a production build.
- Explicit Data Cache example
- Cache lifetime
- Production-mode observation
Guided exercise: Prime the supplied public task cache, edit its source, and observe stale data within the cache lifetime.
Completion check: Demonstrate the outcome and explain one decision without following the worked example.
SESSION 14 · 90 MIN
Revalidation after mutations
Outcome: Keep list and detail views consistent after a mutation.
- Path invalidation
- Shared data tags conceptually
- List and detail consistency
Guided exercise: Edit a task and invalidate every affected list and detail view.
Completion check: Demonstrate the outcome and explain one decision without following the worked example.
SESSION 15 · 90 MIN
User-specific data and cache boundaries
Outcome: Prevent private team data from entering shared public caches.
- Public versus private data
- Session-sensitive reads
- Cache key design
Guided exercise: Keep private team responses outside shared public caches and explain the isolation requirement.
Completion check: Demonstrate the outcome and explain one decision without following the worked example.
05Authentication and architecture4 sessions · 6 hours
SESSION 16 · 90 MIN
Authentication integration and session lifecycle
Outcome: Integrate authentication and reject expired server sessions.
- Supplied authentication integration
- HttpOnly cookies
- Server-side session expiry
- Sign-in, sign-out, and server secrets
Guided exercise: Connect the prepared authentication integration, sign in and out, and verify that an expired session is rejected on the server.
Completion check: Demonstrate the outcome and explain one decision without following the worked example.
Optional extension: Compare the production-oriented integration with a simplified demo token and explain why the demo is insufficient.
SESSION 17 · 90 MIN
Server-side permission checks
Outcome: Authorize every protected operation on the server.
- Session checks per request
- Unauthorized responses
- Untrusted browser state
Guided exercise: Reject a protected request without a valid session even when the browser displays privileged UI.
Completion check: Demonstrate the outcome and explain one decision without following the worked example.
SESSION 18 · 90 MIN
Team ownership checks
Outcome: Enforce team ownership on both reads and writes.
- Tenant boundaries
- Record filtering
- Protected mutations
Guided exercise: Reject access to the other team's record and apply the same ownership check to updates.
Completion check: Demonstrate the outcome and explain one decision without following the worked example.
SESSION 19 · 90 MIN
Feature architecture and service boundaries
Outcome: Separate feature services, data access, and presentation.
- Feature services
- Data-access modules
- Presentation components
- Expected domain errors
- Safe public feedback
- Reusable service contracts
Guided exercise: Separate the task feature into service, data-access, and UI layers. Return consistent missing, forbidden, and invalid-input results without exposing internal details.
Completion check: Demonstrate the outcome and explain one decision without following the worked example.
06Production delivery5 sessions · 7.5 hours
SESSION 20 · 90 MIN
Metadata and accessible public pages
Outcome: Publish meaningful metadata and accessible public content.
- Page metadata
- Semantic content
- Keyboard and image alternatives
Guided exercise: Add a public title and description, then verify keyboard navigation and alternative text.
Completion check: Demonstrate the outcome and explain one decision without following the worked example.
SESSION 21 · 90 MIN
Performance and asset delivery
Outcome: Improve image delivery, font loading, and client bundle size.
- Image dimensions and optimization
- Font loading
- Client bundle inspection
Guided exercise: Add a raster image and local font, then compare layout stability and client JavaScript transfer.
Completion check: Demonstrate the outcome and explain one decision without following the worked example.
SESSION 22 · 90 MIN
Production integration and browser tests
Outcome: Run browser journeys against a production server.
- Health endpoint
- Playwright setup
- Production server checks
Guided exercise: Run the supplied home and health checks against a production build and add a user journey.
Completion check: Demonstrate the outcome and explain one decision without following the worked example.
SESSION 23 · 90 MIN
Environment configuration and Vercel deployment
Outcome: Verify a Vercel preview and production deployment with scoped configuration.
- Environment variables
- Vercel Git import and automatic builds
- Preview and Production Deployments
- Environment scopes and deployment verification
Guided exercise: Deploy the prepared Next.js app to Vercel, test a Preview Deployment, and verify the Production Deployment.
Completion check: Demonstrate the outcome and explain one decision without following the worked example.
SESSION 24 · 90 MIN
Logging and failure investigation
Outcome: Trace a failed request through structured runtime logs.
- Request identifiers
- Structured runtime logs in Vercel
- Intentional failure diagnosis
Guided exercise: Trigger the intentional failure and match its response identifier to the Vercel runtime log.
Completion check: Demonstrate the outcome and explain one decision without following the worked example.
Learning support
- A standalone starter repository and environment setup guide for this course.
- Guided exercises, independent challenges, and code review checkpoints.
- A shared task-workspace project theme, without requiring earlier course code.
- Prepared database schema, migration, and data-access layer. Database design from scratch is outside the 36 guided hours.
- A supplied authentication integration with server-validated sessions. Demo tokens are teaching examples, not the capstone authentication solution.
- Framework versions pinned for class so caching exercises match the taught behavior.
Show what you can build
- Demonstrate the required project features and handle a failure case.
- Implement a small unfamiliar feature independently and fix a seeded bug.
- Explain a design decision; review correctness, readability, accessibility, and error handling.
- Verify persistence after restart, expired-session rejection, and denial of cross-team access.
- Complete the independent capstone and review outside the 24 guided sessions before claiming completion.
The 36 guided hours cover instruction and classroom exercises. Independent practice, final-project development, and the completion review require additional time outside the 24 sessions.
Inside a 90-minute session
10 min
Recap & troubleshoot
20 min
Explain & demonstrate
35 min
Guided implementation
15 min
Independent challenge
10 min
Review & next steps