Blog post to introduce the Temporal Swift SDK

_data/authors.yml

@@ -373,7 +373,7 @@ FranzBusch:
    email: [email protected]
    github: FranzBusch
    gravatar: 3b34dbe9f3870b0e9bf1f4cb0750fa3d
-   about: "Franz Busch is a member of a team developing foundational server-side Swift libraries at Apple, and is a member of the SSWG."
+   about: "Franz Busch is a member of the Ecosystem Steering Group and the Swift Server Workgroup. He works in a team developing foundational server-side Swift libraries at Apple."
 
 adrian-prantl:
   name: Adrian Prantl

_posts/2025-11-10-swift-temporal-sdk.md

@@ -0,0 +1,56 @@
+---
+layout: new-layouts/post
+published: true
+date: 2025-11-10 10:00:00
+title: "Introducing Temporal Swift SDK: Building durable and reliable workflows"
+author: [FranzBusch]
+category: "Developer Tools"
+---
+
+The [Temporal Swift SDK](https://github.com/apple/swift-temporal-sdk) is now available as an open source project. This Swift package enables you to build reliable distributed systems using Temporal’s durable execution platform.
+
+Building reliable distributed systems requires handling failures gracefully, coordinating complex workflows across multiple services, and ensuring long-running processes complete successfully. Rather than develop these resiliency features into every application or service you develop, Temporal offers the pattern of a __workflow__. Workflows encapsulate your code so it runs durably and handles many common failure scenarios.
+
+With the Temporal Swift SDK, you can build resilient workflows that survive infrastructure failures. The SDK brings another essential tool for developers that build highly reliable and scalable production cloud services.
+
+## Writing durable workflows in Swift
+
+The Temporal Swift SDK enables developers to write reliable and durable workflows. Previously, Swift developers had to resort to more traditional approaches for building fault-tolerant workflows, such as implementing custom state machines on top of database systems or message queuing services, solutions that often required significant boilerplate code and careful handling of edge cases that Temporal manages automatically.
+
+The SDK provides a seamless Swift developer experience by:
+
+- Using familiar async/await patterns and Structured Concurrency to build maintainable workflow code.
+- Leveraging Swift's strong type system to catch errors at build time rather than runtime.
+- Providing macros to reduce boilerplate when authoring workflows.
+
+The design and implementation of the Temporal Swift SDK has been informed and validated by multiple production use-cases, ensuring that the SDK meets real-world requirements for performance, reliability, and developer experience. 
+
+The Temporal Swift SDK can be used across a wide range of real-world scenarios where reliability and coordination are paramount, including:
+
+- E-commerce and payment processing where multi-step payment processing requires automatic retry and rollback capabilities.
+- Data processing & ETL where you may be performing large-scale data transformation pipelines.
+- Business process automation with approval workflows and human-in-the-loop interactions.
+- Monitoring and operations with scheduled maintenance and cleanup tasks.
+
+## What is Temporal and why does it matter?
+
+[Temporal](https://temporal.io) is an open source platform for building reliable distributed applications. At its core is the concept of durable execution, your code runs to completion even in the face of infrastructure failures. When a worker crashes or restarts, Temporal automatically resumes your workflow from where it left off, without requiring you to write complex retry logic or state management code. This is achieved through Temporal's architecture, which separates workflow orchestration from actual work execution:
+
+- **Workflows** define the overall business logic and coordination. They describe the sequence of steps, decision points, and error handling for a process. Workflows must be deterministic given the same inputs and history, they must always make the same decisions.
+- **Activities** perform the actual work, such as calling external APIs, processing data, or interacting with databases. Activities should be idempotent, meaning they can be safely retried without causing unintended side effects.
+
+Modern distributed systems face common challenges: coordinating multiple services, handling partial failures, ensuring consistency across operations, and managing long-running processes. Traditional approaches require building custom retry logic, state machines, and coordination mechanisms. Temporal provides a platform that handles these concerns, allowing you to focus on your business logic.
+
+Temporal has also published a [blog post](https://temporal.io/blog/announcing-the-swift-temporal-sdk) detailing the introduction of the Temporal Swift SDK highlighting the unique advantages this brings to Swift developers building distributed systems.
+
+## Getting started
+
+To get started with the Temporal Swift SDK, explore its [documentation](https://swiftpackageindex.com/apple/swift-temporal-sdk/main/documentation/temporal) which provides detailed guides for implementing workflows and activities. The repository also includes a rich collection of [example projects](https://github.com/apple/swift-temporal-sdk/tree/main/Examples), demonstrating the SDK's capabilities across different use cases from simple task orchestration to complex multi-step business processes. For a deeper understanding of Temporal's core concepts and architectural patterns, be sure to check out the [general Temporal documentation](https://docs.temporal.io/), which provides valuable context for building robust distributed systems.
+
+## Community and feedback
+
+Temporal Swift SDK is an open source project and we're eager to hear from the Swift community. Whether you're building microservices, coordinating long-running processes, or simply curious about durable execution, we'd love to know how the Temporal Swift SDK works for you. The SDK provides a powerful foundation for building reliable distributed systems in Swift.
+
+The project is actively developed and we welcome contributions, bug reports, and feature requests. As with any distributed systems tool, different applications and environments present unique challenges, and community feedback is essential for improving the SDK's effectiveness across diverse Swift codebases.
+
+Ready to start building reliable distributed systems? Visit the [Temporal Swift SDK repository](https://github.com/apple/swift-temporal-sdk) to get started.