Learning path
Full-Stack Engineer learning path: everything to study, topic by topic
Comprehensive Full-Stack Engineer assessment covering frontend development, backend development, data layer design, DevOps practices, system architecture, and production operations. Evaluates the ability to deliver end-to-end features across the entire stack.
Short answer
To learn Full-Stack Engineer, work through 6 modules and 35 topics in the order they build on each other. It starts with Frontend Development, then moves on to Backend Development and Data Layer. Use the map as a checklist, or measure your level and study only what is missing.
What you will study
Topics are grouped by module. Open one to see its objectives and key concepts.
1 · Frontend Development6 topics
Component-Based UI Development
Building user interfaces with reusable components, props, component composition, and rendering lifecycle in frameworks like React, Vue, or Angular
Objectives
- Build reusable UI components
- Understand component lifecycle and rendering
Key concepts
- component hierarchy
- props and state
- JSX / templates
- component lifecycle
- reusable components
- composition patterns
- virtual DOM
State Management
Managing application state with local state, context, and state management libraries such as Redux, Zustand, or Pinia
Objectives
- Choose the right state management approach for a given use case
- Implement predictable state flows
Key concepts
- local vs global state
- state lifting
- Redux / Zustand / Pinia
- actions and reducers
- selectors
- derived state
- state normalization
Client-Side Routing
Single-page application routing, nested routes, route guards, lazy loading routes, and URL parameter handling
Objectives
- Configure client-side routing for an SPA
- Implement navigation guards and lazy loading
Key concepts
- client-side routing
- nested routes
- route parameters
- query strings
- route guards
- lazy-loaded routes
- history API
Form Handling & Validation
Controlled and uncontrolled forms, client-side validation, schema-based validation, multi-step forms, and error display patterns
Objectives
- Build forms with proper validation and error handling
- Choose between controlled and uncontrolled patterns
Key concepts
- controlled inputs
- uncontrolled inputs
- validation libraries
- schema validation (Zod/Yup)
- error messages
- multi-step forms
- debounced validation
Responsive & Accessible Design
Responsive layouts with CSS Grid and Flexbox, media queries, ARIA attributes, keyboard navigation, screen reader support, and WCAG compliance
Objectives
- Build responsive layouts that work across devices
- Ensure web applications meet accessibility standards
Key concepts
- responsive design
- CSS Grid
- Flexbox
- media queries
- ARIA roles
- keyboard navigation
- WCAG guidelines
Progressive Enhancement at Scale
Building resilient full-stack applications with progressive enhancement, graceful degradation, and accessibility baselines
Objectives
- Design full-stack applications that function at baseline without JavaScript and progressively enhance
- Implement feature detection and polyfill strategies that balance capability with bundle size
Key concepts
- progressive enhancement
- graceful degradation
- feature detection
- polyfills strategy
- WCAG compliance
- semantic HTML
- no-JS fallbacks
2 · Backend Development7 topics
REST API Development
Designing and building RESTful APIs with proper HTTP methods, status codes, resource naming, pagination, and error handling
Objectives
- Design RESTful endpoints following conventions
- Implement proper error handling and status codes
Key concepts
- REST principles
- HTTP methods
- status codes
- resource naming
- pagination
- error responses
- content negotiation
Database Design & Queries
Relational and NoSQL database design, writing efficient queries, joins, indexes, and basic data modeling
Objectives
- Design database schemas for common application patterns
- Write efficient queries with proper indexing
Key concepts
- table design
- primary and foreign keys
- joins
- indexes
- SQL queries
- NoSQL document design
- normalization
Authentication & Authorization
Implementing auth flows with JWT, OAuth 2.0, session-based auth, role-based access control, and secure token handling
Objectives
- Implement secure authentication flows
- Design role-based access control systems
Key concepts
- JWT
- OAuth 2.0
- session-based auth
- RBAC
- refresh tokens
- CORS
- CSRF protection
Server-Side Rendering
SSR with Next.js, Nuxt, or similar frameworks; hydration, static generation, incremental static regeneration, and rendering strategies
Objectives
- Choose the right rendering strategy for a given use case
- Implement server-side rendering with hydration
Key concepts
- SSR vs CSR vs SSG
- hydration
- getServerSideProps / loaders
- ISR
- streaming SSR
- SEO benefits
- time to first byte
Background Jobs & Async Processing
Task queues, background workers, cron jobs, message brokers, retry strategies, and dead letter queues
Objectives
- Design background job processing for long-running tasks
- Implement retry and failure handling strategies
Key concepts
- task queues (Celery/Bull/Sidekiq)
- message brokers
- retry with backoff
- dead letter queues
- idempotency
- cron scheduling
- async vs sync processing
SSR/SSG/ISR Trade-offs
Choosing and combining server-side rendering, static generation, and incremental static regeneration for optimal full-stack performance
Objectives
- Select and combine SSR, SSG, and ISR patterns based on content freshness and performance requirements
- Diagnose hydration and TTFB issues in server-rendered full-stack applications
Key concepts
- SSR hydration
- SSG build time
- ISR revalidation
- streaming SSR
- edge rendering
- cache invalidation
- TTFB optimization
Full-Stack Security
Comprehensive full-stack security: CSRF, session fixation, CORS misconfiguration, and secure cookie patterns
Objectives
- Identify and remediate common full-stack security vulnerabilities across frontend and backend
- Design secure cookie and session management that prevents CSRF, fixation, and XSS attacks
Key concepts
- CSRF tokens
- SameSite cookies
- session fixation
- CORS misconfig
- HttpOnly
- Secure flag
- Content-Security-Policy
- OWASP Top 10
3 · Data Layer5 topics
Relational Schema Design
Normalization forms, denormalization trade-offs, entity-relationship modeling, constraints, and migration strategies
Objectives
- Design normalized schemas for application data
- Make informed denormalization decisions
Key concepts
- 1NF / 2NF / 3NF
- denormalization
- ER diagrams
- constraints
- migrations
- referential integrity
- composite keys
ORM Usage & N+1 Prevention
Using ORMs effectively, eager vs lazy loading, N+1 query detection and prevention, raw query fallbacks
Objectives
- Detect and fix N+1 query problems
- Use ORM features efficiently without sacrificing performance
Key concepts
- ORM patterns
- eager loading
- lazy loading
- N+1 problem
- query optimization
- raw SQL fallback
- query logging
Caching (Redis/Memcached)
Caching strategies, cache invalidation, TTL policies, cache-aside vs write-through, distributed caching with Redis or Memcached
Objectives
- Design caching strategies for web applications
- Handle cache invalidation correctly
Key concepts
- cache-aside
- write-through
- write-behind
- TTL
- cache invalidation
- Redis data structures
- distributed caching
API Data Contracts & Validation
Request/response schemas, OpenAPI/Swagger, schema validation with Pydantic or Zod, versioning, and backward compatibility
Objectives
- Define and enforce API contracts
- Implement schema validation for API endpoints
Key concepts
- OpenAPI / Swagger
- schema validation
- Pydantic / Zod / Joi
- API versioning
- backward compatibility
- contract testing
- request/response DTOs
Database Performance Tuning
Query plan analysis, index optimization, partitioning, connection pooling, read replicas, and slow query diagnosis
Objectives
- Analyze and optimize slow database queries
- Design indexing strategies for production workloads
Key concepts
- EXPLAIN / query plans
- index strategies
- partitioning
- connection pooling
- read replicas
- slow query logs
- database sharding
4 · DevOps & Deployment5 topics
Git Workflows & Branching
Git branching strategies, trunk-based development, Git Flow, merge vs rebase, pull request workflows, and conflict resolution
Objectives
- Apply appropriate branching strategies for team collaboration
- Resolve merge conflicts effectively
Key concepts
- branching strategies
- trunk-based development
- Git Flow
- merge vs rebase
- pull requests
- conflict resolution
- semantic commits
Docker & Containerization
Dockerfiles, multi-stage builds, Docker Compose, container networking, image optimization, and container orchestration basics
Objectives
- Write production-ready Dockerfiles
- Orchestrate multi-container applications with Docker Compose
Key concepts
- Dockerfile
- multi-stage builds
- Docker Compose
- container networking
- volumes
- image optimization
- container registries
CI/CD Pipeline Setup
Continuous integration and deployment pipelines, build automation, test automation, deployment strategies, and artifact management
Objectives
- Design CI/CD pipelines for full-stack applications
- Implement safe deployment strategies
Key concepts
- CI pipeline stages
- automated testing
- build artifacts
- deployment strategies
- blue-green deployment
- canary releases
- rollback strategies
Cloud Service Basics (AWS/GCP/Azure)
Core cloud services for compute, storage, databases, and networking; serverless basics, managed services, and cost optimization
Objectives
- Select appropriate cloud services for application components
- Understand serverless vs container deployment trade-offs
Key concepts
- compute (EC2/Cloud Run/App Service)
- object storage (S3/GCS/Blob)
- managed databases (RDS/Cloud SQL)
- serverless (Lambda/Cloud Functions)
- load balancers
- CDN
- cost management
Infrastructure as Code Basics
Terraform, CloudFormation, or Pulumi basics; resource provisioning, state management, modules, and environment parity
Objectives
- Provision infrastructure using code
- Manage infrastructure state across environments
Key concepts
- Terraform / CloudFormation / Pulumi
- declarative infrastructure
- state management
- modules / stacks
- environment parity
- drift detection
- plan and apply workflow
5 · System Design & Architecture6 topics
Monolith to Microservices
Decomposition strategies, bounded contexts, strangler fig pattern, service boundaries, and migration planning
Objectives
- Identify service boundaries using domain-driven design
- Plan incremental migration from monolith to microservices
Key concepts
- monolith vs microservices
- bounded contexts
- strangler fig pattern
- service boundaries
- data ownership
- shared nothing
- migration planning
API Gateway Patterns
API gateway responsibilities, BFF pattern, rate limiting, request routing, authentication at the edge, and API composition
Objectives
- Design API gateway architectures for microservices
- Implement cross-cutting concerns at the edge
Key concepts
- API gateway
- BFF pattern
- rate limiting
- request routing
- edge authentication
- API composition
- circuit breaker at gateway
Event-Driven Communication
Event sourcing, CQRS, message queues, pub/sub, eventual consistency, and saga patterns for distributed transactions
Objectives
- Design event-driven architectures for loosely coupled services
- Handle distributed transactions with sagas
Key concepts
- event sourcing
- CQRS
- pub/sub
- message queues
- eventual consistency
- saga pattern
- idempotent consumers
Scalability Planning
Horizontal vs vertical scaling, load balancing, database sharding, CDN strategy, auto-scaling, and capacity planning
Objectives
- Design scalable architectures for growing applications
- Plan capacity for anticipated traffic patterns
Key concepts
- horizontal scaling
- vertical scaling
- load balancing algorithms
- database sharding
- CDN strategy
- auto-scaling policies
- capacity planning
Multi-Tenant Architecture
Tenant isolation strategies, shared vs dedicated resources, data partitioning, tenant-aware routing, and noisy neighbor prevention
Objectives
- Design multi-tenant architectures with appropriate isolation
- Handle tenant data partitioning and routing
Key concepts
- tenant isolation
- shared database / shared schema
- database per tenant
- schema per tenant
- tenant-aware routing
- noisy neighbor
- tenant onboarding
Micro-Frontend Architecture
Decomposing frontend monoliths into independently deployable micro-frontends using Module Federation or iframes
Objectives
- Design micro-frontend architectures that enable team independence and independent deployability
- Manage shared dependencies and communication patterns across micro-frontend boundaries
Key concepts
- Module Federation
- routing shells
- shared dependencies
- communication patterns
- team independence
- deployment isolation
6 · Production Operations6 topics
Logging & Error Tracking
Structured logging, log levels, centralized log aggregation, error tracking with Sentry/Datadog, correlation IDs, and log retention
Objectives
- Implement structured logging for production applications
- Set up error tracking and alerting
Key concepts
- structured logging
- log levels
- centralized logging (ELK/CloudWatch)
- error tracking (Sentry)
- correlation IDs
- log retention
- PII in logs
Monitoring & Alerting
Application and infrastructure monitoring, metrics collection, dashboards, alerting thresholds, SLIs/SLOs, and observability
Objectives
- Design monitoring strategies using golden signals
- Set up meaningful alerts that reduce noise
Key concepts
- metrics (Prometheus/CloudWatch)
- dashboards (Grafana)
- alerting thresholds
- SLIs and SLOs
- golden signals
- distributed tracing
- observability pillars
Feature Flags & Progressive Rollout
Feature flag systems, percentage rollouts, A/B testing, kill switches, flag lifecycle management, and dark launches
Objectives
- Implement feature flag systems for safe releases
- Manage flag lifecycle to avoid technical debt
Key concepts
- feature flags
- percentage rollout
- A/B testing
- kill switches
- flag lifecycle
- dark launches
- flag debt management
Incident Response
Incident management process, severity classification, on-call rotations, postmortems, runbooks, and blameless culture
Objectives
- Lead incident response following established processes
- Write effective postmortems with actionable follow-ups
Key concepts
- incident severity levels
- on-call rotations
- runbooks
- postmortems
- blameless culture
- communication protocols
- incident commander role
Performance Optimization End-to-End
Full-stack performance analysis, frontend and backend profiling, network optimization, Core Web Vitals, and performance budgets
Objectives
- Diagnose and resolve performance issues across the full stack
- Establish and enforce performance budgets
Key concepts
- Core Web Vitals
- performance budgets
- frontend profiling
- backend profiling
- network waterfall analysis
- bundle optimization
- critical rendering path
Web Performance Budgets
Establishing and enforcing performance budgets across the full stack: Core Web Vitals, resource budgets, and monitoring
Objectives
- Define and enforce performance budgets across Core Web Vitals and resource metrics in CI/CD
- Use resource hints, bundle splitting, and critical path optimization to meet performance budgets
Key concepts
- Core Web Vitals
- LCP/CLS/INP
- performance budgets
- Lighthouse CI
- resource hints
- critical path
- bundle budgets
Levels: Junior, Mid, Senior, and Expert
Explain it in your own words
Graded by AI · no account · 1 questionNo options to guess from: you write, the AI grades against the topic's rubric and tells you what level your answer reads at.
Already studying Full-Stack Engineer?
The assessment measures topic by topic, and your plan skips what you already know.
Open to read. An account is only needed to be measured.
Frequently asked questions
Where should I start studying Full-Stack Engineer?
Start with Frontend Development: Component-Based UI Development, State Management, and Client-Side Routing. The map orders topics by what they depend on, so each one prepares the next.
How long does a full Full-Stack Engineer assessment take?
A full assessment of this path takes about 60 minutes. Study time depends on where you start; a diagnostic shows which topics you can skip.
Do I need an account to use this page?
No. The map, objectives and key concepts are open. You only need an account to be measured, get your gap by topic and receive a plan.