Core Code
Core Code Modern Dev Handbook
REACT Contents
React Fundamentals
React Architecture Overview JSX and Rendering Model Component Design Principles Props and Data Flow State Management with useState Side Effects with useEffect Event Handling Patterns Conditional Rendering Strategies Lists, Keys, and Reconciliation Forms and Controlled Components Component Composition Lifting State and Shared State Basic Routing with React Router Failure Modes in Beginner React Apps
React + TypeScript
Typing Functional Components Typing Props and Children useState and Type Inference useReducer with Type Safety Typing Event Handlers Generic Components Utility Types in React Discriminated Unions for UI State Strict Mode and Null Safety API Response Typing Strategies Form Typing Patterns Avoiding any and Unsafe Casts Type-Safe Context API Failure Modes in React + TypeScript
React Advanced Patterns
Custom Hooks Architecture Context vs Prop Drilling Tradeoffs Compound Components Pattern Controlled vs Uncontrolled Abstractions Render Props and Pattern Alternatives State Machines in React Performance Optimization Playbook Memoization Strategies Code Splitting and Lazy Loading Error Boundaries and Recovery Portal Architecture Large Scale Folder Structure Testing Strategy: Unit and Integration Common React Anti Patterns
React Production
CSR vs SSR vs SSG Hydration and Mismatch Failures Next.js Architecture Overview App Router Deep Dive Authentication Patterns Token Storage Security Role Based UI Control API Integration Patterns Rate Limiting and UI Resilience Frontend Security Checklist XSS in Modern React Observability in Frontend Bundle Optimization Production Incident Playbook
Distributed Systems
Distributed System Fundamentals CAP Theorem in Practice Consistency Models Replication Strategies Leader Election Concepts Consensus Algorithms Overview Event Driven Architectures Message Queues and Delivery Guarantees Idempotency Patterns Saga Pattern Circuit Breakers Backpressure and Flow Control Observability in Distributed Systems Failure Scenarios and Postmortems

Saga Pattern

Sagas manage distributed workflows without global transactions. Learn choreography vs orchestration, compensations, idempotent steps, and failure handling to avoid stuck orders and inconsistent side effects.
On this page

Why Sagas Exist

  • Distributed systems rarely support safe global ACID transactions across services.
  • Workflows span services: order, payment, inventory, shipping.
  • Sagas provide eventual consistency with explicit steps and compensations.

Saga Types

  • Choreography: services react to events and trigger next steps.
  • Orchestration: a coordinator issues commands and tracks progress.
  • Production rule: pick based on observability and complexity, not ideology.

Core Design Requirements

  • Each step must be idempotent.
  • Each step must have a compensation or a defined terminal failure policy.
  • State must be persisted for recovery after crashes.
  • Timeouts are part of correctness and must be explicit.

Compensation vs Rollback

  • Compensation is a new business action that semantically undoes a previous step.
  • Compensation may be imperfect: refunds instead of reversing authorization.
  • Production rule: define acceptable outcomes for partial completion.

Choreography Failure Risks

  • Hidden coupling through events and implicit ordering assumptions.
  • Harder end to end visibility without correlation and tracing.
  • Poison messages can stall a step and block progress.

Orchestration Failure Risks

  • Coordinator becomes a bottleneck or single point of failure if not replicated.
  • State machine bugs can cause stuck workflows.
  • Complexity moves into the orchestrator codebase.

Operational Patterns

  • Use correlation ids across all commands and events.
  • Persist saga state as a state machine with explicit transitions.
  • Use outbox pattern for publish reliability.
  • Use dead letter queues and replay tooling.

Failure Modes

  • Stuck saga: step never completes due to missing event or consumer lag.
  • Duplicate step: message redelivery triggers a side effect twice.
  • Compensation failure: refund fails and workflow remains inconsistent.
  • Out of order events: state machine applies transitions incorrectly.

Production Checklist

  • All steps are idempotent and have retry caps.
  • Compensation is defined and tested for each reversible step.
  • Saga state is persisted and recoverable after restart.
  • Correlation ids and tracing provide end to end visibility.
  • Runbooks exist for replay, manual intervention, and compensation.
Circuit Breakers →