Saddle Command Center
A Harness for Your Microservices
Connect, compose, and govern your microservices.
Unbridled microservices are a liability.
Microservices unlock agility — but without central oversight, they become a leaderless distributed system. Services couple to each other, debugging spans multiple teams, and one failed step can silently break an entire business process.
Engineering teams end up spending more time building retry logic, dead-letter queues, and tracing infrastructure than delivering business value.
Rein in your microservices with LittleHorse.
LittleHorse sits at the center of your architecture as a command center: it knows every service, orchestrates every interaction, and traces every step.
Instead of microservices calling each other directly, they register as Task Workers with LittleHorse and let workflows compose them. The result: true loose coupling, built-in reliability, and total visibility.
Everything you need to govern your microservices
LittleHorse replaces ad-hoc glue code with a unified platform for cataloging, composing, and observing your microservices.
Catalog & Reuse
Every microservice registered as a Task Worker becomes a governed, discoverable building block with a defined API contract — ready to be dropped into any workflow.
True Loose Coupling
Microservices communicate through LittleHorse — not directly to each other. Change, reorder, or replace services without cascading updates across your architecture.
E2E Tracing & Visibility
Every step of every process is journaled and searchable. Trace a request across ten microservices from a single dashboard — no Zipkin or Jaeger required.
Multi-Step Orchestration
Compose multi-service processes with retries, error handling, SAGA rollbacks, and async waits — all defined in code, not duct-taped together with queues.
Catalog Every API Contract
When a microservice registers as a Task Worker, LittleHorse automatically captures its input and output schema. The dashboard gives every team a single source of truth for what each service does and how to call it.
No more digging through Confluence pages or Slack threads to understand another team's API. LittleHorse becomes your living service catalog.
@LHTaskWorker("charge-customer")
public PaymentResult chargeCustomer(String customerId, double amount) {
// Your existing business logic — now a governed,
// reusable, and observable microservice task.
return paymentGateway.charge(customerId, amount);
}
}
One Annotation to Govern a Service
The @LHTaskWorker annotation transforms any Java, Python, Go, or C# method into a governed, observable, and reusable TaskDef in LittleHorse. Your business logic stays exactly where it is — LittleHorse wraps it with retries, schema registration, and telemetry automatically.
No framework lock-in. No rewriting. Just annotate, deploy, and your microservice is ready to be composed into any workflow.
Compose microservices with a WfSpec
A WfSpec defines how your microservices work together — which tasks run, in what order, and what happens when things go wrong. Retries, conditional logic, SAGA rollbacks, and async waits are all defined in code you can read, review, and version control.
Each microservice stays focused on its own domain. The workflow is the only place that knows the end-to-end process, keeping your services truly decoupled.
// Each execute() calls a different microservice
wf.execute("create-order", customerId, cart);
wf.execute("reserve-inventory", cart);
wf.execute("charge-customer", customerId, total);
wf.execute("ship-order", orderId);
// Built-in SAGA: roll back on failure
wf.handleException(handler -> {
handler.execute("issue-refund", txnId);
handler.execute("release-inventory", cart);
});
}
End-to-End Workflow Observability
The LittleHorse dashboard shows you the real-time state of every workflow execution — which tasks completed, which are pending, what data flowed between services, and where failures occurred.
When a customer reports a stuck order, you don't need to coordinate across five teams and slog through DataDog logs. Just open the workflow run and see exactly what happened.
Unbridled Microservices
- ✕Custom retry logic in every service
- ✕Dead-letter queues and Transactional Outbox tables
- ✕Zipkin, Jaeger, or Kiali for distributed tracing
- ✕Hand-rolled SAGA pattern implementations
- ✕Cross-team debugging sessions to find stuck requests
Reined-In Task Workers with LittleHorse
- ✓Built-in retries and durable execution
- ✓Workflow-level SAGA and exception handling in code
- ✓Every step traced and searchable on the dashboard
- ✓Living service catalog with governed API contracts
- ✓Services decoupled — rewire workflows, not microservices
Go deeper
Read our blog series on Microservices and Workflow.
Get Started. It's Easy and Free.
Take control of your microservices. Let LittleHorse be your command center.