Technical Tutorials

Microservices architecture often introduces complexity in managing distributed transactions. While services are decoupled, coordinating their interactions requires robust orchestration. Temporal addresses this by providing durable execution capabilities, allowing developers to write reliable workflows in a fault-tolerant manner. This guide explores how to leverage Temporal with Python, Go, and TypeScript, creating a truly polyglot client environment.

The Power of Polyglot Clients

One of Temporal's strongest features is its language-agnostic SDKs. Teams can choose the best language for each service without sacrificing workflow consistency. Whether your core backend is in Go for performance, your data processing layer is in Python for analytics, or your frontend integration is in TypeScript, Temporal provides a unified programming model using the Workflow Definition Language (WDL).

Defining Workflows in Go

Go is often the backbone of high-performance microservices. In Temporal, a Go workflow is defined as a regular function. The key is using the workflow.ExecuteActivity function, which allows you to call activities (stateless functions) that perform the actual work.

package main

import (
    "go.temporal.io/sdk/workflow"
)

func MyWorkflow(ctx workflow.Context) error {
    ao := workflow.ActivityOptions{
        StartToCloseTimeout: 10 * time.Second,
    }
    ctx = workflow.WithActivityOptions(ctx, ao)

    var result string
    // Execute activity and wait for completion
    err := workflow.ExecuteActivity(ctx, GreetActivity, "Hello").Get(ctx, &result)
    return err
}

func GreetActivity(ctx context.Context, name string) (string, error) {
    return "Greeting: " + name, nil
}

Implementing Workers in Python

Python developers benefit from Temporal's intuitive decorators. The @workflow.defn and @activity.defn decorators simplify the registration of workflows and activities. This approach keeps the business logic clean and separates workflow control flow from activity implementation.

from temporalio import workflow
from temporalio import activity
from typing import Dict

@activity.defn
async def greet_activity(name: str) -> str:
    return f"Greeting: {name}"

@workflow.defn
class MyWorkflow:
    @workflow.run
    async def run(self, name: str) -> str:
        result = await workflow.execute_activity(
            greet_activity,
            name,
            schedule_to_close_timeout=timedelta(seconds=10)
        )
        return result

Client Integration with TypeScript

p>TypeScript clients are ideal for serverless functions or frontend-connected workers. The SDK provides type-safe interfaces that align well with modern web development practices. You can start workflows and query their status directly from your Node.js applications.

import { Client } from '@temporalio/client';

async function startWorkflow() {
    const client = new Client({
        connectionOptions: {
            address: 'localhost:7233',
        },
    });

    const handle = await client.start('MyWorkflow', {
        taskQueue: 'default',
        args: ['World'],
    });

    console.log(`Workflow started with ID: ${handle.workflowId}`);
}

startWorkflow();

Best Practices for Polyglot Environments

When working across multiple languages, consistency is key. Ensure that all clients use the same Temporal Server version to avoid compatibility issues. Use shared interfaces or Protobuf schemas for data structures passed between activities in different languages. This prevents serialization errors and ensures type safety across the entire workflow.

Conclusion

Temporal enables developers to build resilient, scalable microservices without being locked into a single language ecosystem. By leveraging Python, Go, and TypeScript, teams can utilize the strengths of each language while maintaining a unified execution model. As you adopt these patterns, focus on durable execution and fault tolerance to deliver robust applications that can withstand failures gracefully.