Ad Delivery & Payment Workflows
Real-time ad delivery orchestration processing billions of impressions daily, plus payment workflows for advertiser billing with automatic retry and compensation logic.
Media Encoding Pipeline
Content encoding workflows converting media for 200+ device types, handling multi-hour encoding jobs with checkpointing and automatic retry on infrastructure failures.
Terraform Cloud Orchestration
Infrastructure provisioning workflows for plan and apply operations, state locking, policy evaluation, and multi-environment deployment coordination.
Payment Processing Workflows
Complex payment flows including subscriptions, disputes, and refunds with saga patterns for distributed transactions and compliance audit trails.
What Temporal Developers Actually Build
Before you write your job description, understand what a Temporal developer will do at your company. Here are real examples from industry leaders:
Social Media & Advertising
Snap uses Temporal extensively for their advertising and payment infrastructure:
- Ad delivery workflows processing billions of ad impressions daily
- Payment processing with automatic retry and compensation logic
- User data workflows for privacy compliance (GDPR deletion requests)
- Content moderation pipelines requiring human-in-the-loop approvals
Coinbase relies on Temporal for cryptocurrency operations:
- Wallet creation and cryptocurrency transfer workflows
- Compliance and KYC verification processes
- Multi-step onboarding workflows with external verification
- Transaction reconciliation across multiple blockchains
Streaming & Entertainment
Netflix runs critical infrastructure on Temporal:
- Media encoding pipelines (converting content for 200+ device types)
- Content ingestion workflows from studios and partners
- Asset management and delivery orchestration
- A/B test deployment and rollback workflows
Datadog uses Temporal for their observability platform:
- Alert workflow orchestration across millions of metrics
- Incident management and escalation workflows
- Data pipeline orchestration for log processing
- Customer onboarding and trial management
Developer Tools & Infrastructure
HashiCorp built Terraform Cloud on Temporal:
- Plan and apply workflows for infrastructure provisioning
- State locking and coordination across teams
- Policy evaluation and approval workflows
- Multi-environment deployment orchestration
Stripe processes payments through Temporal:
- Complex payment flows (subscriptions, disputes, refunds)
- Marketplace payout orchestration
- Fraud detection with human review workflows
- International payment routing with compliance checks
E-commerce & Logistics
DoorDash orchestrates deliveries with Temporal:
- Order fulfillment from placement to delivery
- Driver assignment and re-assignment on failures
- Restaurant confirmation and preparation tracking
- Refund and compensation workflows
Box manages enterprise content workflows:
- Document approval and signing workflows
- Retention policy enforcement
- Cross-system sync and migration
- Compliance audit trail generation
What to Look For: Skills by Level
Junior Temporal Developer (0-2 years)
What they should know:
- Basic Temporal concepts: workflows, activities, workers, task queues
- Writing simple workflow definitions and activities in their language (Go, Java, TypeScript, Python)
- Understanding workflow vs activity distinction and why it matters
- Basic error handling and retry configuration
- Local development and testing patterns
What they're learning:
- Signal and query patterns for workflow interaction
- Child workflows and when to use them
- Timer and sleep patterns for scheduling
- Workflow versioning for safe deployments
Realistic expectations: They can implement straightforward sequential workflows but need guidance on complex patterns, long-running workflow design, and production operational concerns.
Mid-Level Temporal Developer (2-4 years)
What they should know:
- Advanced patterns: sagas, compensation, continue-as-new
- Signal and query handling for external interaction
- Child workflows and parent-child coordination
- Workflow versioning and safe deployment strategies
- Activity timeout and retry policy optimization
- Testing strategies including workflow replay tests
- Basic operational tasks (namespace management, worker scaling)
What they're learning:
- Multi-cluster deployment and failover
- Advanced visibility and search attributes
- Performance optimization at scale
- Custom data converters and encryption
- Building internal platform abstractions
Realistic expectations: They can own features end-to-end, design workflow architectures for new use cases, and troubleshoot production issues independently.
Senior Temporal Developer (5+ years)
What they should know:
- Designing workflow architectures for complex business domains
- Saga patterns with proper compensation logic
- Multi-region deployment and disaster recovery
- Performance optimization at scale (thousands of concurrent workflows)
- Advanced patterns: schedules, update handlers, async activities
- Building internal SDKs and developer experience tooling
- Migration strategies from other orchestration systems
What sets them apart:
- They've operated Temporal at significant scale (millions of workflow executions)
- They can articulate tradeoffs between Temporal and alternatives (Step Functions, Airflow, custom solutions)
- They mentor others and establish team patterns and best practices
- They've survived and learned from production incidents involving workflow failures
- They understand the Temporal server architecture and can make informed deployment decisions
The Modern Temporal Developer (2024-2026)
Temporal has matured significantly since its 2019 launch. The ecosystem and best practices have evolved rapidly.
The Shift to Temporal Cloud
Self-managed Temporal clusters are increasingly rare outside of very large companies. Most teams now use:
- Temporal Cloud — The fully managed offering from Temporal Technologies
- Self-hosted — For organizations with strict data residency or compliance requirements
- Hybrid — Critical workloads on-premise, others on Temporal Cloud
Hiring implication: Operational Temporal experience (Cassandra tuning, Elasticsearch configuration) matters less than it did 2 years ago. Focus on workflow design and application-level skills for most roles.
The Rise of Multi-Language Teams
Temporal supports multiple SDKs, and teams often use more than one:
- Go remains the most popular, especially for infrastructure teams
- TypeScript is growing rapidly for web-oriented teams
- Java dominates in enterprise environments
- Python is gaining traction for data and ML workflows
Interview tip: Ask which SDK they've used and why. The answer reveals their background and what types of workflows they've built.
Workflow Patterns Have Standardized
The community has converged on best practices:
- Saga pattern for distributed transactions with compensation
- Polling pattern for external system integration
- Entity pattern for long-lived stateful objects
- DSL pattern for business-user-configurable workflows
Look for: Candidates who can discuss when to use each pattern—not just Temporal syntax.
Testing Has Matured
Production Temporal code requires sophisticated testing:
- Workflow replay tests for determinism verification
- Time skipping for testing timer-based logic
- Mocking frameworks for activity isolation
- Integration test patterns for end-to-end verification
Assessment tip: Ask how they'd test a workflow with a 30-day timeout. Strong candidates know about time skipping and don't suggest waiting 30 days.
Recruiter's Cheat Sheet: Spotting Great Candidates
Conversation Starters That Reveal Skill Level
Instead of asking "Do you know Temporal?", try these:
| Question | Junior Answer | Senior Answer |
|---|---|---|
| "How would you handle a workflow that might run for months?" | "Use sleep or timers" | "I'd use continue-as-new to reset history size, implement heartbeating for long activities, design idempotent activities for retries, and set up proper search attributes for visibility into long-running workflows." |
| "When would you choose Temporal over AWS Step Functions?" | "Temporal is more powerful" | "Step Functions for simple AWS-native workflows with native service integrations. Temporal when you need code-first workflow definition, complex business logic, multi-region deployment, or want to avoid vendor lock-in. The testability of Temporal code is also a major factor for complex domains." |
| "Tell me about a workflow failure you debugged" | Generic or vague | Specific details: "A payment workflow was timing out because an activity retried indefinitely on a downstream service that was rate-limiting us. We added exponential backoff, set a max retry limit, and implemented a fallback path. Also added alerts for activity retry rates." |
Resume Signals That Matter
✅ Look for:
- Specific scale indicators ("Orchestrated 500K workflow executions/day", "99.99% workflow completion rate")
- Production operational experience (incidents, migrations, upgrades)
- Mentions of saga patterns, compensation logic, or distributed transactions
- Experience with workflow versioning and safe deployment
- Contributions to Temporal SDKs or community
🚫 Be skeptical of:
- "Expert in Temporal" without production context
- Listing every orchestration tool (Temporal AND Airflow AND Step Functions AND Camunda AND...)
- No mention of testing, versioning, or operational concerns
- Only tutorial-level projects (simple sequential workflows)
GitHub Portfolio Signals
Strong indicators:
- Workflow definitions with proper error handling and compensation
- Custom activities with retry configuration and heartbeating
- Worker implementations with graceful shutdown
- Tests using workflow replay and time skipping
- Documentation of architectural decisions
Weak indicators:
- Only "hello world" workflow examples
- No error handling or retry logic
- Missing tests for workflow determinism
- No consideration for long-running workflow patterns
Temporal vs Alternatives: When It Makes Sense
Understanding when Temporal is the right choice helps you write better job descriptions and evaluate candidates.
Temporal vs AWS Step Functions
| Aspect | Temporal | Step Functions |
|---|---|---|
| Workflow definition | Code (Go, TS, Java, Python) | JSON/YAML |
| Testability | Full unit testing, replay tests | Limited, mostly integration |
| Vendor lock-in | None | AWS-specific |
| Local development | Full local server | LocalStack with limitations |
| Complex business logic | Native code constructs | ASL expressions |
| Multi-region | Built-in support | Complex to configure |
| Cost model | Compute-based | Per state transition |
Use Step Functions when: Simple AWS-native workflows, heavy AWS service integration, small team without Temporal expertise.
Use Temporal when: Complex business logic, testability is critical, multi-cloud or hybrid deployment, long-running workflows (months/years).
Temporal vs Apache Airflow
| Aspect | Temporal | Airflow |
|---|---|---|
| Primary use case | Application workflows | Data pipelines |
| Execution model | Event-driven, durable | Schedule-driven, DAGs |
| Latency | Sub-second | Minute-level |
| State persistence | Automatic, built-in | External (database) |
| Failure handling | Automatic retry, compensation | Manual retry, limited |
| Developer experience | IDE support, debugging | Web UI, limited debugging |
Use Airflow when: Batch data pipelines, ETL workflows, scheduled jobs with complex dependencies.
Use Temporal when: Application workflows, real-time orchestration, long-running business processes, complex error handling.
Common Hiring Mistakes
1. Requiring Temporal Experience for a Small Team
The mistake: Demanding 3+ years of Temporal experience when your team is just adopting it.
Reality check: Temporal launched in 2019, and the talent pool with deep production experience is small. Strong backend engineers with distributed systems knowledge learn Temporal quickly. Netflix and Snap built their early Temporal teams from engineers with workflow orchestration concepts, not necessarily Temporal-specific experience.
Better approach: Require distributed systems fundamentals and workflow concepts. "Experience with workflow orchestration (Temporal, Step Functions, Cadence, or Camunda)" casts a wider net.
2. Testing for Temporal API Trivia
The mistake: Asking "What's the default activity timeout?" or "What method starts a child workflow?"
Why it fails: These are easily looked up. Strong engineers might not memorize defaults because they always configure explicitly. Meanwhile, someone who memorized the docs might struggle with real architectural decisions.
Better approach: Ask "How would you design a payment workflow that needs to refund if any step fails?" This reveals understanding of saga patterns, compensation, and real-world workflow design.
3. Ignoring Transferable Skills
The mistake: Rejecting candidates without Temporal experience when they have strong Cadence, Step Functions, or Airflow backgrounds.
Reality: Temporal is based on Cadence—the concepts are nearly identical. Step Functions users understand workflow orchestration. Airflow users know about task dependencies and failure handling. A strong distributed systems engineer learns Temporal specifics in 2-4 weeks.
Better approach: Test for workflow thinking, not Temporal syntax. Ask about handling distributed transactions, long-running processes, or failure compensation—these concepts transcend any specific tool.
4. Conflating Temporal with Data Engineering
The mistake: Expecting every Temporal developer to also know Spark, Kafka, and dbt.
Reality: Temporal roles span a spectrum:
- Backend engineers who use Temporal for application workflows
- Platform engineers who operate Temporal infrastructure
- Data engineers who use Temporal for pipeline orchestration (rarer)
Better approach: Be specific about what you need. "Temporal platform engineer" is different from "Backend engineer using Temporal" is different from "Data engineer with Temporal experience."
5. Underestimating the Learning Curve for Advanced Patterns
The mistake: Hiring for basic workflow skills when you need saga pattern expertise.
Reality: Basic Temporal workflows are straightforward. Advanced patterns—sagas with compensation, long-running entity workflows, complex versioning strategies—require significant experience. Snap's payment workflows and HashiCorp's Terraform workflows needed senior engineers who understood both Temporal and the business domain.
Better approach: For advanced use cases, specify the patterns you need. "Experience with saga patterns and compensation logic" is more precise than "Temporal experience."