Beyond Durable Execution: Business-as-Code | LittleHorse

Skip to main content<br>In the early 2010's, Maxim Fateev observed at AWS that we would write code a lot differently if we didn't have to worry about server crashes: we could write Thread.sleep(Duration.ofDays(30))! This astute observation led to the creation of Durable Execution (AWS Simple Workflow, Cadence, and now Temporal).

In 2026, however, durability is becoming a commodity. What comes next? Rather than just caching the byte output of function call side effects, we move up the business stack and focus on delivering business value by managing and optimizing business processes. That is what LittleHorse's Business-as-Code approach does.

While LittleHorse and Temporal at first seem similar, the goal of Business-as-Code is much more ambitious than Durable Execution. Rather than stop after providing engineers with the ability to write durable long-running processes, Business-as-Code goes several steps further in order to allow engineers to rise up the business stack. LittleHorse provides the same durability guarantees as Durable Execution as a side effect (pun intended!) of durably-orchestrated business-level abstractions. In this post, we'll walk through:

The philosophical differences between Business-as-Code and Durable Execution.

A technical deep-dive into the architectural differences that result from those different philosophies.

Features available in Business-as-Code platforms which Durable Execution cannot support due to those architectural differences.

The Philosophy​

While Durable Execution gives engineers durability primitives to make code impervious to infrastructure failures, Business-as-Code models and orchestrates business flows across events, agents, and microservices.

Durable Execution Orchestrates Bytes​

Durable Execution started as a project at AWS Simple Workflow (SWF) by Maxim Fateev. After AWS, Max continued working on the Durable Execution concept at Uber with an open-source project called Cadence, which he then forked into what is now Temporal. Max astutely observed that we engineers would write code very differently if we didn't have to worry about intermittent networks or crashes. For example, we would never put sleep(Duration.ofDays(30)); in production code that orchestrates a billing cycle. Just relying on RAM to persist a subscription means that anytime a kubernetes pod restarts, we would lose all of our subscriptions!

Durable Execution's philosophy (pioneered by Max and Temporal) is that we should be able to write code that sleeps for 30 days and doesn't worry about intermittent network errors. Durable Execution (especially Temporal) solves that problem quite elegantly! We'll see how shortly, and it is a very clever trick.

However, this approach stops short of orchestrating end-to-end business flows while remaining a valuable infrastructure plumbing tool.

Business-as-Code Models Business Flows​

I started LittleHorse to go a few steps beyond Durable Execution, allowing engineers to contribute value higher up the business stack by not only making code reliable but also using that code to model and manage business processes.

LittleHorse provides the same durability primitives as Temporal, but goes further. Business-as-Code:

Aligns software to business intention, visualizing the end product to make the code easier to audit and understand.

Provides real-time insights into process execution by emitting events into Apache Kafka.

Catalogs technical services and modules of business functionality, promoting reuse and governance.

Aligning Code to Business Intent​

First, this approach bridges the gap between business workflows and technology. For example, the WfSpec (Workflow Specification) primitive reflects business processes in code, showing business-friendly diagrams to further collaboration between product and engineering while preserving a strong developer experience.

Business-as-Code automaticallly visualizes workflow code. This helps unify engineering and business intent. The visual representation is also useful when reviewing code written by agents: it provides a deterministically-generated, human-understandable, and business-friendly blueprint of the technical process created by the agents, allowing engineers and product owners to catch critical errors before production.

A running WfRun on the LittleHorse Dashboard from the code in the next section!<br>This is especially useful when you get tired of reviewing code written by agents!

Real-Time Business Insights​

Because Business-as-Code engines understand the semantics of a process (rather than simply caching the bytes representing what has already happened), they can emit real-time intelligence into Apache Kafka, providing business-level metrics (eg. events when orders reach the "shipping" stage). This solves a problem that almost all microservice developers face: it's easy to inspect the health of a single service, but very difficult to analyze business...