POPOK ACADEMY LOGOPOPOK
ACADEMY
Web development path
Course 03 / Full-stack development
Coming soon

Full-Stack Applications with Next.js

Extend your React skills into server-rendered applications with persistent data, protected mutations, deliberate caching, and observable deployment.

24 sessions36 guided hours8 teaching weeks

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
  1. 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.

  2. 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.

  3. 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.

  4. 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
  1. 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.

  2. 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.

  3. 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.

  4. 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
  1. 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.

  2. 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.

  3. 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.

  4. 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
  1. 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.

  2. 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.

  3. 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
  1. 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.

  2. 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.

  3. 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.

  4. 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
  1. 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.

  2. 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.

  3. 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.

  4. 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.

  5. 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

  1. 10 min

    Recap & troubleshoot

  2. 20 min

    Explain & demonstrate

  3. 35 min

    Guided implementation

  4. 15 min

    Independent challenge

  5. 10 min

    Review & next steps