🌐Full Stack Developer

A monolith is one deployable unit sharing code and database: simpler to build, test and deploy early, but it can become tightly coupled and must scale as a whole. Microservices split capabilities into independently deployable services with their own data stores: they scale and evolve separately but add operational cost around networking, observability and distributed transactions. Start monolithic and extract services at clear bounded contexts when team or scale pain appears.

An API gateway is a single entry point that routes to backend services while handling cross-cutting concerns: auth, rate limiting, request validation, transformation, caching, retries and observability. It simplifies clients and enforces policy centrally. Warn that it can become a bottleneck or dumping ground for business logic if overused.

Queues persist messages between producers and consumers so bursts buffer, deploys proceed independently, and failures retry with backoff into dead-letter isolation. Choose at-least-once delivery with idempotent handlers, order where the domain needs it, and monitor depth plus oldest-message age. Contrast brokered queues with log-based streaming for replay needs.

Synchronous REST or gRPC suits request-response flows needing immediate answers but couples availability and latency across hops. Async events suit state changes that many consumers need eventually, gaining resilience at consistency complexity cost. Default to async across bounded contexts with explicit contracts and versioned schemas.

Sagas chain local transactions where each step publishes events triggering the next, with compensating actions undoing prior steps on failure. Choreography reacts to events without a controller while orchestration drives steps centrally for visibility. Choose orchestration for complex rollbacks and design every action compensatable from day one.

CAP states a partitioned distributed store trades strong consistency against availability, so designs pick CP banking ledgers or AP feeds with eventual convergence. In practice tune per operation with quorum, sloppy quorums, and CRDTs rather than treating the pick as binary. Name your consistency needs before choosing the store.

Round-robin spreads evenly, least-connections favors emptier backends, consistent hashing pins sessions or cache keys, and latency-aware routing avoids slow nodes. Health checks must remove failing targets fast while slow-start ramps warmed ones. Match strategy to statefulness and measure tail latency per policy.

Sharding partitions rows by a shard key across nodes so each handles a slice of reads and writes with near-linear headroom. Pick high-cardinality even keys like user id, plan for cross-shard queries and rebalancing, and route with a shard map or proxy. Rehearse resharding since key hotspots are the classic failure.

Monorepos: one repository with shared tooling, atomic cross-service changes, and unified CI at scale-system cost. Polyrepos: separate repositories per service with independent versioning and ownership at integration overhead. Choose monorepo for tight collaboration and polyrepo for strong team autonomy.

Twelve-factor prescribes declarative config in the environment, stateless processes with backing services, explicit dependencies, and disposable fast-starting instances. It yields portable builds, environment parity, and smooth scaling across platforms. Cite config separation, log streaming, and admin processes as interview-friendly examples.

Enqueue work like emails, exports, and media processing with retries, priorities, and dead-letter queues while workers scale independently of web dynos. Keep jobs idempotent and small, report progress via websockets or polling, and alert on queue age. Separate queues by latency sensitivity.

Automate encrypted backups with cross-region copies, document RPO and RTO per dataset, and rehearse restores quarterly including game-day failovers. Test partial restores for user-error cases, not just full-region loss, and keep runbooks with timed steps. An untested backup is a hope, not a plan.

Choose silo, pool with tenant ids, or bridge models by compliance and scale needs, enforcing tenant scoping in every query via middleware and row policies. Isolate secrets, queues, and rate limits per tenant and test cross-tenant access aggressively. Loud tenant context in logs speeds incident response.

BFFs place a thin orchestration layer per client type that aggregates service calls, shapes payloads, and hides churn from mobile or web apps. It reduces over-fetching and client complexity at extra-service cost, so adopt when clients diverge sharply. Share code between BFFs where logic overlaps.

Sketch redirect and create APIs with rate limits and abuse controls, a key-value store with cache in front, base62 ids from counters or hashes, and analytics pipelines for clicks. Cover custom aliases, expiry, auth scopes, and regional failover, then size with back-of-envelope math. Drive discussion with tradeoffs, not just components.

Keep server state in a query cache such as React Query or SWR with invalidation, and client UI state in local component state or a light store like Zustand or Redux Toolkit only when truly global. Derive rather than duplicate state, normalize entities, and persist drafts to localStorage or the backend. The rule is server cache for fetched data and a minimal global store for cross-cutting UI state.

Use WebSockets for bidirectional low-latency updates like chat and presence, server-sent events for one-way streams, or polling as a fallback. Scale with shared pub-sub such as Redis, authenticate socket handshakes like any API, and design for reconnects with message replay and idempotent handlers.

SSR renders HTML per request on the server, improving first paint, SEO and social previews for content-heavy or personalized pages. It costs server compute and complexity around data fetching, caching and hydration mismatches. Use SSR for SEO-sensitive or slow-device pages, static generation for stable content, and client rendering for app-like interactions; Next.js lets you mix per route.

WebSockets: bidirectional low-latency channels ideal for chat, collaboration, and games. SSE: one-way server-to-client streams over HTTP that reconnect automatically, ideal for feeds and progress. Polling: simple periodic requests that waste resources but work everywhere as a fallback. Match direction and latency needs to the cheapest sufficient option.

Fetch on the server per request with parallel queries, per-route caching, and streaming so slow sections do not block fast ones. Serialize only needed props to avoid hydration bloat and secret leaks, then let client query caches take over interactively. Measure time-to-first-byte against interactivity to pick SSR, static, or hybrid per route.

Mismatches occur when server HTML differs from first client render due to random values, dates, locale differences, or browser-only APIs read during render. Fix by rendering deterministic output, deferring nondeterministic parts to effects or dynamic imports, and keeping formatting data identical across tiers. Treat warnings as bugs since they discard server work and confuse users.

Validate instantly in the browser for UX with shared schemas, then revalidate authoritatively on the server since clients are untrusted. Return field-level error codes the UI maps to messages, preserve input on failure, and test bypass attempts. Sharing one schema package keeps both tiers consistent.

The client applies expected mutations immediately with rollback on server rejection, reconciling against authoritative responses when they arrive. Design operations idempotent with temp ids, show pending states, and queue offline edits for replay. Reserve it for high-confidence actions where conflicts are rare and reversible.

Persist state locally with durable stores, queue mutations with ordering metadata, and sync with conflict resolution such as last-writer-wins or CRDTs when connectivity returns. Surface sync status honestly and test airplane-mode journeys end to end. Plan storage quotas and schema migrations for long-lived clients.

Structure with fieldsets, labels, hints, and inline validation announced to assistive tech, keeping layouts single-column with logical tab order. Save drafts automatically, confirm destructive submits, and summarize errors with focus moved to the summary. Test with keyboard only plus zoomed viewports.

Budgets cap bundle sizes, image weights, and web-vital scores per route with CI failures on regression, making perf part of definition of done. Track field data by template and device, attributing regressions to specific deploys. Celebrate budget wins so teams treat speed as a feature.

App Router colocates server components, streaming layouts, and route handlers so data fetching, caching, and mutations live beside UI code. Server actions simplify forms while route segment configs tune static versus dynamic rendering. Mind cache semantics and client boundaries to avoid shipping server-only code to browsers.

Authentication verifies identity (who you are) via passwords, SSO or OIDC or passkeys. Authorization decides permissions (what you may do) via RBAC or ABAC checks on every request. A common flow is OIDC login issuing short-lived JWTs with the backend enforcing scopes per endpoint. Never trust client-side checks alone.

Apply defense in depth: HTTPS everywhere, secure auth with short-lived tokens and HttpOnly cookies, per-endpoint authorization, input validation and parameterized queries, output encoding to stop XSS, CSRF tokens, security headers and CSP, secret management, dependency scanning, rate limiting and audit logging. Review with threat modeling and OWASP checklists before launch.

JWTs: self-contained signed tokens validated without server lookups, easy for stateless services and mobile but hard to revoke before expiry. Session cookies: opaque ids backed by server stores that revoke instantly and stay small, at lookup cost per request. Prefer short-lived tokens with rotation or sessions for sensitive apps, never trusting client claims alone.

The app redirects to an identity provider, the user authenticates there, and the app exchanges the authorization code with PKCE for ID and access tokens. ID tokens prove identity while access tokens authorize API calls with scopes, refreshed via short-lived rotation. Validate issuer, audience, and signatures server-side and never expose client secrets in browsers.

RBAC assigns permissions to roles like editor or admin that users inherit, simple to administer for coarse boundaries. ABAC evaluates attributes such as team, ownership, plan, and time per request for fine-grained control at policy complexity cost. Start with RBAC, add ABAC rules where ownership or tenancy demands per-resource decisions.

Hash with memory-hard algorithms like bcrypt, scrypt, or Argon2 with per-user salts and tuned work factors, never reversible encryption or plain hashes. Enforce breach-aware strength checks, rate-limit attempts, and offer passkeys or MFA for high-value accounts. Keep pepper and parameters in secret management with upgrade paths as hardware improves.

Authenticate once at the edge, attach identity and roles to the request context, then check resource ownership and scopes inside route middleware before handlers run. Centralize policy helpers, deny by default, and log decisions for audits. Test with matrix cases crossing roles and resources.

Stop XSS with framework escaping, strict CSP, HttpOnly cookies, and sanitized rich-text rendering, and stop CSRF with SameSite cookies plus synchronizer tokens on state-changing routes. Validate and encode at boundaries, scan dependencies, and test with malicious payload suites. Treat any reflected input as hostile until proven safe.

Browsers enforce same-origin policy and use preflight checks before cross-origin writes, so servers must allowlist exact origins, methods, and headers instead of reflecting arbitrary ones. Keep credentialed access narrow, cache preflights modestly, and prefer same-site APIs or gateways where possible. Debug with network panels showing preflight versus actual requests.

TLS encrypts traffic, authenticates servers, and preserves integrity, while HSTS, secure cookies, and redirects close downgrade gaps. Automate issuance and renewal, terminate at the edge with modern configs, and monitor expiry and mixed-content warnings. Assume hostile networks and encrypt internal hops carrying sensitive data too.

Inject secrets at runtime from a manager with rotation, versioning, and audit trails, scoped per service with least-privilege access. Separate config from secrets, scan repos and images for leaks in CI, and prefer workload identity over static keys. Rotate on schedule plus on every departure or incident.

Scan manifests and lockfiles in CI with advisories blocking merges on critical CVEs, then update via automated pull requests with test suites proving safety. Pin versions with lockfiles, prune unused packages, and track base-image freshness. Measure mean time to patch as the headline metric.

Model core entities like users, posts, comments, follows and likes with normalized tables, foreign keys and indexes on feed and lookup paths. Plan the hot queries first (home feed, profile, notifications), then add denormalized counters, cursor pagination and caching for timelines. Discuss sharding by user, media in object storage with CDN, and moderation tables from day one.

Validate at boundaries (client for UX, server as source of truth), use typed errors with codes, return consistent problem-details responses, and log with correlation IDs across frontend and backend. Show friendly fallback UI with retry affordances, report to an error tracker like Sentry, and alert on server 5xx spikes rather than every client validation failure.

REST: resource-oriented endpoints with fixed shapes, HTTP caching, and simple tooling, ideal for CRUD services and public APIs. GraphQL: a typed query layer where clients request exactly the fields they need in one round trip, powerful for varied frontends at schema-governance cost. Choose REST for stable resources and GraphQL when clients diverge and over-fetching hurts.

Model nouns as resources with plural paths, use verbs correctly with GET for reads, POST for creates, PUT or PATCH for updates, and DELETE for removes, keeping responses consistent. Return 201 with location on create, 204 for empty success, 400 for validation, 401 for missing auth, 403 for denied permission, and 404 for absent resources. Version explicitly and document with examples plus error codes.

Offset: simple page numbers that degrade on large tables and skip or duplicate rows when data shifts mid-read. Cursor: opaque markers anchored to sort keys that page stably through changing datasets with efficient indexed seeks. Prefer cursors for feeds and large collections, reserving offset for small admin lists.

SQL: relational tables with joins, ACID transactions, and ad-hoc queries, ideal for connected domains needing consistency. NoSQL: document, key-value, wide-column, or graph stores that scale horizontally with flexible schemas, ideal for high-write or hierarchical workloads. Model access patterns first since NoSQL demands query-driven denormalization.

Indexes provide ordered lookup structures so selective filters, joins, and sorts avoid full scans, verified with explain plans showing index usage. They cost write amplification, storage, and planner confusion when over-applied, so index hot paths, cover frequent selects, and drop unused ones measured by statistics. Beware low-selectivity leading columns that scans beat.

Transactions group reads and writes into atomic units with consistency, isolation, and durability so concurrent operations cannot leave half-applied state. Choose isolation deliberately since serializable safety costs throughput while read-committed suits many app flows with idempotent retries. Keep transactions short, retry on serialization failures, and never hold them across network calls.

N plus 1 happens when code fetches a list then issues one query per item, turning one round trip into hundreds under load. Fix with eager joins or batched loaders like DataLoader that coalesce per-item requests, plus query logging in tests that fails on count regressions. Confirm with traces showing collapsed query counts.

ORMs: map rows to objects with migrations, relations, and productivity for standard CRUD at abstraction and tuning cost. Raw SQL: full control over plans, locks, and bulk operations for hot paths and reporting. Use ORMs by default with reviewed migrations, dropping to tuned SQL with tests for performance-critical queries.

Cache-aside reads through the app which fills the cache on miss, simple with stale-window care, while write-through updates cache synchronously and write-behind batches for speed at durability risk. Set TTLs from data volatility, namespace keys by version for clean invalidation, and monitor hit ratios per prefix. Protect origins with request collapsing during stampedes.

Invalidate by versioned keys, event-driven purges on writes, and short TTLs for volatile data layered over longer TTLs for stable assets. Single-flight loading plus stale-while-revalidate keeps thundering herds from hitting origins during expiry. Test invalidation paths explicitly since untestable caching causes the nastiest production surprises.

Terminate connections behind a load balancer with sticky or stateless routing, then fan out through a shared pub-sub like Redis so any node can reach any client. Persist session and presence in shared stores, authenticate the upgrade handshake, and design reconnect with replay cursors. Load-test connection counts plus message fan-out separately.

Clients attach a unique key per operation so retried requests collapse to one effect, with servers storing key-to-result mappings inside the same transaction. Expire keys sensibly, return the original response on replay, and apply to payments, webhooks, and queue consumers. Without this, at-least-once delivery double-charges users.

Token buckets grant each client tokens refilling over time, permitting bursts up to capacity while bounding sustained rates, enforced at the gateway with shared counters. Return 429 with retry-after headers and per-key or per-plan tiers, distinguishing auth abuse from legitimate spikes. Monitor rejection ratios to tune before launch events.

Stack fast unit tests for logic, service tests for API contracts with real collaborators, and a thin layer of browser journeys for critical paths. Keep the pyramid bottom-heavy so suites run in minutes and failures localize quickly. Gate merges on the pyramid and run heavy E2E nightly plus pre-release.

Providers and consumers share versioned expectations verified in CI, so breaking field removals fail builds before deploy rather than paging at night. Pact-style workflows let consumers declare needs that providers verify, complementing schema registries. Treat contract violations as breaking changes with explicit major versions.

The gateway mints a request id propagated through HTTP headers, queue messages, and logs so one grep reconstructs the whole journey. Structured logging carries the id everywhere and traces link spans under it. Enforce propagation in shared clients and test that background jobs preserve the chain.

The backend authorizes and mints short-lived presigned URLs so browsers upload directly to object storage without proxying bytes. Validate content type and size server-side, scan on arrival, then process via background jobs with progress callbacks. Multipart uploads with resume handle large media gracefully.

Index documents with analyzers matching language and domain, expose faceted queries with pagination, and sync via change-data-capture or background jobs. Tune relevance with field boosts and synonyms, then monitor slow queries and index sizes. Start with Postgres search and graduate to dedicated engines when scale demands.

Write reversible migrations with expand-then-contract phases, test on production-sized staging data, and deploy schema changes separately from code that uses them. Back up first, run in transactions where supported, and monitor locks during execution. Never edit applied migrations, always add new ones.

Versioned seeds provide representative users, catalogs, and edge cases so every developer and preview environment starts from the same story. Generate at scale with factories, anonymize production samples for privacy, and reset deterministically in tests. Keep seeds fast enough to run on every setup.

Evolve additively with optional fields, version in paths or headers only at true breaking points, and publish changelogs with sunset timelines. Support overlapping versions during migration, monitor old-version traffic, and test clients against both. Deprecate loudly with contact and deadline before removal.

DataLoader batches per-item loads within a tick into single queries and caches by key per request, collapsing resolver fan-out transparently. Scope caches per request to avoid cross-user leaks and combine with join planning for deep trees. Observe query counts drop from hundreds to a handful in traces.

tRPC: end-to-end typesafe procedure calls with inferred contracts, superb for TypeScript monorepos shipping fast. REST: resource HTTP APIs with universal tooling, caching, and language independence for public or polyglot consumers. Choose tRPC for internal velocity and REST for public boundaries.

CI continuously builds, tests and scans every commit so integration issues surface in minutes. CD extends that to automated deploys through staging to production with approvals and progressive rollouts. Small, frequent, reversible releases beat rare big-bang deploys on speed, quality and incident recovery.

Store originals in object storage, serve through a CDN with content-hashed filenames for immutable long caching, and automate invalidation on deploys. Compress with modern codecs, set correct content types, and sign URLs for private content. Measure cache-hit ratios and origin egress to prove the savings.

Trigger affected-package detection so frontend, backend, and shared changes run only relevant lint, typecheck, unit, and contract suites in parallel. Build versioned artifacts with migration checks, run ephemeral preview environments for integration, then promote immutable images. Cache aggressively and fail fast on the cheapest signal first.

One compose file boots frontend, API, database, cache, and queue with seeded data and shared networks so onboarding takes minutes. Overrides add debug ports and hot reload while profiles slim the default set. Mirror production topology and versions so local surprises stay rare.

Keep code identical and inject config per environment from validated sources with typed schemas, separating secrets from plain settings. Bake nothing sensitive into images, review config diffs in deploys, and fail boot fast on missing required values. Document every variable with examples and safe defaults.

Combine real-user web vitals, frontend error tracking, API golden signals, and database slow-query logs under shared dashboards and SLO alerts. Trace sampling links slow clicks to backend spans and query plans. Alert on user-facing burn with runbooks bridging both halves of the stack.

Flags gate backend endpoints and frontend surfaces independently with targeting by cohort, so releases ship dark and enable progressively with kill switches ready. Coordinate flag states across tiers in one definition and test matrix combinations in CI. Expire flags promptly to avoid combinatorial debt.

Stand up the green stack with migrated schemas kept backward-compatible, warm caches, then flip routing and watch business metrics before decommissioning blue. Database compatibility windows matter more than container swaps since data cannot flip instantly. Rehearse rollback including reverse migrations.

Define schedules in code with timezone care, single-flight locks to prevent overlaps, and retries with alerting on repeated failure. Prefer managed schedulers over server crontabs for visibility, backfill support, and DST safety. Log run history with durations for capacity review.

Traces link spans from browser timings through gateway, services, and queries under one id, exposing which hop owns latency. Sample intelligently, propagate context through async boundaries, and set span-based SLO alerts. One trace often replaces hours of cross-team log archaeology.

Vercel: zero-config edge deploys with previews, image optimization, and serverless scaling, fastest for frontend teams at platform cost and limits. Direct AWS: full control over VPCs, data, and exotic workloads with operational responsibility. Start managed for speed and egress to AWS primitives where control or cost demands.