AI Coding Assistants 1
▼
Uses GitHub Copilot for accelerating fullstack development: autocompleting React components, Express routes, SQL queries. Checks proposed code for correctness and security, understands that AI code requires review.
Effectively uses Copilot in fullstack projects: generating TypeScript types from API specifications, creating tests for both layers, writing utility functions. Uses Copilot Chat for explaining unfamiliar code and quick context switching between stacks.
Optimizes fullstack development with Copilot: custom project instructions, boilerplate generation for end-to-end features, routine task automation. Critically evaluates AI suggestions for security and architectural conformance, trains team.
Defines Copilot usage policy in the fullstack organization: licensing, restrictions for sensitive code, best practices. Measures impact on team productivity, establishes guidelines and ensures AI-assisted code quality.
Algorithms & Data Structures 2
▼
Understands the fundamentals of Algorithms & Complexity at a basic level. Applies simple concepts in work tasks using TypeScript/Python. Follows recommendations from senior developers when solving problems.
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.
Applies algorithmic expertise across the stack: query optimization algorithms on backend, virtual scrolling algorithms on frontend, efficient pagination and cursor-based algorithms for API data fetching. Designs end-to-end data processing algorithms balancing server and client computational loads.
Designs fullstack application architecture considering algorithmic complexity at all levels: from SQL queries and server logic to client-side component rendering. Optimizes bottlenecks across the entire stack using profiling and benchmarks.
Understands the fundamentals of Data Structures at a basic level. Applies simple concepts in work tasks using TypeScript/Python. Follows recommendations from senior developers when solving problems.
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.
Selects optimal data structures across the full stack: normalized vs denormalized database schemas, API response data shaping, client-side state trees for efficient UI rendering. Optimizes data transfer formats between frontend and backend layers. Designs shared type definitions that enable efficient serialization and validation across stack boundaries.
Selects optimal data structures for each fullstack application layer: HashMap for Redis cache, B-trees for PostgreSQL indexes, normalized stores for frontend state. Trains the team on data structure selection principles for specific tasks.
API Protocols 1
▼
Implements basic WebSocket connections in fullstack applications: subscribing to events with Socket.io on client, handling messages on server. Understands connection lifecycle and displays real-time updates in React/Vue components.
Designs WebSocket communication for fullstack features: rooms and namespaces in Socket.io, reconnection handling on client, server event broadcasting. Implements real-time update patterns: chat, notifications, collaborative editing.
Creates scalable WebSocket architecture for fullstack applications: Redis adapter for horizontal scaling, SSE as alternative for unidirectional streams, rate limiting. Optimizes reconnect logic and frontend state reconciliation.
Defines real-time communication strategy for the fullstack platform: WebSocket vs SSE vs polling for different scenarios, pub/sub architecture. Designs scalable infrastructure for real-time features and messaging protocol standards for the team.
Authentication & Authorization 1
▼
Implements basic JWT authentication in fullstack applications: login through form, token storage, sending in API request headers. Understands JWT structure, difference between access and refresh tokens, implements route protection on frontend and backend.
Integrates OAuth 2.0 into fullstack applications: authorization through Google/GitHub, PKCE flow for SPA, callback handling. Implements refresh token rotation, backend session management and frontend authentication state with proper token expiration handling.
Designs fullstack application authentication: SSO through OpenID Connect, multi-tenant authorization, RBAC with checks on frontend and backend. Configures secure token storage (httpOnly cookies vs memory), CSP for OAuth and protection against token theft.
Defines authentication strategy for the fullstack platform: centralized identity provider, token management standards, audit logging. Designs authorization architecture with a unified model for frontend and backend, trains the team on security best practices.
Build Tools & Bundling 1
▼
Works with Vite in fullstack projects: understands dev server with HMR, basic configuration for React/Vue. Can set up proxy for API requests to backend, import assets and use environment variables for different environments.
Independently implements complex UI components with Vite and modern bundlers. Optimizes rendering performance. Writes tests. Applies for state management.
Configures Vite for fullstack development: custom plugins, SSR mode for server-side rendering, dependency pre-bundling optimization. Configures multi-entry builds for different application parts and integrates Vitest for end-to-end testing.
Designs Vite infrastructure for the fullstack platform: monorepo configuration with shared plugins, SSR pipeline, custom transforms. Defines configuration standards for the team and optimizes DX in fullstack development with a unified build tool.
CI/CD 1
▼
Understands basic GitHub Actions for fullstack projects: reading workflow files, viewing CI results. Runs linting and tests for frontend and backend, understands the pipeline concept and why automated code checking is needed.
Creates GitHub Actions workflows for fullstack applications: parallel jobs for frontend and backend tests, Docker image builds, staging deployment. Configures node_modules caching, matrix builds and conditional execution based on changed paths.
Designs CI/CD pipelines for fullstack applications: monorepo-aware builds with affected package detection, e2e tests with Playwright, canary deployments. Optimizes build time, configures PR preview deployments and automated migration verification.
Defines CI/CD strategy for the fullstack platform: standard pipelines for different project types, reusable workflows, automated quality gates. Designs release process: semantic versioning, changelog, coordinated frontend and backend deployment.
Clean Code & Refactoring 1
▼
Understands the fundamentals of Code Quality & Refactoring at a basic level. Applies simple concepts in work tasks using TypeScript/Python. Follows recommendations from senior developers when solving problems.
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.
Designs code quality standards across frontend and backend: consistent patterns for API contracts, shared type definitions, mono-repo code organization. Refactors full-stack features for clear separation of concerns between UI, business logic, and data layers. Establishes cross-stack review practices for end-to-end code quality.
Implements unified code quality standards for fullstack projects: shared ESLint config for client and server, pre-commit hooks, automated linting in CI. Configures SonarQube for cross-stack analysis. Conducts architectural reviews focused on stack consistency.
Concurrency & Parallelism 1
▼
Understands the fundamentals of Async Programming at a basic level. Applies simple concepts in work tasks using TypeScript/Python. Follows recommendations from senior developers when solving problems.
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.
Designs async architectures across the stack: server-side async request processing pipelines, client-side concurrent data fetching strategies, WebSocket/SSE real-time communication patterns. Mentors team on end-to-end async design.
Designs end-to-end async flows: from WebSocket connections and SSE on frontend through message queues on backend to async workers. Solves race condition and deadlock problems at all stack levels, implements graceful degradation patterns.
Containerization 1
▼
Uses Docker for local fullstack development: runs PostgreSQL and Redis containers through docker-compose, understands Dockerfile for Node.js applications. Can build and run the entire stack locally with a single command.
Creates Docker environments for fullstack projects: multi-stage Dockerfile for optimal image size, docker-compose with frontend, backend and database. Configures hot-reload for development, volume mounts and networking between services.
Optimizes Docker infrastructure for fullstack applications: minimal images on Alpine/distroless, layer caching for fast CI builds, health checks. Designs multi-service compose for staging and configures Docker for SSR applications.
Designs Docker strategy for the fullstack platform: standard base images, docker-compose templates for different project types, CI/CD pipeline optimization. Defines image security policies and trains the team on fullstack application containerization.
CSS & Styling 3
▼
Uses design system components to build fullstack application UI: buttons, forms, cards from documentation. Follows composition and reuse principles, correctly passes props and applies component variants.
Independently implements complex UI components with design system development. Optimizes rendering performance. Writes tests. Applies for state management.
Develops design system components for fullstack project: typed interfaces, accessibility, theme support. Creates Storybook documentation and integration tests. Ensures UI consistency between server-rendered and client-side parts of the application.
Designs design system architecture for the fullstack platform: modular package structure, versioning, changelog process. Coordinates frontend developers and designers, defines component APIs and system evolution strategy.
Applies modern CSS for fullstack application styling: Flexbox and Grid for layouts, CSS variables for theming, media queries for responsiveness. Understands cascade and specificity, builds layouts from designs with pixel-perfect accuracy.
Independently implements complex UI components with modern CSS. Optimizes rendering performance. Writes tests. Applies for state management.
Creates complex CSS solutions for fullstack applications: GPU-accelerated animations, Container Queries for component-level responsiveness, CSS Layers for specificity management. Optimizes critical CSS for SSR pages and resolves FOUC issues.
Designs CSS architecture for fullstack applications: CSS-in-JS vs utility-first strategy, critical CSS management with SSR, style loading optimization. Defines styling standards and solves architectural CSS scaling problems for the team.
Builds fullstack application UI components with Tailwind CSS from designs, using utility classes for typography, spacing and colors. Applies responsive prefixes for adaptivity and follows project design tokens.
Independently implements complex UI components with Tailwind CSS. Optimizes rendering performance. Writes tests. Applies for state management.
Creates scalable design system on Tailwind for fullstack project: custom theme with tokens, reusable components, dark mode. Optimizes final CSS bundle through purge and configures Tailwind config for the entire application's needs.
Designs style architecture for fullstack applications on Tailwind: unified design token config, component library with variants, Storybook integration. Defines styling standards for the team and ensures visual consistency.
Data Modeling 2
▼
Creates basic data models for fullstack features: tables with proper types, foreign keys, NOT NULL constraints. Understands the connection between database schema, backend types (TypeScript interfaces) and frontend data structure.
Independently designs schemas and optimizes queries with data modeling and schema design. Understands indexing and query execution plans. Uses Prisma/SQLAlchemy effectively.
Designs data models for fullstack applications across the entire stack: normalized database schema, DTO transformation on backend, normalized store on frontend. Applies DDD approach, separates read/write models and optimizes for UI usage patterns.
Defines data modeling architecture for the fullstack platform: single source of truth in database schema, type auto-generation for backend and frontend through Prisma/GraphQL codegen. Establishes naming and model evolution standards for the team.
Creates basic migrations for fullstack applications: adding tables and columns through Prisma Migrate or Knex. Understands migration execution order, writes reversible migrations and coordinates schema changes with API and frontend updates.
Independently designs schemas and optimizes queries with database migrations. Understands indexing and query execution plans. Uses Prisma/SQLAlchemy effectively.
Implements complex migrations for fullstack applications: zero-downtime schema changes, data migrations with transformation, expand-contract scenarios. Coordinates migration deployment with backend and frontend updates, ensuring API backward compatibility.
Designs migration process for the fullstack platform: CI/CD automation, review of dangerous operations (DROP, ALTER TYPE), rollback strategy. Defines team standards: naming, migration testing, coordination with frontend releases.
Database Optimization 2
▼
Understands the role of indexes in fullstack applications: creates B-tree indexes for frequent WHERE conditions, unique indexes for business keys. Analyzes EXPLAIN plans for slow ORM-generated queries on backend and adds missing indexes.
Independently designs schemas and optimizes queries with database indexing. Understands indexing and query execution plans. Uses Prisma/SQLAlchemy effectively.
Optimizes indexes for fullstack applications based on actual usage patterns: composite indexes for complex UI filters, partial indexes for active records, GIN indexes for JSONB and full-text search. Monitors index usage and eliminates redundant ones.
Designs indexing strategy for the fullstack platform: automated slow query analysis, index review process during migrations, performance monitoring. Trains the team on indexing principles for typical fullstack scenarios — lists, search, pagination.
Writes basic SQL queries (SELECT, JOIN, WHERE, GROUP BY). Understands that queries can be slow. Knows that EXISTS is usually faster than IN for subqueries.
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.
Deeply analyzes query plans (Seq Scan vs Index Scan, Nested Loop vs Hash Join). Optimizes query planner hints. Uses materialized views for precomputations. Optimizes bulk operations (COPY, batch inserts). Tunes work_mem, shared_buffers for specific queries.
Designs query optimization strategy for the entire system. Configures automated slow query monitoring (pg_stat_statements, auto_explain). Optimizes cross-shard queries. Designs denormalization for critical hot paths. Makes decisions on precomputation vs real-time aggregation. Trains the team on query plan analysis.
E2E Testing 1
▼
Writes basic e2e tests for fullstack applications with Playwright or Cypress: page navigation, form filling, result verification. Understands the full test cycle from UI through API to database and back, uses page object pattern.
Creates e2e tests for critical fullstack scenarios: registration, payments, CRUD operations with database verification. Configures test environment with seed data, external service mocks and parallel test execution for speed.
Designs e2e testing for fullstack applications: Playwright with API mocks and real backend, visual regression testing, performance tests. Integrates into CI with parallelization, flaky-test detection and automated retry for stability.
Defines e2e testing strategy for the fullstack platform: critical scenarios for automation, balance with unit/integration tests, execution time SLA. Creates infrastructure for stable e2e tests and trains the team on effective practices.
Frontend Architecture 2
▼
Understands micro-frontends as part of fullstack architecture: knows how frontend micro-apps relate to backend microservices, understands BFF (Backend For Frontend) pattern. Knows main approaches to micro-frontend integration.
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.
Designs fullstack micro-frontend architecture: defines vertical slice architecture (frontend + BFF + service per domain), configures shared authentication through token propagation, designs unified error handling. Ensures observability through distributed tracing from browser to backend.
Standardizes fullstack micro-frontend platform: creates project templates for vertical slices, designs shared infrastructure (auth, logging, feature flags), defines deployment strategy. Coordinates frontend and backend teams for aligned domain boundaries.
Understands SSR and SSG concepts in fullstack development: difference between server and client rendering, hydration, static generation. Creates simple pages with getServerSideProps/getStaticProps in Next.js, understands when each approach is appropriate.
Independently implements complex UI components with SSR/SSG/ISR patterns. Optimizes rendering performance. Writes tests. Applies for state management.
Implements complex SSR/SSG scenarios for fullstack applications: streaming SSR for fast TTFB, ISR for scalable static content, React server components for reducing JS bundle. Optimizes hydration and resolves server-client rendering mismatch issues.
Designs rendering architecture for the fullstack platform: SSR vs SSG vs ISR strategy for different content types, edge rendering, CDN caching. Defines data fetching patterns for server rendering and standards for the team.
Frontend Testing 1
▼
Writes basic React/Vue component tests for fullstack applications with Testing Library: rendering, text verification, button clicks. Tests components with API request mocks and understands the principle of testing behavior, not implementation.
Independently implements complex UI components with component testing. Optimizes rendering performance. Writes tests. Applies for state management.
Creates comprehensive component testing strategy for fullstack applications: integration tests with MSW for API mocking, server component tests, design system snapshot tests. Configures coverage reports and ensures testing of end-to-end scenarios from request to UI.
Designs component testing architecture for the fullstack platform: test utilities with preconfigured providers, backend mock standards, visual regression testing. Defines coverage strategy and trains the team on effective testing patterns.
Integration Testing 1
▼
Writes basic integration tests for fullstack applications: testing API endpoints with supertest, verifying controller → service → database chain. Understands the difference between unit and integration tests, uses test database.
Creates integration tests for fullstack scenarios: API tests with real database through testcontainers, middleware chain tests, GraphQL resolver verification. Configures fixtures and seed data, tests authorization and business logic across layers.
Designs integration testing for fullstack applications: contract testing between frontend and backend with Pact, tests with real services through docker-compose, migration testing. Creates infrastructure for reproducible test environments.
Defines integration testing strategy for the fullstack platform: consumer-driven contracts, test environments with docker-compose, automated PR execution. Trains the team on testing service boundaries and ensures frontend-backend compatibility.
Kubernetes & Orchestration 1
▼
Understands basic Kubernetes concepts for fullstack applications: Pod, Service, Deployment, ConfigMap. Reads manifests, can view pod logs and understands how a fullstack application deploys in a cluster — frontend, backend, database.
Creates Kubernetes manifests for fullstack applications: Deployment with readiness/liveness probes, Service for internal communication, Ingress for routing. Configures ConfigMap and Secrets for frontend and backend environment variables.
Designs Kubernetes architecture for fullstack applications: HPA for backend autoscaling, separate deployments for SSR and API, update strategies. Configures service mesh, resource monitoring and optimizes cluster resource consumption.
Defines Kubernetes strategy for the fullstack platform: namespace organization, Helm charts for typical applications, GitOps with ArgoCD. Designs deployment standards for the team: canary releases, blue-green, automatic rollback on metric degradation.
Networking 1
▼
Understands basic networking concepts spanning frontend and backend — HTTP/HTTPS protocols, CORS, DNS resolution, and reverse proxy basics. Follows team guidelines for configuring API routing, SSL termination, and debugging end-to-end network connectivity issues.
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.
Designs network architecture for fullstack applications: HTTP/3 optimization for frontend, gRPC between microservices, VPN for internal services. Configures edge routing, optimizes TCP settings for WebSocket and resolves complex network interaction issues.
NoSQL Databases 1
▼
Performs basic MongoDB operations in fullstack applications: CRUD through Mongoose, simple queries and aggregations. Understands the document model and when it's preferable to relational, creates schemas for storing user form data.
Independently designs schemas and optimizes queries with MongoDB. Understands indexing and query execution plans. Uses Prisma/SQLAlchemy effectively.
Designs MongoDB schemas for fullstack applications: denormalization for fast frontend reads, indexes for search scenarios, aggregation pipeline for analytics. Implements embedded vs referenced document patterns and optimizes queries for UI.
Defines MongoDB strategy for fullstack projects: sharding for scaling, change streams for real-time frontend updates, replication. Designs hybrid PostgreSQL+MongoDB solutions and establishes modeling standards for the team.
OOP & Design Patterns 2
▼
Understands the fundamentals of Design Patterns at a basic level. Applies simple concepts in work tasks using TypeScript/Python. Follows recommendations from senior developers when solving problems.
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.
Has deep expertise in design patterns across full stack: designs cohesive architectures bridging frontend and backend patterns, implements API contract patterns for service integration, optimizes pattern usage for end-to-end system performance. Mentors team on full-stack architectural patterns for production applications.
Applies design patterns across the entire stack: Repository and Unit of Work on backend, Compound Components and Render Props on frontend, BFF pattern for connection. Reviews team architectural decisions ensuring approach consistency.
Understands the fundamentals of OOP & SOLID Principles at a basic level. Applies simple concepts in work tasks using TypeScript/Python. Follows recommendations from senior developers when solving problems.
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.
Applies OOP/SOLID across the full stack: consistent abstraction patterns between frontend services and backend layers, shared interface contracts for API communication, dependency inversion for testable cross-stack modules. Designs clean architectures that maintain SOLID principles across stack boundaries.
Designs domain models for fullstack applications applying SOLID and DDD: service layer with clean architecture on backend, composition and dependency inversion on frontend. Ensures unified domain logic through shared packages between client and server.
React Ecosystem 2
▼
Uses Next.js at a basic level. Creates simple components from designs. Understands basic concepts and follows component guidelines.
Independently implements complex UI components with Next.js. Optimizes rendering performance. Writes tests. Applies for state management.
Designs fullstack Next.js solutions with Server Actions, API routes, and middleware. Optimizes database queries in server components and implements auth/session management. Creates reusable fullstack patterns.
Defines frontend architecture at product level with Next.js. Establishes standards and best practices. Conducts architectural reviews.
Builds simple React components integrated with backend APIs. Understands JSX, props, and state for full-stack feature development. Follows component patterns established by the team for consistent UI layers.
Independently implements complex UI components with React Core. Optimizes rendering performance. Writes tests. Applies for state management.
Creates complex React components for fullstack applications with optimal server and client state management. Integrates React Query/SWR for API synchronization, applies suspense patterns and rendering optimization for seamless UX.
Designs React architecture for fullstack applications: separating server and client components, data prefetching strategy, optimistic updates. Defines component library structure and backend integration standards for the team.
Relational Databases 1
▼
Writes basic SQL queries for fullstack applications: CRUD operations, JOINs, filtering. Understands the connection between PostgreSQL schema and backend models (Prisma/TypeORM), can read query plans and create tables for new features.
Independently designs schemas and optimizes queries with PostgreSQL. Understands indexing and query execution plans. Uses Prisma/SQLAlchemy effectively.
Designs PostgreSQL schemas for fullstack applications: normalization, indexes for frequent frontend queries, JSONB for flexible structures. Optimizes N+1 queries through DataLoader, configures connection pooling and writes complex queries with CTEs and window functions.
Defines PostgreSQL architecture for the fullstack platform: partitioning strategy, replication for read-heavy UI scenarios, migration process. Optimizes database performance for frontend and backend access patterns, trains the team.
REST API 1
▼
Creates basic REST endpoints for fullstack applications: CRUD routes with proper HTTP methods and status codes. Implements frontend request → router → controller → database chain, understands REST conventions and JSON response structure.
Designs REST API for fullstack features: pagination, filtering and sorting for frontend tables, nested resources, HATEOAS links. Implements middleware for validation, authentication and error handling with user-friendly messages for UI.
Designs REST API for fullstack applications considering frontend needs: BFF endpoints for optimal data loading, sparse fieldsets, ETags for caching. Creates OpenAPI specifications with auto-generated types and clients for frontend.
Defines REST API standards for the fullstack platform: design guidelines, versioning, contract-first approach with OpenAPI. Designs BFF layer for data aggregation, defines error handling and pagination patterns for the team.
State Management 2
▼
Implements basic data fetching patterns in fullstack applications: fetch/axios for REST API, handling loading/error states, displaying data in components. Understands the request lifecycle from client through server to database and back.
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.
Designs data-fetching layer for fullstack applications: React Query/SWR with caching and invalidation, optimistic updates, parallel requests. Implements SSR data-fetching with hydration, data streaming and prefetch strategies for optimal UX.
Defines data fetching architecture for the fullstack platform: BFF pattern for aggregation, tRPC or GraphQL for type-safe data fetching, caching strategy at all levels. Creates standard hooks and utilities for the team, optimizes waterfall requests.
Manages fullstack application state at a basic level: useState/useReducer for local state, context for global data (theme, user). Understands the difference between server and client state in full stack context.
Independently implements complex UI components with State Management. Optimizes rendering performance. Writes tests. Applies for state management.
Designs state management for fullstack applications: Zustand/Jotai for client state, React Query for server state, separating cache from UI state. Implements optimistic updates with rollback on API errors and cross-tab synchronization.
Defines state architecture for the fullstack platform: server vs client state strategy, data normalization, real-time updates through WebSocket. Creates standard patterns and utilities for the team, ensures predictable data flows.
Type Systems 1
▼
Understands the fundamentals of Type Safety & Type Systems at a basic level. Applies simple concepts in work tasks using TypeScript/Python. Follows recommendations from senior developers when solving problems.
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.
Has deep expertise in cross-stack type safety — designs shared type schemas between frontend and backend with code generation, implements end-to-end type-safe APIs with tRPC or GraphQL codegen, and architects monorepo type sharing strategies. Mentors team on maintaining type consistency across system boundaries, runtime validation at API edges, and balancing type strictness with development velocity.
Ensures end-to-end type safety in fullstack applications: from database schema through Prisma/Drizzle to tRPC or typed GraphQL resolvers and auto-generated frontend types. Implements Zod validation at layer boundaries, configures strict TypeScript for the entire monorepo.
Unit Testing 1
▼
Writes basic unit tests for fullstack applications: tests for utility functions and React components with Jest/Vitest, API call mocks. Understands test structure (arrange-act-assert) and can test both server logic and client hooks.
Creates unit tests for fullstack code: testing backend services with database mocks, React hooks with renderHook, Redux/Zustand stores. Applies parameterized tests, fixtures and factory pattern for generating test data across both application layers.
Designs unit testing strategy for fullstack applications: test architecture for server and client logic, shared test utilities, coverage targets. Creates test infrastructure with preconfigured ORM, API and provider mocks to accelerate test development.
Defines unit testing standards for the fullstack platform: test pyramid for fullstack projects, quality metrics, CI automation. Trains the team on testing end-to-end scenarios from API to UI and creates test templates for typical fullstack patterns.
Web Frameworks 1
▼
Uses Node.js Frameworks at a basic level. Performs simple tasks using established templates. Understands basic concepts and follows team practices.
Independently implements backend APIs with Node.js frameworks (Express/Next.js API routes/NestJS) alongside frontend. Understands SSR/SSG patterns, API route design, and full-stack data flow. Writes end-to-end tests spanning both layers.
Develops fullstack applications on NestJS or Express with clear modular structure, integrating server-side rendering through Next.js. Configures middleware chains, DTO validation, error handling and API layer optimized for frontend needs.
Designs Node.js backend architecture for fullstack projects: modular NestJS structure, BFF pattern for optimal frontend support, shared type and utility packages. Defines SSR/SSG strategy, middleware pipeline and request handling standards for the team.
Web Performance 2
▼
Understands bundling principles in fullstack applications and can analyze bundle size through webpack-bundle-analyzer. Applies basic optimizations: dynamic imports for code splitting, tree-shaking unused code, dependency optimization.
Independently implements complex UI components with bundle optimization. Optimizes rendering performance. Writes tests. Applies for state management.
Optimizes fullstack application bundles: code-splitting by routes and components, separate chunks for vendor code, SSR bundle optimization. Configures Vite/webpack for minimal size, implements prefetch strategies and analyzes server dependency impact.
Designs bundling strategy for the fullstack platform: chunk architecture, shared dependencies in monorepo, lazy-loading strategy. Defines bundle size budgets, configures automated CI checks and optimizes shared client-server packages.
Understands Core Web Vitals metrics (LCP, FID, CLS) and their impact on fullstack application UX. Measures metrics through Lighthouse and Chrome DevTools, fixes basic issues: image optimization, lazy-loading, preventing layout shift.
Independently implements complex UI components with Core Web Vitals optimization. Optimizes rendering performance. Writes tests. Applies for state management.
Optimizes Core Web Vitals of fullstack applications across the entire stack: server-side rendering for LCP, hydration optimization for INP, streaming SSR for TTFB. Configures RUM monitoring, analyzes field data and eliminates bottlenecks from API to rendering.
Designs Web Performance strategy for fullstack products: performance budgets, CWV monitoring in CI/CD, SSR pipeline optimization. Defines architectural decisions for achieving target metrics and trains the team on performance-oriented development.
Web Standards & APIs 1
▼
Implements basic accessibility in fullstack applications: semantic HTML, alt texts, color contrast, focus states. Uses ARIA attributes for custom components and tests keyboard navigation in main user scenarios.
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.
Ensures WCAG 2.1 AA compliance for fullstack applications: accessible forms with server and client validation, live regions for dynamic content, skip navigation. Configures automated a11y testing in CI and conducts audits with assistive technologies.
Designs accessibility strategy for fullstack products: standards for server-rendered and SPA pages, a11y requirements in definition of done, automated checks. Trains the team on inclusive design and coordinates a11y audits.