Temporal makes a long-running process resumable by recording workflow progress and replaying workflow code against that history. The key change from an ordinary background job is that orchestration code must be deterministic: it decides what should happen next, while external work such as HTTP requests and database operations runs in Activities. In .NET, that means using Temporal’s workflow timers and avoiding ordinary wall-clock, I/O, and threading behavior inside Workflow code.
What changes when a job needs durable progress?
A conventional hosted service or queue consumer commonly keeps its current progress in process memory. If the process stops, recovery depends on what the job has already persisted and what the queue or application does when work is retried. A Temporal Workflow instead expresses the orchestration as code and uses recorded history to resume its progress. This is useful when a process must wait for time or external input, coordinate multiple steps, or remain open across worker restarts and deployments.
As an Amazon Associate I earn from qualifying purchases.
Temporal’s .NET development model has four main parts: a Workflow, Activities, a Worker, and a Client. The Workflow coordinates the process; Activities perform external work; a Worker executes workflow and activity tasks; and a Client starts workflows and communicates with them. Temporal’s .NET guide organizes its learning path around these pieces, along with testing, debugging, and best practices.
This model provides durable orchestration, not a guarantee that every external side effect happens exactly once. If a worker fails around the time an external operation completes, an Activity can be retried and the outcome may be ambiguous to the application. Design side-effecting operations to be idempotent where possible, or give the integration a way to detect and reconcile repeated attempts.
#1 Best Overall
Workflow or Activity: where does each operation belong?
| Part | What it does | Typical work |
|---|---|---|
| Workflow | Coordinates steps and makes decisions that can be replayed from recorded history. | Choose the next step, schedule an Activity, wait for a timer, or react to workflow input. |
| Activity | Performs external or otherwise nondeterministic work. | Call an HTTP API, read or update a database, or perform I/O. |
The boundary is about replay, not merely code organization. Temporal replays workflow code against its Event History to reconstruct orchestration state. Its documentation states: “Workflow code must be deterministic to support replay.” For the same input and history, workflow code must issue the same Temporal API calls in the same sequence. Returning the same final value is not enough if a replay takes a different orchestration path.
Keep network calls, database access, file access, and other external interactions out of the workflow’s replay path. Schedule them as Activities and let the Workflow make its next decision from their recorded results. That way a replay reconstructs the sequence of orchestration decisions without repeating ordinary I/O as part of workflow execution.
What .NET code must change for replay safety?
Inside a Temporal Workflow, do not base decisions on changing external state or nondeterministic process behavior. The .NET SDK README specifically cautions against DateTime.Now, Task.Delay, and Thread.Sleep in Workflow code. Use Temporal’s workflow time and timer APIs instead; the README identifies Workflow.DelayAsync as its timer primitive.
- Do not make HTTP requests, database calls, or other I/O from Workflow code; put that work in an Activity.
- Do not use the system clock to decide when workflow logic advances; use Temporal workflow time and timers.
- Avoid ordinary thread and task-scheduling behavior in Workflow code. The .NET SDK README flags
Task.RunandConfigureAwait(false)as hazards in workflow code because the SDK uses a deterministic task scheduler. - Keep these constraints specific to Workflow code. Activities and ordinary application code are not subject to the same replay contract.
A useful design sketch is: the Workflow schedules an Activity to submit an order, waits using a Temporal timer, then schedules another Activity to check the external system. The HTTP request and status lookup belong in Activities; the decision about when to perform them and what to do with their results belongs in the Workflow. Treat this as an architectural sketch, not a compile-ready API sample: check the current Temporal .NET SDK documentation for signatures and package-version details before writing code against a particular release.
How do waits, messages, and retries fit?
A durable Workflow can wait for a timer or external input and continue from its recorded history, rather than relying on a process remaining alive while it waits. Temporal’s .NET guide covers timers, message passing, cancellation, schedules, child workflows, and continue-as-new alongside Activity execution and error handling. These primitives let orchestration represent a process that pauses, receives new information, and then chooses its next step.
Activities are also the boundary for failure handling. Their timeout and retry configuration should reflect what the external system can tolerate and how long an operation may take. A retry can cause an external request to be attempted again; Temporal’s orchestration history does not by itself make an arbitrary remote API or database operation exactly-once. Use idempotency keys, deduplication, or explicit reconciliation when repeating the side effect could cause harm.
Rank #4
How should workflow changes be deployed?
Open executions may outlast a deployment. When an execution is replayed, a code change that alters the Temporal API calls made by its Workflow can conflict with the existing Event History. Temporal’s .NET versioning guidance says replay-incompatible changes need a versioning method. The strategy depends on the change and on which executions remain open; versioning is not a universal one-time deployment switch.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
- Identify whether the edit changes the Workflow’s sequence of Temporal operations for executions that are already open.
- If it is replay-incompatible, use a versioning approach so existing histories can follow a compatible path while new executions use the intended behavior.
- Consider a new Workflow type when that provides a clearer route for new executions without changing the behavior required by open executions of the existing type.
- Keep the old compatible path available for as long as executions that need it remain open, according to the chosen migration strategy.
For example, adding a new Activity between two existing steps can change the call sequence seen during replay. Do not assume that deploying the changed method automatically migrates every execution already in progress. Check the .NET versioning guidance for the current SDK’s supported approach and test the relevant histories before rolling out the change.
How do you start, and what does .NET 10 establish?
Temporal’s official .NET quickstart describes both local Temporal Service setup and a Temporal Cloud path. Choose the path that fits the team’s operating model: a local setup is useful for development, while a production deployment requires deciding who operates the service and how it will be maintained. The quickstart establishes those starting paths, but it is not a detailed comparison of service features, pricing, regions, or service levels.
Microsoft lists .NET 10 as an LTS release, with a retirement date of November 15, 2028. Microsoft’s current support guidance says LTS releases are supported for a minimum of three years, or one year after the next LTS release ships if later. That is Microsoft’s .NET lifecycle information; it does not establish that a particular Temporal .NET SDK release guarantees compatibility with .NET 10.
Before choosing a production target, verify the currently supported Temporal .NET SDK package and its release or CI documentation for the runtime compatibility claim you need. The Temporal documentation referenced here does not provide an explicit .NET 10 compatibility matrix or minimum-runtime statement, so do not infer SDK compatibility solely from .NET 10’s LTS status.
Windows Errors? Fix Them Before They Spread
Repair common Windows errors and clear accumulated junk for a smoother, more stable PC - no reinstall needed.Free scan · no reinstallCrashes, No Sound, or Screen Glitches?
Random freezes, missing sound and display glitches usually trace back to one bad driver. Find and replace yours safely.Free scan · under a minuteQuick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
