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: Completing tasks under the guidance of senior colleagues. Learning the codebase, standards, and team processes. Writing code to spec, fixing simple bugs, writing tests.

Key skills:

Core Web Vitals Need
CSS-in-JS Need
Progressive Web Apps (PWA) Need
SSR/SSG/ISR Patterns Need
State Management Need
Svelte / SvelteKit Need
Tailwind CSS Need
Vite & Modern Bundlers Need
Web APIs Need
Web Components Need
Visual Regression Testing Need
Component Testing Need
Bundle Optimization Need
Design System Development Need
Modern CSS Need

Middle

2-5 years

Next

Responsibility: Independently developing features from decomposition to deployment. Participating in code review. Optimizing performance. Mentoring junior developers. Taking part in architecture discussions.

Key skills:

Core Web Vitals Need
CSS-in-JS Need
Data Fetching Need
Progressive Web Apps (PWA) Need
SSR/SSG/ISR Patterns Need
State Management Need
Svelte / SvelteKit Need
Tailwind CSS Need
Vite & Modern Bundlers Need
Web APIs Need
Web Components Need
Visual Regression Testing Need
Web Accessibility Need
Component Testing Need
Bundle Optimization Need
Design System Development Need
Modern CSS Need
Type Safety & Type Systems Need

Senior

5-8 years

Responsibility: Designing the architecture of components and services. Solving complex technical problems. Managing technical debt. Code review as a quality gatekeeper. Mentoring middle developers. Choosing technologies for new tasks.

Key skills:

Core Web Vitals Need
CSS-in-JS Need
Data Fetching Need
Progressive Web Apps (PWA) Need
SSR/SSG/ISR Patterns Need
State Management Need
Svelte / SvelteKit Need
Tailwind CSS Need
Vite & Modern Bundlers Need
Web APIs Need
Web Components Need
Algorithms & Complexity Need
Async Programming Need
Visual Regression Testing Need
Web Accessibility Need
Code Quality & Refactoring Need
Component Testing Need
Bundle Optimization Need
Design System Development Need
Modern CSS Need
Data Structures Need
Type Safety & Type Systems Need

Lead / Staff

7-12 years

Responsibility: Technical leadership of a team or area. Designing system architecture. Coordinating with other teams. Establishing standards and best practices. Participating in hiring. Planning the technical roadmap.

Key skills:

Core Web Vitals Need
CSS-in-JS Need
Data Fetching Need
Performance Budgets Need
Progressive Web Apps (PWA) Need
SSR/SSG/ISR Patterns Need
State Management Need
Svelte / SvelteKit Need
Tailwind CSS Need
Vite & Modern Bundlers Need
Web APIs Need
Web Components Need
Algorithms & Complexity Need
Async Programming Need
Visual Regression Testing Need
Web Accessibility Need
Code Quality & Refactoring Need
Component Testing Need
Bundle Optimization Need
Design Patterns Need
Design System Development Need
Modern CSS Need
Data Structures Need
Accessibility Testing Need
Type Safety & Type Systems Need

Principal

10+ years

Responsibility: Technical strategy at the company or domain level. Cross-organizational influence. Solving systemic business problems through technology. Mentoring lead engineers. Publicly representing the company.

Key skills:

Core Web Vitals Need
CSS-in-JS Need
Data Fetching Need
Performance Budgets Need
Progressive Web Apps (PWA) Need
SSR/SSG/ISR Patterns Need
State Management Need
Svelte / SvelteKit Need
Tailwind CSS Need
Vite & Modern Bundlers Need
Web APIs Need
Web Components Need
Algorithms & Complexity Need
Async Programming Need
Visual Regression Testing Need
Web Accessibility Need
Code Quality & Refactoring Need
Component Testing Need
Bundle Optimization Need
Design Patterns Need
Design System Development Need
Modern CSS Need
Data Structures Need
Accessibility Testing Need
Type Safety & Type Systems Need

Gap analysis: skills to develop

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

Core Web Vitals

Optimizes Core Web Vitals in SvelteKit: preloads critical resources, lazy loading through Svelte actions, font optimization. Configures web-vitals library for RUM monitoring, improves INP through event handler debouncing and $effect optimization.

CSS-in-JS

Applies CSS-in-JS approaches within Svelte component styling, using scoped styles with dynamic class bindings and CSS custom properties. Optimizes rendering performance by leveraging Svelte's compile-time style optimization. Integrates design tokens and writes tests for component visual states.

Data Fetching

Implements advanced data fetching patterns in SvelteKit: parallel load functions, invalidateAll for updates, streaming with promises. Creates type-safe API wrappers, configures response caching through Cache-Control headers in server routes.

Progressive Web Apps (PWA)

Configures PWA in SvelteKit with a custom service worker: caching strategies (stale-while-revalidate, cache-first), offline fallback pages. Implements background data synchronization, push notifications, and SW updates without losing $state.

SSR/SSG/ISR Patterns

Configures rendering strategies in SvelteKit: SSR for dynamic pages, prerender for static, CSR for SPA sections. Uses adapter-static and adapter-node, implements ISR-like patterns through caching headers and invalidation.

State Management

Designs SvelteKit application state: global stores for auth and settings, context API for tree-scoped data, $state for forms. Implements optimistic updates through form actions, synchronizes server and client state through load invalidation.

Svelte / SvelteKit

Independently implements complex UI components with Svelte/SvelteKit. Optimizes rendering performance. Writes tests. Applies state management tools.

Tailwind CSS

Configures Tailwind CSS for a SvelteKit project: custom theme, plugins, content paths for Svelte files. Combines Tailwind with Svelte scoped styles and Skeleton UI, creates reusable component variants through class: directive and clsx.

Vite & Modern Bundlers

Configures Vite for a SvelteKit project: custom path aliases, API proxy, dependency optimization (optimizeDeps). Connects Vite plugins for SVG components, imagetools, configures build optimizations and environment variables for different environments.

Web APIs

Applies advanced Web APIs in Svelte: ResizeObserver and MutationObserver through actions, Web Workers for heavy computations, Clipboard API. Integrates Geolocation, Media API, and Notification API in SvelteKit, manages lifecycle through $effect cleanup.

Web Components

Creates Svelte components exported as Web Components through customElement: true, configures shadow DOM and property forwarding. Integrates third-party Web Component UI libraries in SvelteKit, ensures correct SSR hydration.

Visual Regression Testing

Configures visual testing system for Svelte: Playwright with pixel comparison, Chromatic for Storybook components. Creates tests for different viewports and themes, integrates visual checks in CI through GitHub Actions, manages baseline snapshots.

Web Accessibility

Implements advanced accessibility in Svelte components: live regions for dynamic content, focus management during SvelteKit navigation. Configures aria-* attributes for custom widgets, creates skip-links and correct heading hierarchies in layouts.

Component Testing

Creates comprehensive Svelte component tests: mocking stores and $state, testing $derived computations, async operations. Tests components with context, slots, and snippets, configures Vitest coverage reports, creates test utilities for SvelteKit.

Bundle Optimization

Optimizes SvelteKit application bundle: configures code splitting by routes, manualChunks for vendor libraries, preload strategies. Minimizes CSS through Tailwind purge, analyzes dependency duplication, configures gzip/brotli compression on the server.

Design System Development

Develops design system components on Svelte 5 with typed $props(), slots, and snippets for flexible composition. Configures Storybook for Svelte component documentation, creates variants through CSS variables and Tailwind classes.

Modern CSS

Applies advanced CSS features in Svelte: container queries, has(), nesting, cascade layers (@layer). Creates responsive layouts with dynamic viewport units, uses Svelte transitions and animations with CSS keyframes for smooth UI transitions.

Type Safety & Type Systems

Creates strict TypeScript interfaces for component props, types stores and $derived runes with generics. Configures svelte-check in strict mode, types form actions, server hooks, and SvelteKit API endpoints with full type safety.