Back to all posts
Backend7 min read·October 25, 2026

Synchronous vs Asynchronous Processing: When to Use Each

TB
ThynkBlox Team
Engineering

What is the difference between synchronous and asynchronous processing?

Synchronous processing keeps the caller waiting for an operation to finish before continuing with the step that depends on its result. Asynchronous processing lets the caller continue while the operation completes separately, so the product needs a way to show progress, return results or explain failure. Practical synchronous vs asynchronous processing examples include checking a discount before confirming an order, then generating its receipt separately.

The decision starts with a business question: does the person need the finished result to take their next action?

Which business workflows suit each approach?

Use synchronous processing when the next decision depends on an immediate answer. Consider asynchronous processing when completion can wait and the product can make that delay clear.

WorkflowSuggested approachWhat the user should see
Check whether a discount appliesSynchronousThe accepted discount or a clear rejection
Save a delivery addressSynchronousConfirmation after the save succeeds
Generate a large sales reportAsynchronousAn accepted request, status and download when ready
Process an uploaded product catalogueAsynchronousProgress, rejected rows and a completion summary
Confirm an order and send its emailMixedOrder confirmation first; email delivery separately

These are design examples, not fixed rules. A small report may be quick enough to return immediately. A catalogue upload may need an immediate format check before the longer import begins.

Define the promise for each step. “File received” means something different from “Products imported.”

How do queues support asynchronous work?

A queue holds work for a worker to collect and process. In a report workflow, the application records the request, submits a job and returns a reference that the user can revisit. A worker later prepares the file and updates the request’s status.

Choose queue behaviour deliberately: delivery, ordering and recovery guarantees vary between systems and configurations.

For a business owner, the useful questions are practical:

  • How long can a request remain queued?
  • What happens if processing stops halfway through?
  • Who notices jobs that never finish?
  • Can urgent work proceed while large jobs wait?

A queue is a place for pending work, not a completion promise. Give each job a visible state such as queued, processing, completed or needs attention.

What should users see while work finishes?

Make the first response precise. “Your report is queued” sets a different expectation from “Your report is ready.”

Provide a persistent place to check status. A notification can bring someone back, but the result should also be available from the relevant order, upload or report page.

Show progress only at a level the application can support. “Validating rows” is useful without pretending to know the exact remaining time. If some records fail, explain whether successful records were saved and give the user a way to review the failures.

Decide whether closing the page cancels the work. For a business report, a sensible requirement is that processing continues and the result remains available when the person returns.

What does a mixed workflow look like in practice?

Consider a wholesale order portal. The following sequence is illustrative.

First, confirm the order. Check the submitted details, establish the agreed price and availability, and save the order. Return a confirmed order reference only after the required confirmation steps succeed.

Next, prepare supporting documents. Queue receipt generation and confirmation email delivery. Show the confirmed order immediately, with separate document and email statuses.

Then, handle partial failure. If receipt generation succeeds but email delivery fails, keep the receipt available in the portal. Retry the email according to the recovery policy without asking the buyer to place the order again.

Finally, make support useful. Let an authorised support user see which step failed and retry that step safely.

This separates the business outcome from its follow-up work. The product should never describe an order as failed merely because its confirmation email could not be delivered.

When should failed work be retried?

Start by classifying the failure. A temporarily unavailable service may recover. An invalid delivery address needs correction. Repeating the same invalid request does not resolve its cause.

Set a bounded retry policy: define which failures qualify, how attempts are spaced and when automatic attempts stop. Backoff increases the delay between attempts; jitter varies their timing to reduce synchronised retry bursts.

A timeout needs special care. It tells the caller that an answer did not arrive in time; it does not establish whether the requested action happened.

Before repeating a consequential action, check whether it already completed. For a payment or shipment request, an uncertain result should trigger a status check or reconciliation process.

How do you prevent duplicate business actions?

Design for the same request to arrive again. A person might press submit twice, or a worker might repeat an attempt after losing its connection.

Give each intended business operation a stable identifier. Repeated attempts for that operation should reuse it. This supports idempotency: repeating the request has the same intended business effect as processing it once.

For example, retrying confirmation email delivery should refer to the existing order. It should not create another order.

The duplicate check and the protected action must be coordinated. A separate “has this run?” check followed by an unprotected action can allow concurrent attempts through. For external services, duplicate protection also depends on the guarantees of that service.

Ask a build partner to explain what happens if processing stops immediately before or after the business action succeeds.

How should error recovery work?

Write the recovery path alongside the happy path.

For a catalogue import, decide whether an invalid row blocks the whole file or only that row. Show rejected entries with reasons the user can act on. State whether a corrected upload replaces earlier entries or adds new ones.

For a failed report, retain enough request information to retry it. Decide whether the retry uses the original data snapshot or current data, since those represent different reports.

For work that exhausts its automatic retries, create an actionable failure state. Assign an owner, preserve the operation reference and provide a controlled retry or correction path.

These scenarios belong in software testing and quality assurance: test interrupted work, repeated requests and recovery, as well as successful completion.

What common mistakes should you avoid?

  • Calling acceptance success. A queued import has been accepted; its records are not necessarily saved.
  • Moving validation too late. Reject obvious input problems before asking someone to wait.
  • Retrying every failure. Invalid input needs correction, while an uncertain outcome needs investigation.
  • Hiding partial completion. Tell users which steps succeeded and what remains.
  • Making every operation asynchronous. Each delayed workflow needs status, recovery and a result delivery path.
  • Assuming queues require microservices. Treat processing style and application structure as separate decisions when comparing microservices and monolithic architecture.

What should you agree before development starts?

Use this checklist for each workflow:

  • What result must exist before the user continues?
  • What does the initial response promise?
  • Where can the user check completion or failure?
  • Which failures can retry automatically?
  • How are duplicate actions prevented?
  • What happens after partial completion?
  • Who handles work that cannot recover automatically?

Clear answers turn “run it in the background” into an implementable product requirement.

What are the frequently asked questions?

Does asynchronous mean parallel?

No. Asynchronous describes how completion relates to the caller. Parallel describes work happening at the same time. A background workflow can process its jobs sequentially.

Is asynchronous processing always faster?

No. It lets the caller continue before completion, but it does not guarantee an earlier finished result. Evaluate waiting time and total completion time separately.

Does synchronous processing mean blocking the whole application?

No. The caller waits for that operation’s result. Other requests may still be handled, depending on the application’s design.

Can one workflow use both approaches?

Yes. Confirm an order synchronously, then prepare documents asynchronously. Give each step its own completion condition and recovery path.

For how queued work is usually organised, see background jobs and queues, explained for founders.

Ready to build?

Let's turn these ideas into your next product.

Start your project