Select your current position

Pick a role and level — we'll show the growth path, skills and gap analysis.

Development path

Junior

0-2 years

Current

Responsibility: Building simple features from UI to API. Working with React/Vue + Node.js/Python. Writing basic tests. Fixing bugs on both sides.

Key skills:

Core Web Vitals Need
Data Fetching Need
Next.js Need
React Core Need
SSR/SSG/ISR Patterns Need
State Management Need
Tailwind CSS Need
Vite & Modern Bundlers Need
Algorithms & Complexity Need
Async Programming Need
Web Accessibility Need
Code Quality & Refactoring Need
Component Testing Need
Bundle Optimization Need
Query Optimization Need
Network Fundamentals Need
Design Patterns Need
OOP & SOLID Principles Need
Design System Development Need
Modern CSS Need
Data Structures Need
Type Safety & Type Systems Need

Middle

2-5 years

Next

Responsibility: Independent end-to-end feature development. Designing APIs and UIs. Setting up CI/CD. Working with databases. Performance optimization.

Key skills:

Core Web Vitals Need
Data Fetching Need
Next.js Need
React Core Need
SSR/SSG/ISR Patterns Need
State Management Need
Tailwind CSS Need
Vite & Modern Bundlers Need
Algorithms & Complexity Need
Async Programming Need
Web Accessibility Need
Code Quality & Refactoring Need
Component Testing Need
Micro Frontends Need
Bundle Optimization Need
Query Optimization Need
Network Fundamentals Need
Design Patterns Need
OOP & SOLID Principles Need
Design System Development Need
Modern CSS Need
Data Structures Need
Type Safety & Type Systems Need

Senior

5-8 years

Responsibility: Application architecture (frontend + backend). Technology selection. UX and performance optimization. Mentoring. Data model design.

Key skills:

AWS Need
Code Review Need
Core Web Vitals Need
Data Fetching Need
Docker Need
E2E Testing Need
Git Advanced Need
GitHub Actions / GitLab CI Need
GitHub Copilot Need
GraphQL Design Need
JWT / OAuth2 / OIDC Need
Kubernetes Core Need
MongoDB Need
Next.js Need
Node.js Frameworks Need
OWASP & Application Security Need
PostgreSQL Need
React Core Need
Redis Need
REST API Design Need
SSR/SSG/ISR Patterns Need
State Management Need
Tailwind CSS Need
Unit Testing Need
Vite & Modern Bundlers Need
Algorithms & Complexity Need
Async Programming Need
Web Accessibility Need
Database Indexing Need
Integration Testing Need
Code Quality & Refactoring Need
Component Testing Need
Database Migrations Need
Micro Frontends Need
Bundle Optimization Need
Query Optimization Need
System Design Fundamentals Need
Network Fundamentals Need
Design Patterns Need
OOP & SOLID Principles Need
WebSocket API Design Need
Data Modeling & Schema Design Need
Design System Development Need
Modern CSS Need
API Versioning Strategies Need
Structured Logging Need
Data Structures Need
Type Safety & Type Systems Need

Lead / Staff

7-12 years

Responsibility: Technical leadership of fullstack team. Architectural decisions. Frontend and backend standards. Coordination with design and product.

Key skills:

AWS Need
Code Review Need
Core Web Vitals Need
Data Fetching Need
Docker Need
E2E Testing Need
Git Advanced Need
GitHub Actions / GitLab CI Need
GitHub Copilot Need
GraphQL Design Need
JWT / OAuth2 / OIDC Need
Kubernetes Core Need
MongoDB Need
Next.js Need
Node.js Frameworks Need
OWASP & Application Security Need
PostgreSQL Need
React Core Need
Redis Need
REST API Design Need
SSR/SSG/ISR Patterns Need
State Management Need
Tailwind CSS Need
Unit Testing Need
Vite & Modern Bundlers Need
Algorithms & Complexity Need
Async Programming Need
Web Accessibility Need
Database Indexing Need
Integration Testing Need
Code Quality & Refactoring Need
Component Testing Need
Database Migrations Need
Micro Frontends Need
Bundle Optimization Need
Query Optimization Need
System Design Fundamentals Need
Design Patterns Need
OOP & SOLID Principles Need
WebSocket API Design Need
Data Modeling & Schema Design Need
Design System Development Need
Modern CSS Need
API Versioning Strategies Need
Structured Logging Need
Data Structures Need
Type Safety & Type Systems Need

Principal

10+ years

Responsibility: Product engineering strategy. Choosing technology stack for the company. Architecture for fast time-to-market.

Key skills:

AWS Need
Code Review Need
Core Web Vitals Need
Data Fetching Need
Docker Need
E2E Testing Need
Git Advanced Need
GitHub Actions / GitLab CI Need
GitHub Copilot Need
GraphQL Design Need
JWT / OAuth2 / OIDC Need
Kubernetes Core Need
MongoDB Need
Next.js Need
Node.js Frameworks Need
OWASP & Application Security Need
PostgreSQL Need
React Core Need
Redis Need
REST API Design Need
SSR/SSG/ISR Patterns Need
State Management Need
Tailwind CSS Need
Unit Testing Need
Vite & Modern Bundlers Need
Algorithms & Complexity Need
Async Programming Need
Web Accessibility Need
Database Indexing Need
Integration Testing Need
Code Quality & Refactoring Need
Component Testing Need
Database Migrations Need
Bundle Optimization Need
System Design Fundamentals Need
Design Patterns Need
OOP & SOLID Principles Need
WebSocket API Design Need
Data Modeling & Schema Design Need
Design System Development Need
Modern CSS Need
API Versioning Strategies Need
Structured Logging Need
Data Structures Need
Type Safety & Type Systems Need

Gap analysis: skills to develop

To reach the next level you'll need to develop:

Core Web Vitals

Independently implements complex UI components with Core Web Vitals optimization. Optimizes rendering performance. Writes tests. Applies for state management.

Data Fetching

Implements data fetching patterns with React Query/SWR on the frontend and REST/GraphQL APIs on the backend. Optimizes caching, deduplication, and loading states across the full stack.

Next.js

Independently implements complex UI components with Next.js. Optimizes rendering performance. Writes tests. Applies for state management.

React Core

Independently implements complex UI components with React Core. Optimizes rendering performance. Writes tests. Applies for state management.

SSR/SSG/ISR Patterns

Independently implements complex UI components with SSR/SSG/ISR patterns. Optimizes rendering performance. Writes tests. Applies for state management.

State Management

Independently implements complex UI components with State Management. Optimizes rendering performance. Writes tests. Applies for state management.

Tailwind CSS

Independently implements complex UI components with Tailwind CSS. Optimizes rendering performance. Writes tests. Applies for state management.

Vite & Modern Bundlers

Independently implements complex UI components with Vite and modern bundlers. Optimizes rendering performance. Writes tests. Applies for state management.

Algorithms & Complexity

Independently applies algorithmic thinking across the stack: selects efficient query algorithms on backend, understands virtual scrolling and pagination algorithms on frontend, evaluates data processing trade-offs between client and server. Analyzes end-to-end complexity of feature implementations.

Async Programming

Independently applies async programming across the stack: server-side async request handling, client-side async data fetching, WebSocket/SSE for real-time updates. Understands trade-offs between different async patterns on frontend and backend.

Web Accessibility

Ensures accessibility on both sides: implements server-side rendered accessible HTML with SSR frameworks, configures API responses for accessibility (alt text in image API, structured error messages). Tests with axe-core and verifies keyboard navigation.

Code Quality & Refactoring

Independently applies code quality practices across frontend and backend. Writes consistent code with shared type definitions and clear API boundaries. Understands trade-offs between DRY code sharing and independent deployability. Reviews full-stack features for proper error propagation and data validation consistency.

Component Testing

Independently implements complex UI components with component testing. Optimizes rendering performance. Writes tests. Applies for state management.

Micro Frontends

Works with micro-frontends in fullstack context: implements BFF layer for each micro-frontend, configures API composition for data aggregation, applies Module Federation for frontend integration. Ensures end-to-end type safety through shared TypeScript types between frontend and backend.

Bundle Optimization

Independently implements complex UI components with bundle optimization. Optimizes rendering performance. Writes tests. Applies for state management.

Query Optimization

Analyzes slow queries through EXPLAIN. Eliminates N+1 problems in ORM (eager loading, select_related). Optimizes JOINs (order, types). Uses window functions (ROW_NUMBER, LAG/LEAD). Understands the difference between correlated and non-correlated subqueries.

Network Fundamentals

Applies networking knowledge in fullstack development: CORS configuration for API, SSL/TLS certificates, HTTP/2 multiplexing. Understands CDN architecture for static assets, DNS configuration for domains and diagnoses latency issues between frontend and backend.

Design Patterns

Independently applies design patterns across full stack: repository pattern for backend data access, strategy for interchangeable service implementations, observer for frontend reactivity, adapter for API integration layers. Explains pattern trade-offs for full-stack architecture coherence.

OOP & SOLID Principles

Independently applies OOP/SOLID across frontend and backend: proper service abstractions shared between layers, interface-based API contracts, single responsibility in both UI components and server handlers. Understands trade-offs between OOP and functional patterns across the full stack.

Design System Development

Independently implements complex UI components with design system development. Optimizes rendering performance. Writes tests. Applies for state management.

Modern CSS

Independently implements complex UI components with modern CSS. Optimizes rendering performance. Writes tests. Applies for state management.

Data Structures

Independently selects appropriate data structures across the stack: normalized database schemas, API response DTOs, client-side state trees for UI. Understands trade-offs between data format choices for efficient serialization between frontend and backend.

Type Safety & Type Systems

Independently applies type safety across frontend and backend — TypeScript strict mode for shared type definitions, API contract types with tRPC/GraphQL codegen, and end-to-end type-safe data flow. Understands trade-offs between runtime validation and compile-time guarantees across system boundaries. Applies type-safe patterns in code reviews.