Replay 2025 took place March 3–5 in London under the banner “Modernise,” bringing together engineers from fintech, logistics, pharma, telecom, and platform engineering to share how they’re building production systems on top of Temporal. This wasn’t a product launch event disguised as a conference. It was three days of teams who’ve already shipped talking about what worked, what broke, and what they’d do differently.
Distributed systems are no longer optional — they’re the default. And with every team running microservices, event-driven pipelines, and now AI agents, the question has shifted from “should we orchestrate?” to “how do we orchestrate without losing our minds?” Replay 2025 answered that question with war stories from companies processing billions in payments, managing millions of IoT devices, and running drug discovery pipelines that used to take days.
Tom Wheeler poses a deceptively simple question: “How would you code if your application could not fail?” He contrasts the way senior engineers instinctively design for failure modes — retries, timeouts, partial completions — with how beginners assume the happy path is the only path. The talk builds a compelling case for Durable Execution as a paradigm shift, not just a feature. Wheeler walks through how Temporal’s execution model fundamentally changes the contract between your code and the infrastructure running it. For engineers tired of defensive coding against every conceivable distributed systems failure, this is the philosophical foundation. The practical takeaway: you can write business logic that reads like it runs on a single machine while the runtime handles crashes, restarts, and network partitions transparently. It’s the most-watched talk from the conference for a reason — it reframes what reliability means for application developers.
The keynote demo made the strongest case yet for Temporal as infrastructure for agentic AI systems. Rather than hand-waving about the future, the demo showed a working AI agent pipeline built on Temporal, demonstrating how durable execution solves the exact problems that make AI agents unreliable in production: long-running tasks that span minutes or hours, external API calls that fail mid-execution, and multi-step reasoning chains that need to recover from partial failures. The demo highlighted how Temporal’s workflow orchestration model maps naturally to agent tool-calling patterns — each tool invocation is an Activity, each reasoning step is resumable, and the entire agent execution history is inspectable. For AI engineers building beyond prototypes, this is the architectural pattern that bridges the gap between “it works in a notebook” and “it works at scale in production.” The timing is deliberate: Temporal is positioning Durable Execution as the runtime layer for reliable AI systems.
Worker versioning has been one of the most requested features in the Temporal ecosystem, and this talk delivers the practical guidance engineers need to implement it. Hoskins and Tajik walk through the new Worker Versioning APIs that make deployments safer by ensuring running workflows continue on compatible worker versions while new workflows use updated code. The talk covers the real pain point: how do you deploy changes to long-running workflows without breaking in-flight executions? The answer involves assignment rules, redirect rules, and a versioning model that gives teams fine-grained control over which workers handle which workflows. For teams running Temporal in production with frequent deployments, this session is required viewing — it addresses the operational gap between “my workflow works” and “my workflow survives a rolling deployment.” The talk also covers migration patterns for teams moving from the older versioning approach to the new APIs.
Surdilovic delivers a thorough walkthrough of the Temporal Spring Boot integration that’s approaching GA status. For the massive population of Java developers building enterprise applications, this talk removes friction from Temporal adoption. It covers configuration, observability, scaling, and testing — the four pillars that determine whether a framework integration actually works in production or just in demos. The integration leverages Spring Boot’s auto-configuration patterns to reduce boilerplate while keeping Temporal’s core model intact. Surdilovic demonstrates how to wire up Workers, configure task queues, and integrate with Spring’s dependency injection without losing the determinism guarantees that make Temporal work. For Java teams evaluating Temporal, this is the decision-making session: it shows exactly what the developer experience looks like and where the integration sits relative to maturity. The testing section alone — covering workflow replay testing and mocking Activity implementations — is worth the watch.
Grieger and Deal tackle one of the most ambitious Temporal deployments discussed at the conference: migrating Marketing Cloud onto Hyperforce, Salesforce’s next-generation infrastructure. With over 1,000 engineers involved, this isn’t a microservices migration — it’s a coordinated infrastructure move across dozens of teams and a massive multi-tenant application. Temporal powers the cross-substrate migration system, orchestrating workers across multiple environments and coordinating teams seamlessly. The talk builds on their Replay 2024 presentation about delivering Temporal at scale, showing the evolution from initial adoption to production-critical infrastructure. For engineering leaders considering Temporal for large-scale migrations or organizational coordination, this is proof that the model holds at enterprise scale. The architectural patterns they describe — workflow-driven migration phases, rollback capabilities, and cross-team orchestration — are applicable far beyond Salesforce’s specific use case.
The full keynote session featuring Temporal’s leadership team — CTO Max Fateev, SVP of Engineering Preeti Somal, Engineering Manager Liang Mei, and Senior Staff Solutions Architect Steve Androulakis. Angie Byron opened the session in full medieval gear, chainmail included. The keynote unveiled major product launches: the Pre-Release Ruby SDK with full feature parity, General Availability of Nexus for cross-team workflow orchestration, enhanced high availability through namespace replication, safer Worker Versioning APIs, zero-downtime migration tooling, Temporal Cloud on Google Cloud, and new security and operations tools. This is the state-of-the-union for the Temporal ecosystem and the context for every talk that followed.
An unvarnished look at what it actually takes to self-host Temporal at scale. Ferentschik and Cela López detail four years of managing dozens of clusters at Datadog, including the growing pains that come with increased scale. They cover compute outages, misconfigurations, critical incidents, and the operational realities that documentation doesn’t prepare you for. For teams evaluating self-hosted vs. Temporal Cloud, this talk provides the operational cost data you need to make an informed decision. The candor about what went wrong makes this one of the most practically useful sessions from the conference.
Kikyotani describes how Airwallex stabilized their global financial platform by wrapping legacy microservices with Temporal rather than attempting a risky full rebuild. Operating in over 150 countries, Airwallex’s third-party adapter microservices had accumulated significant tech debt. The approach reduced incidents and increased developer productivity sixfold. The key insight: you don’t need to rewrite everything to get reliability — wrapping existing services with Temporal’s orchestration layer provides immediate resilience gains while buying time for incremental modernization. A pragmatic blueprint for any team dealing with legacy systems they can’t afford to take offline.
One of the most architecturally significant talks from the conference. Prasek introduces Temporal Nexus, the newly GA feature for connecting workflows across teams and namespaces. Miro’s Albuquerque and Moyano then demonstrate a real production use case: building a self-healing control plane for storage infrastructure and leveraging Nexus to orchestrate cross-region data migrations without direct network connectivity. This is the pattern for organizations running Temporal across multiple teams — Nexus provides the abstraction layer that lets workflows call across namespace boundaries while maintaining isolation and ownership. The Miro case study makes the theoretical concrete.
Bhattad describes Noon’s journey from Airflow to Temporal for data pipeline orchestration. What started as a solution for specific data challenges expanded as other teams recognized Temporal’s advantages for pipeline orchestration. The talk covers the migration strategy, the differences in programming model between Airflow’s DAG-based approach and Temporal’s code-first workflows, and the operational improvements they observed. For data engineering teams considering a move away from Airflow, this provides a realistic assessment of what the migration involves and what you gain — and lose — in the transition. The talk is particularly relevant for teams finding Airflow’s scheduler-centric model limiting as their pipelines grow more complex and dynamic.
A meta-talk where Temporal’s own team explains how they use Temporal Cloud to power their self-service sign-up flow. The talk covers the end-to-end onboarding workflow: provisioning, namespace creation, configuration, and the orchestration required to spin up a new customer environment reliably. It’s a practical demonstration of dogfooding — Temporal using Temporal to solve a real product problem. For platform engineers building self-service developer experiences, the patterns here — multi-step provisioning workflows, rollback handling, and asynchronous status tracking — are directly applicable. The talk also provides insight into how Temporal thinks about its own infrastructure challenges.
With 4,500 engineers relying on Maersk’s internal developer platform, inefficiency has real cost. Bohdanowicz and Dubnik demonstrate how they use Temporal to power automation workflows spanning infrastructure provisioning, repository creation, deployment orchestration, and application setup. The saga pattern implementation is particularly interesting — orchestrating multi-step platform operations that need to be rolled back cleanly when any step fails. For platform engineering teams, this is a case study in using workflow orchestration to build self-service developer tooling at enterprise scale. The talk shows how Temporal reduces the coordination burden that typically falls on platform teams.
Duncan shares insights from building financial infrastructure with Temporal at Mercury, focusing on testing approaches, transactional safety, and performance optimizations. Uniquely, Mercury uses a Haskell SDK for Temporal, and Duncan covers the specific patterns and trade-offs involved. The talk addresses the practical reality most teams face: you can’t adopt Temporal all at once. Duncan outlines incremental adoption patterns — how to introduce Temporal into an existing codebase without a big-bang rewrite, how to handle the boundary between Temporal-orchestrated and non-Temporal code, and how to build confidence through progressive rollout. For teams in the early stages of Temporal adoption, particularly in regulated industries like fintech, this is essential guidance.
Wilson explains how Check replaced fragile cron jobs and Celery tasks with Temporal-powered orchestration for processing billions in wages and tax filings. The modular monolith architecture is the interesting part — Check didn’t decompose into microservices. Instead, they used Temporal within a monolithic codebase to achieve the reliability benefits of orchestration without the operational overhead of distributed deployment. The talk covers improvements in speed, reliability, and debugging capabilities. For teams that want Temporal’s guarantees but aren’t ready (or don’t need) to go full microservices, this is the architecture pattern that bridges both worlds.
Dos Santos and Rimell walk through transforming a monolithic Django application into a distributed microservices architecture orchestrated by Temporal, reducing antibody sequence analysis time from days to hours. The pharmaceutical context makes this especially compelling: Next-Generation Sequencing analysis demands intensive disk I/O and CPU resources, and failure mid-pipeline means restarting expensive computations from scratch. The team applied Domain-Driven Design principles and leveraged Temporal’s Python SDK with strategic thread and process pools. Deployed on Kubernetes with producer-consumer patterns and S3 streaming, the system achieved both horizontal and vertical scaling while maintaining deterministic execution. A blueprint for modernizing scientific computing workflows.
Sezer compares three approaches to building resilient platforms: traditional coding, Kafka-based orchestration, and Temporal. The comparison is practical — he demonstrates the limitations of each approach for handling retries, failures, state persistence, and long-running workflows. For engineers currently using Kafka as a workflow orchestration layer (a common pattern), this talk provides a clear comparison of where Kafka’s strengths end and Temporal’s begin. The talk includes a hands-on debugging session showing Temporal’s observability advantages. Sezer works on Trendyol’s Internal Developer Platform Database Team, giving him perspective on automating database management tasks — an area where reliable orchestration matters enormously.
Dellarosa describes Mollie’s transformation from a PHP monolith to Java-based microservices orchestrated by Temporal. The customer onboarding process now uses multiple concurrent workflows, improving both developer velocity and compliance automation. The talk covers the organizational dimension: how introducing Temporal changed not just the architecture but the way teams collaborate on complex financial processes. For fintech teams dealing with legacy PHP codebases and regulatory requirements, Mollie’s migration path — incremental, workflow-driven, and compliance-aware — is directly relevant. The focus on developer experience alongside reliability reflects a mature approach to modernization.
Reni and Tagliabue outline Mediaset’s switch from Airflow + EMR to Temporal + Bauplan for data processing. As one of Europe’s largest broadcasters, Mediaset processes 150GB of data daily. The new stack provides a streamlined Python-native platform that replaced the operational complexity of managing EMR clusters alongside Airflow DAGs. The partnership with Bauplan is interesting — it represents a new pattern where Temporal handles orchestration while a specialized compute layer handles data processing execution. For data engineering teams running Airflow at scale, this is a real-world comparison of operational overhead, developer experience, and cost between the two approaches.
Ramanauskas shares how Vinted integrated Temporal into their Ruby-based payments monolith to manage Europe’s largest second-hand marketplace. Processing millions of payments daily across multiple currencies and banking systems, Vinted needed reliability guarantees that their existing architecture couldn’t provide. The talk covers how integrating Temporal reduced complexity, improved resilience, and changed the way engineers design fault-tolerant workflows — all within an existing Ruby codebase. For teams running Ruby at scale (and there are more than you’d think), Vinted’s experience is especially relevant given the Pre-Release Ruby SDK announced at the conference. The payment flow patterns are applicable to any financial processing system.
Embar shares three years of production experience using Temporal for platform engineering at Nutanix. The examples range from simplified Kubernetes workload management to access control systems, demonstrating how Temporal solves problems at multiple layers of the stack. The “Swiss Army knife” framing is apt — the talk shows how a single orchestration tool can address an endless backlog of operational problems spanning workload orchestration, security approvals, and compliance enforcement. For platform teams evaluating whether Temporal can serve as their primary automation backbone, Nutanix’s breadth of use cases provides strong evidence.
El Aabidi and Vanzara demonstrate how Wise uses Temporal to enable self-service automation for critical database operations. With 16 million customers worldwide and downtime tolerance measured in milliseconds, the stakes are real. The talk covers integrating Temporal with AWS to handle database issues with minimal human intervention. The “massive to multitudes” framing captures Wise’s journey from large, manually-managed database operations to decomposed, automated workflows that individual teams can trigger and manage. For any team running critical databases at scale, the patterns for automated failover, scaling, and maintenance operations are directly applicable.
Tupe explains how Equinix — the backbone of the internet — uses Temporal-powered automation to scale Software-Defined Networking across global data centers. The talk covers the unique challenges of network automation at planetary scale: coordinating changes across thousands of devices, handling partial failures in network configuration, and maintaining consistency across distributed infrastructure. For infrastructure engineers working on SDN or network automation, this is a rare look at how a digital infrastructure giant handles orchestration at global scale. The AI-ready data center angle adds context for how infrastructure providers are preparing for the next wave of compute demand.
Waseem shares a crisis response story: how KOHO adopted Temporal mid-flight during a critical development cycle when a vendor experienced a Sev1 outage. Rather than scrambling with ad-hoc solutions, the team integrated Temporal to maintain service reliability, turning what could have been a major incident into a non-event for users. The talk centers on critical vendor integrations, real-world factors, and the high-stakes decision that ultimately made the team choose Temporal. For engineering managers evaluating Temporal adoption under pressure, KOHO’s experience demonstrates that Temporal can be brought in during a crisis — not just during a planned modernization cycle — and deliver immediate reliability improvements.
Irwin walks through how Vodafone built a highly resilient CPE management system to handle software deployment, security patches, and fleet-wide updates across millions of routers and home devices. The implementation supports USP (User Services Platform), a standardized protocol for dynamically adding new services to connected devices. For IoT and telecom engineers, this is a rare production case study in using workflow orchestration for device fleet management at massive scale. The challenges are unique to this domain: unreliable device connectivity, firmware update rollbacks, and the need to coordinate updates across millions of devices without bricking them.
Bykov uses the Three Little Pigs fairy tale as a surprisingly effective framework for explaining application reliability. He traces the evolution of reliability requirements and explains how redundancy enhances resilience while introducing new coordination challenges. The analogy works: building with straw (no reliability), sticks (some retries), or bricks (Durable Execution) maps cleanly to how teams evolve their architecture. The talk provides a conceptual foundation for understanding why Temporal’s approach to reliability differs from traditional retry-and-hope patterns. For engineers new to distributed systems reliability, this is the accessible entry point that connects intuition to architecture.
Suryadevara and Mei dive into the enhanced high availability offerings announced at the keynote, specifically namespace replication and the infrastructure behind Temporal Cloud’s multi-region capabilities. For teams running mission-critical workloads on Temporal Cloud, this talk covers the mechanics of how failover works, what RPO/RTO guarantees look like, and how namespace replication enables disaster recovery without application-level changes. The talk bridges the gap between the keynote announcement and practical implementation — it’s the operational detail that platform teams need to make informed deployment decisions.
Jonsson describes Telenor Sweden’s digital transformation journey that started in 2018 with building a microservice-based BSS stack. Teams repeatedly built similar code to handle resilient state management, creating duplication and inconsistency. Integrating Temporal into their order intake process leveraged built-in support for event sourcing, resilience, and compensating transactions. The result: developers focus on business value without managing traditional technical complexities. The talk demonstrates how Temporal reduces time-to-value by aligning development efficiency with business objectives — reducing incidents, increasing throughput, and improving alignment between business goals and technical execution.
Temporal went to London and proved that Durable Execution isn’t just a clever abstraction — it’s the foundation that teams across every industry are choosing when failure isn’t an option. Twenty-seven talks, zero hand-waving. The future of resilient systems isn’t theoretical. It’s already in production.
You’re reading Talk::Overflow #24 — the weekly digest for developers who want to stay sharp and skip the noise.
→ Browse past issues
→ Suggest a talk
→ Share it with the friends
Stay curious. Stay kind.
— Talk::Overflow
Comments
Nothing yet. Say the first thing.
Sign in to join the conversation.