The Ultimate Saga Orchestration Solution for Microservices
Coordinate complex, long-running distributed transactions across enterprise microservices without the cost and complexity of legacy ESBs or dedicated orchestration servers. Embed directly into standard Spring Boot services with native Event Sourcing, Continuous Straight-Through Processing (STP), and Pausable Human-in-the-Loop (HITL) wait states — fully supported across both Synchronous and Kafka event-driven architectures.
Architecture Highlights for Modern Enterprise & Banking Microservices
Zero Extra Servers
Embeds in domain services — no ESB or dedicated clusters
Dual LRT Execution
Continuous STP & Pausable HITL without thread starvation
Native Event Sourcing
Pristine state restoration on your existing DB
Self-Healing Retries
Token-ring partition coordinates conflict-free recovery
Choose Your Implementation
StackSaga offers two powerful implementations tailored to your architecture needs
StackSaga Framework
Service-embedded engine for orchestrating long-running transactions within request-response patterns. Supports both sub-second Continuous Straight-Through Processing (STP) and Pausable wait-states (HITL) for webhooks and approvals without thread starvation.
StackSaga Kafka
Event-driven saga orchestration built on Apache Kafka for asynchronous, high-throughput microservice workflows. Fully supports both Continuous Straight-Through Processing (STP) and Pausable wait-states (HITL) across Kafka event streams without thread starvation.
Why Choose StackSaga?
Built for developers who need reliable distributed transaction management without the complexity
Zero Dedicated Servers & No ESB
Ditch heavyweight ESBs and dedicated orchestration clusters like Camunda or Temporal. StackSaga embeds orchestration directly into domain services ('smart endpoints, dumb pipes') with zero extra infrastructure.
Dual LRT: Continuous STP & Pausable HITL
Execute unbroken straight-through processing (Continuous LRT) at wire speed, or pause transactions for hours/days awaiting payment webhooks or human approvals (Pausable LRT) without thread starvation — fully supported across both synchronous REST and Kafka event-driven pipelines.
Native Event Sourcing & Pristine State
Store full audit logs directly in your existing relational or NoSQL database. On retries, StackSaga re-instantiates clean state from event history, discarding dirty in-memory mutations.
Zero Downstream Dependencies
Downstream utility microservices remain standard REST or gRPC services. They require no StackSaga SDK, no special wrappers, and zero knowledge of the saga lifecycle.
Reactive & High Performance
Full support for reactive programming with Spring WebFlux and standard Spring Boot MVC. Use reactive, non-reactive, or hybrid approaches based on high-throughput throughput needs.
Token-Ring Distributed Retries
Intelligent retry agents use token-ring partitioning across instances to coordinate conflict-free recovery for transient failures without centralized coordinator bottlenecks.
Built-in Transaction Tracing
Comprehensive admin dashboard for monitoring and tracing distributed transactions in real-time across all services, step transitions, and compensation paths.
Cloud-Native & Enterprise-Tested
First-class support for Kubernetes, Docker, Eureka, and modern cloud platforms. Proven in enterprise banking and fintech environments handling mission-critical transactions.
Complete Ecosystem
Everything you need for distributed transaction management in one cohesive platform
Domain-Embedded Orchestrator
Lightweight engine embedded directly in your domain microservices, eliminating centralized ESBs and dedicated coordinator clusters.
- Dual LRT: Continuous STP & Pausable HITL
- Automatic compensation & rollback
- Zero downstream dependencies
Transaction Tracing Dashboard
Real-time monitoring and visualization of distributed saga executions, state machines, and compensation paths.
- Live transaction tracking
- Visual execution graphs
- Error diagnostics & state replay
Self-Healing Retry Agents
Token-ring partitioned retry agents that automatically resolve transient network failures without master bottlenecks.
- Pristine state restoration
- Token-ring distributed partition
- Configurable backoff & DLQ
Native Event Sourcing
Built-in event-sourcing engine that records transaction lifecycles directly to your existing relational or NoSQL database.
- No separate event store needed
- Immutable temporal audit trail
- Clean state re-instantiation
StackSaga Initializer
Bootstrap a StackSaga project in seconds. Select your version, build tool, orchestration or coordinator type and database — then copy the exact dependencies and configuration you need, no boilerplate hunting required.
Pick your stack
Choose the StackSaga version, build tool, orchestration or coordinator type, application mode and database.
Copy the snippets
Get the ready-to-use BOM, dependencies and configuration — formatted for Maven or Gradle.
Start building
Drop the snippets into your project and you're ready to orchestrate sagas.
Built for Modern Architectures
Everything you need to orchestrate complex transactions across your microservices
Domain-Centric Orchestration (No ESB)
Decentralized 'smart endpoints, dumb pipes' architecture. Any microservice can orchestrate its domain transactions directly, eliminating the need for legacy Enterprise Service Buses or standalone coordinator servers.
Dual LRT Execution Models
Run sub-second automated Straight-Through Processing (Continuous LRT) or pause execution for hours or days awaiting payment gateways or approval workflows (Pausable LRT) without thread starvation — fully supported in both Synchronous and Kafka architectures.
Pristine State Restoration
Guarantees safe, idempotent retries by re-hydrating execution state directly from the event log, eliminating dirty state carry-over caused by in-memory mutations.
Guaranteed Distributed Consistency
Enforces eventual consistency across polyglot microservices with automatic reverse-compensation on failure and zero-dependency downstream utility services.
Ready to get started?
Explore our comprehensive documentation and examples to begin orchestrating your microservices.