What a Lead } should know

Defines algorithmic efficiency architectural standards for Svelte projects, introduces performance benchmarks for reactive computations. Conducts code reviews focused on O-notation in critical rendering paths and SvelteKit load functions.

Standardizes async programming patterns in Svelte projects: unified approaches to error boundaries, retry logic, and timeouts. Implements async operation monitoring, defines SLA for load functions and SvelteKit server routes.

Defines code quality standards for the entire Svelte team, creates shared ESLint and svelte-check configurations for monorepos. Implements automatic quality gates in GitHub Actions, trains the team on clean code practices in the Svelte ecosystem.

Standardizes data modeling approaches in Svelte projects, defines normalization patterns for complex domain models. Introduces unified data structure interfaces between client stores and SvelteKit server endpoints.

Defines an architectural pattern catalog for the team's Svelte ecosystem, standardizes composition and reuse approaches. Reviews architectural decisions, ensuring pattern consistency in load functions, form actions, and SvelteKit API routes.

Standardizes typing strategy for the team's Svelte projects: shared types between packages, auto-generation from OpenAPI schemas, strict tsconfig settings. Ensures zero-any policy, introduces incremental typing during Svelte 5 and TypeScript strict migration.

Defines bundle optimization standards for Svelte projects: size budgets, automatic checks, dependency review process. Implements bundle size monitoring in CI/CD, coordinates optimizations between teams, trains on efficient code splitting.

Defines component testing standards in the Svelte team: mandatory coverage, test patterns, review criteria. Introduces mutation testing through Stryker, trains the team on efficient testing of Svelte 5 runes and SvelteKit-specific patterns.

Defines Core Web Vitals standards for the team's Svelte projects: threshold values, monitoring, regression response process. Integrates performance review into the development process, coordinates optimization between the frontend team and SvelteKit infrastructure.

Defines product-level styling architecture for Svelte applications: evaluates CSS-in-JS approaches vs Svelte native styling, establishes design token standards, and sets component styling guidelines. Conducts reviews ensuring consistent, performant, and accessible UI across all teams.

Standardizes data fetching patterns in the Svelte team: unified approaches to error handling, loading states, cache invalidation. Defines API layer architecture between SvelteKit and backend, implements latency and error rate monitoring for load functions.

Manages the team's design system development: component roadmap, version policy, contribution process. Coordinates designer and developer work, ensures Figma token synchronization with Svelte components and Tailwind configuration.

Defines Svelte MFE strategy: creates build tooling for Svelte micro-frontends, designs shared design system compatible with Svelte and other frameworks through CSS custom properties. Defines Svelte adoption roadmap in the micro-frontend ecosystem.

Standardizes CSS practices in the Svelte team: scoped vs global style conventions, naming conventions, architectural patterns. Defines browser support strategy, introduces visual regression testing for Svelte components through Playwright.

Defines PWA development standards in the Svelte team: Lighthouse metric checklists, offline testing, update strategies. Implements SW error and cache efficiency monitoring, coordinates PWA functionality integration with SvelteKit adapters for different platforms.

Defines rendering strategy standards in the Svelte team: SSR/SSG/CSR selection criteria, adapter architecture, caching. Coordinates DevOps for optimal SSR infrastructure, implements TTFB and hydration performance monitoring in production.

Defines state management standards in the Svelte team: when to use $state vs stores vs context, patterns for server state. Trains the team on idiomatic Svelte 5 approach, introduces best practices for predictable data flow in SvelteKit applications.

Defines product-level frontend architecture with Svelte/SvelteKit. Establishes standards and best practices. Conducts architectural reviews.

Standardizes Tailwind CSS usage in the team's Svelte projects: unified configurations, presets, style linting rules. Defines component library architecture based on Skeleton UI, trains the team on efficient Tailwind patterns in the Svelte ecosystem.

Defines visual testing strategy for the Svelte team: critical UI path coverage, visual change review process. Implements automatic baseline updates, coordinates visual QA between designers and developers.

Standardizes Vite configuration in the team's Svelte projects: shared presets, plugin stack, build pipelines for monorepos. Defines Vite and SvelteKit upgrade strategy, ensures build stability and optimal build times in CI.

Builds accessibility culture in the Svelte team: mandatory a11y checks in CI through svelte-check, component standards, training. Defines accessibility roadmap, coordinates audits with WCAG experts, ensures legal compliance.

Standardizes Web API approaches in Svelte projects: actions and utilities catalog, fallback strategies, feature detection. Defines polyfill and progressive enhancement policies, ensures consistent API operation between SSR and client in SvelteKit.

Defines Web Components strategy for the organization: when to use Svelte custom elements vs native, interaction standards. Coordinates shared component library creation, ensures documentation and testing for multi-framework consumers.

Defines GraphQL standards in the Svelte team: schema conventions, query patterns, caching strategy, monitoring. Coordinates schema evolution with backend teams, implements GraphQL playground and documentation, trains the team on efficient patterns with Houdini.

Defines API design standards for the Svelte team: naming conventions, error format, pagination patterns, documentation. Implements TypeScript client auto-generation from OpenAPI specs, coordinates contracts between SvelteKit BFF and backend teams.

Standardizes Docker practices in the Svelte team: base images, security scanning, CI/CD pipelines for containers. Defines orchestration strategy for SvelteKit services, coordinates with DevOps for optimal Kubernetes or Cloud Run environment.

Defines CI/CD standards for the team's Svelte projects: mandatory checks, quality gates, deployment strategies. Optimizes pipeline time through caching and parallelism, implements automatic rollback mechanisms and failure notifications.

Defines accessibility testing standards and quality gates for Svelte projects across the organization. Establishes automated a11y testing pipelines, Svelte component accessibility certification processes, and WCAG compliance audit workflows. Conducts architecture reviews ensuring Svelte applications leverage compile-time a11y checks and meet accessibility requirements, mentoring teams on Svelte-specific accessible component patterns.

Defines E2E testing standards in the Svelte team: mandatory release scenarios, flaky test policy, environment management. Implements Playwright reporting with video and traces, coordinates QA automation, ensures test suite stability in CI.

Defines unit testing standards in the Svelte team: minimum coverage, mandatory tests for load functions and form actions. Introduces TDD practices, conducts Vitest and testing pattern training, ensures quality gates in CI through coverage reports.

Defines AI usage strategy in the Svelte team: prompting guidelines, AI code review, training. Implements AI-assisted code review for pull requests, creates a prompt library for SvelteKit, defines boundaries for responsible AI usage.

Implements GitHub Copilot in the Svelte team: configures organizational policies, trains for effective usage. Defines guidelines for reviewing Copilot code in SvelteKit projects, measures productivity and quality impact, creates shared Copilot instructions.

Builds code review culture in the Svelte team: review SLA, escalation process, automated CODEOWNERS for SvelteKit modules. Conducts review skills training, implements automated review through ESLint and svelte-check, balances review speed and quality.

Defines Git standards for the Svelte team: branching strategy, commit conventions, merge policy, release process. Implements automatic changelog from conventional commits, coordinates Git workflow for SvelteKit monorepos with multiple packages.

Defines performance budgets for the team's Svelte projects: standards by page types, review process when exceeded. Builds performance-awareness culture, coordinates optimizations between teams, ensures accountability for budget compliance.