Database

Monorepo strategies with Nx and Turborepo for scalable multi-project repositories

Release management and tagging strategies for predictable, automated software releases

Trunk-based development for continuous integration with short-lived branches

Container registry setup, authentication, and image management for ECR, GCR, GHCR, and Docker Hub

Container image scanning, runtime hardening, and security best practices for production workloads

Docker Compose configuration for multi-service development, testing, and local orchestration

Docker networking modes, custom networks, DNS resolution, and multi-host connectivity patterns

Multi-stage builds, layer caching, and image size optimization for production Docker images

Helm chart creation, templating, dependency management, and release lifecycle for Kubernetes

Kubernetes autoscaling with HPA, VPA, Cluster Autoscaler, and event-driven scaling with KEDA

Kubernetes core concepts including pods, services, deployments, and namespace management

Component API design, composition patterns, and architecture for scalable design system components

Versioning, contribution processes, and governance models for design system teams

Design tokens for colors, spacing, typography, and other visual primitives in design systems

Icon systems, SVG management, and scalable icon delivery pipelines for design systems

Motion and animation guidelines, easing curves, and transition patterns for design systems

Responsive design patterns, fluid layouts, and adaptive component strategies for design systems

Storybook documentation, visual testing, and interactive component cataloging for design systems

Theme systems, dark mode implementation, and runtime theme switching for design systems

API gateway and Backend-for-Frontend (BFF) patterns for managing client-service communication

Circuit breaker and resilience patterns for building fault-tolerant distributed systems

Database scaling patterns including sharding, replication, and read replicas for high-throughput systems

Distributed caching strategies for reducing latency and database load in large-scale systems

Event-driven architecture and CQRS patterns for reactive, decoupled distributed systems

Message queue patterns including pub/sub, fan-out, and reliable delivery for asynchronous communication

Microservices architecture patterns for building independently deployable, loosely coupled services

Rate limiting and throttling strategies for protecting distributed systems at scale

Expert guidance for building, deploying, and optimizing AWS Lambda functions

Expert guidance for orchestrating serverless workflows with AWS Step Functions

Expert guidance for building and deploying applications on Cloudflare Workers at the edge

Expert guidance for mitigating and optimizing cold start latency in serverless functions

Expert guidance for building event-driven serverless architectures with S3, SQS, and EventBridge triggers

Expert guidance for using serverless databases like PlanetScale, Neon, and Turso in serverless applications

Expert guidance for testing serverless applications locally and in CI/CD pipelines

Expert guidance for building Vercel Edge and Serverless Functions for full-stack web applications

Compound component pattern for building flexible, implicitly-shared React component APIs

React Context patterns for efficient state sharing, provider composition, and avoiding unnecessary re-renders

Custom hooks pattern for extracting and reusing stateful logic across React components

Error boundary pattern for gracefully catching and recovering from runtime errors in React component trees

Optimistic update patterns for instant UI feedback with server reconciliation and rollback in React

Render props pattern for sharing cross-cutting logic through function-as-children and render callbacks

React Server Components pattern for zero-bundle server-rendered components with direct backend access

React Suspense patterns for declarative loading states, data fetching, and code splitting

Asyncio patterns for concurrent I/O-bound programming in Python

Context manager patterns using with statements for reliable resource management in Python

Dataclass and Pydantic model patterns for structured data in Python

Decorator patterns for wrapping, extending, and composing Python functions and classes

Dependency injection patterns for loosely coupled, testable Python applications

Generator and itertools patterns for memory-efficient data processing in Python

Metaclass and descriptor patterns for advanced class customization in Python

Type hint patterns and mypy best practices for statically typed Python code

Async Rust programming with async/await, Tokio runtime, futures, and concurrent task patterns

Cargo workspaces, project structure, dependency management, and multi-crate Rust project organization

Rust error handling with Result, Option, the ? operator, and ecosystem crates anyhow and thiserror

Rust lifetime annotations for ensuring reference validity and understanding the borrow checker

Rust ownership, borrowing, and move semantics for writing memory-safe code without a garbage collector

Rust pattern matching with match, if let, while let, destructuring, and advanced match patterns

Rust smart pointers Box, Rc, Arc, RefCell, and their combinations for heap allocation and shared ownership

Rust traits and generics for polymorphism, abstraction, and zero-cost generic programming

Context usage for cancellation, timeouts, deadlines, and value propagation in Go