{
  "version": "https://jsonfeed.org/version/1",
  "title": "Temporal on LLBBL Blog",
  "icon": "https://avatars.micro.blog/avatars/2023/40/125738.jpg",
  "home_page_url": "https://llbbl.blog/",
  "feed_url": "https://llbbl.blog/feed.json",
  "items": [
      {
        "id": "http://llbbl.micro.blog/2026/04/27/what-temporal-actually-does-and.html",
        "title": "What Temporal Actually Does (And Why You'd Want It)",
        "content_html": "<p>Building a multi-step process across microservices usually goes something like this. You wire up a message queue, add retry logic, build a state machine backed by a Postgres <code>status</code> column, throw in some cron jobs, and pray. It sounds complicated because it is.</p>\n<p>Temporal is an open-source &ldquo;durable execution&rdquo; system that replaces all of that duct tape with a single, opinionated framework. Lets break it down.</p>\n<h2 id=\"workflows-and-activities\">Workflows and Activities</h2>\n<p>Temporal splits your application into two concepts:</p>\n<ul>\n<li><strong>Workflows</strong> are your business logic, written in standard code (Go, Python, TypeScript) using a Temporal SDK. They must be deterministic. They define the order of operations, branching, loops, and error handling.</li>\n<li><strong>Activities</strong> are the actual tasks your services perform. HTTP requests, database writes, external API calls. Activities are where the non-deterministic, real-world work happens.</li>\n</ul>\n<p>When a workflow runs, it executes on your own worker services. Every time it schedules an activity, starts a timer, or completes a step, the Temporal Server records that event internally. If the worker crashes, another worker picks it up, replays the workflow&rsquo;s event history to the exact point of failure, and resumes. No data loss. No half-finished state.</p>\n<p>All of all the things that you would have to build yourself simplified Into A framework that handles it for you.</p>\n<h2 id=\"what-it-replaces\">What It Replaces</h2>\n<p>Without something like Temporal, teams generally land in one of two camps:</p>\n<ul>\n<li><strong>Choreography (event-driven):</strong> Services emit and listen to events through a message broker like Kafka or RabbitMQ. Highly decoupled, sure. But in practice it turns into a pinball machine. There&rsquo;s no single place to understand the flow of a business transaction. Debugging becomes detective work across dozens of services and topics.</li>\n<li><strong>Ad-hoc orchestration:</strong> You build a custom state machine with a database, message queues, background workers, and cron jobs. Then you write a <em>ton</em> of boilerplate for retries, dead-letter queues, and idempotency. Every team ends up building a slightly different version of this, and none of them are great.</li>\n</ul>\n<p>Temporal gives you the reliability of a custom state machine without making you build and maintain one.</p>\n<h2 id=\"why-its-worth-looking-at\">Why It&rsquo;s Worth Looking At</h2>\n<p>A few things stand out:</p>\n<ul>\n<li><strong>Durable sleep.</strong> A workflow can execute <code>sleep(30_DAYS)</code>. Temporal suspends the execution, frees the worker&rsquo;s resources, and wakes it back up a month later exactly where it left off. Hard to do with a cron job.</li>\n<li><strong>Built-in resiliency.</strong> Exponential backoffs, timeouts, and retry policies are configured on the activity invocation. You&rsquo;re not writing custom <code>while</code> loops and <code>try/catch</code> blocks to handle network jitter.</li>\n<li><strong>Centralized observability.</strong> Instead of piecing together distributed traces or searching through logs to figure out why step 4 of 7 failed, the Temporal UI shows the exact execution state of every workflow. Inputs, outputs, errors, all in one place.</li>\n<li><strong>Code over configuration.</strong> Unlike AWS Step Functions or YAML-heavy tools like Airflow, you write workflows in a real programming language. You can unit test them, store them in version control, and run them through your normal CI/CD pipeline.</li>\n</ul>\n<p>That last point is worth reading and thinking through again. If your orchestration logic lives in code, it gets all the benefits code gets. Reviews, tests, refactoring, IDE support. Visual workflow builders look great in demos, but they don&rsquo;t scale the way code does.</p>\n<h2 id=\"should-you-use-it\">Should You Use It?</h2>\n<p>Temporal isn&rsquo;t free in terms of operational complexity. You&rsquo;re running the Temporal Server (or paying for Temporal Cloud), and your team needs to understand the replay model and determinism constraints. It&rsquo;s not something you bolt on to a simple CRUD app.</p>\n<p>But if you&rsquo;re managing distributed transactions with queues, cron jobs, and hand-rolled state machines, Temporal is worth a serious look. It takes the hardest parts of that problem and makes them someone else&rsquo;s. Durability, retries, observability. All handled.</p>\n<p>I&rsquo;d appreciate a follow. You can subscribe with your email below. The emails go out once a week, or you can find me on Mastodon at <a href=\"https://micro.blog/llbbl?remote_follow=1\">@logan@llbbl.blog</a>.</p>\n",
        "date_published": "2026-04-27T10:00:00-05:00",
        "url": "https://llbbl.blog/2026/04/27/what-temporal-actually-does-and.html",
        "tags": ["DevOps","Temporal","Microservices","Distributed-systems"]
      }
  ]
}