Synchronous call
A synchronous call is an invocation in which the caller waits for the operation to complete or return a result before continuing.
Grokking Software Architecture
A synchronous operation blocks the initiating participant until the requested processing completes and a result is available.
- How it is used
- Contrasts waiting for an API response with deferring background work to avoid blocking chains.
- How deep it goes
- Explains the request-response cycle and illustrates latency and availability consequences of sequential service calls.
- Examples
- Uses a coffee-shop queue and an order workflow involving inventory, payment, and shipping.
- What you can do after
- Evaluate which work needs an immediate result and which can be queued for later processing.
Read how Grokking Software Architecture explains synchronous call →
Designing AI Systems
Synchronous execution is an execution model in which the caller waits for an operation to complete before receiving its result.
- How it is used
- Uses synchronous calls for fast AI workflows and external tool operations where callers can wait for results.
- How deep it goes
- Explains request handling through validation, tracing, timeouts, thread execution, and downstream deadlines.
- Examples
- Illustrates image categorization, a scheduling API, and a synchronous workflow handler.
- What you can do after
- Evaluate when synchronous execution fits and configure a workflow handler with validation, tracing, and timeouts.
Rust Servers, Services, and Apps
Synchronous programming executes an operation and waits for it to complete before continuing with subsequent work.
- How it is used
- Establishes a sequential baseline for comparing blocking work with multithreaded and async execution.
- How deep it goes
- Defines waiting at a function call and works through simulated file delays; stops short of synchronous implementation internals.
- Examples
- Uses a Rust main() calling simulated file reads with four- and two-second sleeps, producing a six-second total delay.
- What you can do after
- Diagnose/debug with it when sequential blocking calls make independent operations wait for one another.
Read how Rust Servers, Services, and Apps explains synchronous call →
Microservices Patterns, Second Edition
Synchronous code performs operations in a sequence that waits for each operation to complete before continuing.
- How it is used
- Uses synchronous request/response for service collaboration, saga orchestration, and distributed queries.
- How deep it goes
- Explains response timing, runtime coupling, retries, and idempotency through service flows and a saga state machine.
- Examples
- Illustrates order creation through a REST endpoint and a saga orchestrator invoking participant endpoints.
- What you can do after
- Evaluate synchronous response timing and apply retries and idempotency to service interactions.
Read how Microservices Patterns, Second Edition explains synchronous call →
Grokking Concurrency
A synchronous call is an I/O call that retains control until the operation completes and thereby creates a synchronization point.
- How it is used
- Coordinates ordered communication by making completion a point at which tasks can proceed.
- How deep it goes
- Defines synchronous calls and distinguishes control flow from blocking I/O, contrasting both with asynchronous alternatives.
- Examples
- Uses a phone conversation and a map-and-reduce data exchange to illustrate waiting and communication choices.
- What you can do after
- Evaluate synchronous versus asynchronous communication for tasks that exchange data.
Apache Kafka in Action
Synchronous communication is an interaction in which the sender and receiver coordinate during the same exchange and the sender waits for a response.
- How it is used
- Positions synchronous calls as a simple way to connect services while distinguishing immediate acknowledgement from asynchronous downstream processing.
- How deep it goes
- Explains service dependencies, cascading failures, and a button-click alternative, but does not detail HTTP implementation.
- Examples
- Contrasts dependent service calls with a button click that receives prompt confirmation while processing continues through Kafka.
- What you can do after
- Evaluate/understand when to acknowledge a request synchronously and when to let downstream work proceed asynchronously.
Build High Value Software Systems
Processing in which an operation waits for current work to complete before proceeding or returning.
- How it is used
- Maps how blocking service interactions contribute to end-to-end request latency and where architectural flow may be redesigned.
- How deep it goes
- Explains sequential waiting, accumulated latency, and design tradeoffs without detailing call implementation.
- Examples
- Uses a six-service checkout chain, including database contention and a slow external payment API.
- What you can do after
- Diagnose latency by tracing sequential service calls and identify steps that may not need to block the response.
Read how Build High Value Software Systems explains synchronous call →
F# in Action: A Revised Edition of Get Programming with F#
A synchronous operation runs to completion in the caller's execution flow and normally keeps its thread occupied while it waits.
- How it is used
- Provides a simple sequential flow for calls whose results the caller waits to receive.
- How deep it goes
- Explains sequential execution and blocking through a database lookup, without detailing synchronous API implementation.
- Examples
- Uses conversations, email validation, database lookups, and paired ExecuteSql and ExecuteSqlAsync methods.
- What you can do after
- Evaluate/understand when a simple synchronous flow fits and when blocking I/O makes an asynchronous API useful.
Read how F# in Action: A Revised Edition of Get Programming with F# explains synchronous call →
Latency
Synchronous processing is a processing model in which operations are handled sequentially and completion or errors are observed before subsequent processing proceeds.
- How it is used
- Contrasts sequential waiting with asynchronous processing as a way to hide latency.
- How deep it goes
- Explains sequential execution and blocking through a request loop, then distinguishes threaded concurrency from asynchronous I/O.
- Examples
- Uses a single-threaded socket server that receives, processes, and responds to one request at a time.
- What you can do after
- Evaluate where synchronous waiting delays work and compare it with threaded or asynchronous processing.
Clean Applications with Hexagonal Architecture
A synchronous call is an interaction in which the caller waits for the called system to return an answer.
- How it is used
- Carries boundary-crossing requests whose next step cannot continue without an answer.
- How deep it goes
- Explains call flow, waiting costs, and adapter mitigations; defers asynchronous request flows.
- Examples
- Uses an editor waiting for WriteFlow’s reopen decision before the CMS shows an article as reopened.
- What you can do after
- Evaluate whether a boundary interaction needs an answer before work can continue, then choose a synchronous call when it does.
Read how Clean Applications with Hexagonal Architecture explains synchronous call →
Quarkus in Action
Synchronous communication is an interaction in which the requesting application waits for a response from another system before continuing.
- How it is used
- Uses network calls that make a requesting microservice wait for another system's result.
- How deep it goes
- Defines waiting for a result and traces failure propagation, while deferring retries, timeouts, and circuit breakers.
- Examples
- Uses the Users, Reservation, Rental, Inventory, and Billing services as an interservice communication example.
- What you can do after
- Understand how service failures can propagate through a synchronous call chain to the original requester.
JavaScript in Depth
Execution in which JavaScript work runs to completion on the current thread before later work can proceed.
- How it is used
- Avoids unnecessary promise work in synchronous stream transforms and helps explain main-thread delays during diagnostics.
- How deep it goes
- Explains promise creation, microtask scheduling, and event-loop effects, then uses profiling to separate causes of delay.
- Examples
- Contrasts Node.js and Web Streams transforms and compares I/O latency with event loop delay.
- What you can do after
- Diagnose event-loop stalls by checking GC, profiling synchronous JavaScript, and comparing I/O latency with event loop delay.
Also covered in
- Elixir in Action, Third Edition
- C# Concurrency: Asynchronous and multithreaded programming
- Crack Any Codebase with AIIn early access (MEAP)
- "Looks Good to Me"
- Robotics for ProgrammersIn early access (MEAP)
- Fast by DefaultIn early access (MEAP)
- Amazon Web Services in Action, Third Edition: An in-depth guide to AWS
- MongoDB 8.0 in Action, Third Edition
- Code Like a Pro in Rust
- Modern Angular
- Django in Action
- Fast Python: High performance techniques for large datasets
What to know first
- RESTREST is an architectural style for distributed systems that organizes interactions around identifiable resources and their representations, using a uniform interface and constraints such as statelessness and cacheability.
- scalabilityScalability is the ability of a system or process to accommodate growth in workload, size, or demand while maintaining acceptable operation.
- contractA contract is an agreed specification of the conditions, expectations, rights, or obligations that govern behavior or interactions between parties or software components.
- gRPCgRPC is an open-source remote procedure call framework for defining services and invoking them across process or network boundaries, commonly using Protocol Buffers and HTTP/2.
Related concepts
- cudaMemcpyToSymbolincludes · cudaMemcpyToSymbol is a CUDA runtime API function that copies data to a named device symbol.
- integration eventcontrasts with · An integration event is a published event exchanged across service boundaries to communicate an occurrence, an operation result, or data relevant to other services.
- integration modekind of · An integration mode is a way for work or information to cross an architectural boundary, distinguished by waiting and responsibility for continuing work.
- asynchronous programmingcontrasts with · Asynchronous programming structures operations so that the initiating execution can continue or yield control without synchronously waiting for each operation to complete.
- asynchronous requestcontrasts with · An asynchronous request is an interaction in which a requester sends a request without waiting for its processing to complete or for an immediate response.
- asynchronous communicationalternative to · Asynchronous communication is the exchange of information without requiring participants to interact at the same time or the sender to wait for the receiver to process a message.
Questions about synchronous call
What is synchronous call?
A synchronous call is an invocation in which the caller waits for the operation to complete or return a result before continuing.
Which Manning books explain synchronous call?
Grokking Software Architecture, Designing AI Systems, Rust Servers, Services, and Apps, Microservices Patterns, Second Edition, Grokking Concurrency, Apache Kafka in Action, Build High Value Software Systems, F# in Action: A Revised Edition of Get Programming with F# and 4 more.
What should I know before learning synchronous call?
Manning books that teach synchronous call usually introduce REST, scalability, contract and gRPC first.
What is the difference between synchronous call and integration event?
A synchronous call is an invocation in which the caller waits for the operation to complete or return a result before continuing. An integration event is a published event exchanged across service boundaries to communicate an occurrence, an operation result, or data relevant to other services.
What kinds of synchronous call are there?
Kinds of synchronous call include cudaMemcpyToSymbol.
What is synchronous call a kind of?
Synchronous call is a kind of integration mode. An integration mode is a way for work or information to cross an architectural boundary, distinguished by waiting and responsibility for continuing work.
These guides are generated from the text of Manning books by Manning's knowledge graph and link to the sections they draw on. The full books are available on liveBook and at manning.com.











