Push vs pull in medical imaging workflows
- Medical imaging modalities and PACS push studies outward via C-STORE immediately after acquisition rather than exposing pull APIs.
- C-MOVE and C-GET exist for pulling data, but C-GET is rarely supported and C-MOVE needs a reverse inbound connection.
- The IHE Scheduled Workflow profile has modalities push images to PACS automatically once an exam completes.
- Hospital firewalls block inbound connections, so push architectures align with outbound-only NAT and firewall policies.
- DICOMweb STOW-RS is the push equivalent of C-STORE over HTTP, while QIDO-RS and WADO-RS are pull-based query and retrieve operations.
Software engineers entering healthcare often assume medical imaging systems work like modern web applications. In typical web architectures, client systems query REST endpoints or storage records on demand whenever they need data. When building a cloud diagnostic tool or AI pipeline, developers frequently ask how to query a hospital archive. In production healthcare environments, that approach encounters a fundamental architectural reality. Medical imaging systems operate almost exclusively on an event-driven push model. Modalities (such as CT and MRI scanners) and Picture Archiving and Communication Systems (PACS) push studies outward to designated destinations immediately after acquisition. They rarely expose pull interfaces to external systems.
Understanding why healthcare workflows rely on push semantics—and how legacy DICOM protocols compare with DICOMweb standards—is essential for designing reliable cloud ingestion pipelines.
How do push and pull workflows work in classic DICOM?
In classic DICOM (the DIMSE protocol running over TCP), the distinction between push and pull maps to specific service classes defined in DICOM PS3.4.
Push Model (C-STORE):
[Modality / PACS] ---------------- C-STORE Request ---------------> [Receiver]
<--------------- C-STORE Response --------------
Pull Model (C-MOVE):
[Querying Client] ---------------- C-MOVE Request ---------------> [PACS Archive]
(Move destination: "MY_SCU")
[PACS Archive] ---------------- C-STORE Request ---------------> [Querying Client]
<--------------- C-STORE Response --------------
[Querying Client] <--------------- C-MOVE Response --------------- [PACS Archive]
The push pattern: C-STORE
In a push workflow, the system holding the data acts as a Service Class User (SCU) for Storage. It initiates a network connection to the receiving system, which acts as a Service Class Provider (SCP).
- The sender requests a DICOM association with the receiver.
- The sender transmits one or more instances using the
C-STORE-RQcommand. - The receiver accepts and validates each instance, acknowledging with a
C-STORE-RSPstatus code. - The sender releases the association when the transfer finishes.
The receiver never asks for the data. The transfer is initiated entirely by the source when an operational event occurs, such as a technologist completing an examination.
The pull pattern: C-MOVE and C-GET
Classic DICOM provides two mechanisms for retrieving data on demand:
- C-MOVE: A client sends a
C-MOVE-RQto an archive with query filters and a destination AE title. The archive does not return image data over the query connection. Instead, it opens a secondary connection back to the designated destination to transmit files usingC-STORE. - C-GET: A client sends a
C-GET-RQto an archive. Unlike C-MOVE, the archive transmits the requested instances back over the existing connection using embedded C-STORE sub-operations.
While C-GET avoids opening a secondary connection, it is rarely supported across hospital PACS installations due to implementation complexity and resource contention. C-MOVE remains the dominant pull protocol in local hospital networks, but its requirement for reverse inbound connections makes it impractical across network perimeters.
Why do clinical imaging workflows push data instead of pulling?
The dominance of push architecture in medical imaging is not accidental. It stems from clinical safety requirements, hardware constraints on imaging equipment, and network security boundaries.
1. The IHE Scheduled Workflow profile
Clinical radiology workflows follow standardized integration profiles established by Integrating the Healthcare Enterprise (IHE). Under the IHE Radiology Scheduled Workflow (SWF) profile:
- A patient arrives, and their order is scheduled in the Radiology Information System (RIS).
- The scanner queries the RIS using DICOM Modality Worklist (MWL) to obtain demographic details and procedure identifiers.
- The technologist performs the scan.
- As soon as the procedure completes, the modality issues an IHE transaction (
RAD-8: Modality Images Stored) pushing the acquired instances to the PACS archive usingC-STORE. - The modality sends a Storage Commitment request (
RAD-10) confirming the PACS has safely written the images to durable storage.
This sequence ensures that images move into the clinical record immediately upon acquisition. No human or automated system needs to periodically poll modalities to check whether a scan finished.
2. Modality storage and compute limits
Medical scanners are specialized real-time computing systems designed for image acquisition, reconstruction, and patient safety. A multi-detector CT scanner can generate thousands of slices per examination.
Modality local disks are engineered as staging buffers, not permanent archives. To prevent local disks from filling during busy clinical shifts, modalities must offload studies immediately to a central destination. Allowing external software to pull data whenever convenient would force scanners to maintain large local caches and service arbitrary retrieval queries, competing with real-time acquisition tasks.
3. Network perimeter security and NAT
Hospital network perimeters enforce strict security policies. As detailed in our guide on why hospitals cannot open inbound ports for cloud services, clinical firewalls block external inbound connection attempts.
In a pull architecture, an external cloud platform must initiate an inbound connection into the hospital network:
- With C-MOVE, the cloud service must reach the PACS on an internal port. The PACS must then open a secondary connection back to the cloud.
- With C-GET or DICOMweb WADO-RS, the cloud service still needs an open inbound path through the firewall into the internal PACS listener.
Hospital IT teams reject inbound firewall rules to protect vulnerable medical equipment from internet-borne attacks. Conversely, outbound connections initiated from inside the hospital LAN through Network Address Translation (NAT) gateways align naturally with firewall policies. A push architecture allows the hospital system to initiate the connection outward to a cloud endpoint.
| Dimension | Push Architecture (C-STORE / STOW-RS) | Pull Architecture (C-MOVE / WADO-RS) |
|---|---|---|
| Connection Origin | Hospital modality/PACS initiates outbound connection | External consumer initiates inbound connection |
| Firewall Compatibility | Traverses enterprise NAT state tables cleanly | Requires inbound firewall holes or complex VPN tunnels |
| Latency to Consumer | Real-time; instances arrive as soon as acquired | Polling latency or delayed manual dispatch |
| Archive Resource Load | Single sequential stream per study | Heavy query/retrieve load and indexing overhead |
| Modality Disk Impact | Local buffer cleared immediately after storage commit | Modality must retain studies until external pull completes |
How does DICOMweb handle push vs pull?
The DICOMweb standard (DICOM PS3.18) translates medical imaging protocols into web standards built over HTTP and REST. DICOMweb maintains the functional separation between push and pull operations:
Push: STOW-RS (Store Over the Web)
POST /studies HTTP/1.1
Host: cloud.example.com
Content-Type: multipart/related; type="application/dicom"; boundary=boundary123
--boundary123
Content-Type: application/dicom
<binary DICOM payload>
--boundary123--
- STOW-RS (Push): The hospital system sends an HTTP
POSTrequest containing binary DICOM instances packaged as a MIMEmultipart/relatedpayload (defined in RFC 2387). The sender initiates the HTTP connection outward to the receiver’s HTTPS endpoint. - QIDO-RS and WADO-RS (Pull): A client issues HTTP
GETrequests to query metadata (QIDO-RS) or retrieve specific studies, series, or instances (WADO-RS).
Using WADO-RS to retrieve studies from inside a hospital faces the exact same network barrier. A cloud client cannot send an HTTP GET request directly to an on-premises PACS sitting behind an enterprise firewall.
Consequently, modern hybrid cloud workflows use STOW-RS as an outbound push mechanism. Scanners or on-premises gateways push studies out to cloud endpoints over HTTPS, preserving the security benefits of outbound-only communication while using standard web protocols. You can explore how these protocols compare in depth in our guide to DICOM C-STORE vs DICOMweb STOW-RS.
Architectural implications for cloud ingestion systems
Designing a cloud ingestion pipeline around push semantics requires a different architecture than traditional pull-based ETL systems.
Clinical Network (LAN) Public Cloud
+---------------------+ +---------------------------------------+
| Modality / Gateway | | Ingestion Endpoint (HTTPS) |
| | | |
| Acquires study | | Accepts incoming STOW-RS push |
| Initiates push |--- Outbound Push --->| Validates client authentication |
| Clears local disk | | Streams instances to object storage |
+---------------------+ | Triggers downstream processing queue |
+---------------------------------------+
1. Build webhook receivers, not scheduled polling workers
In a pull system, backend services run cron jobs or worker queues that query external archives at regular intervals. In an event-driven push system, your ingestion layer must act as a high-availability webhook receiver.
Your receiver must expose an authenticated endpoint ready to accept incoming transfers at any time. When a hospital technologist finishes a trauma scan at 2:00 AM, the modality pushes that study immediately. The ingestion service must handle incoming bursts without dropping connections or forcing modalities into backoff states.
2. Stream large multipart payloads
DICOM studies vary widely in size. A chest X-ray may contain one or two 15 MB files. An automated breast ultrasound or high-slice CT can exceed 2 GB across thousands of individual instances.
A push receiver accepting STOW-RS payloads must not buffer entire multi-gigabyte transfers in application memory. Ingestion services must stream multipart byte streams directly to durable cloud object storage or processing workers. Buffering multi-gigabyte payloads in memory causes out-of-memory crashes when multiple modalities transmit large studies simultaneously.
3. Handle asynchronous study arrival
Because studies are pushed instance-by-instance or series-by-series, cloud ingestion systems cannot assume a study arrives as a single atomic package.
During a typical C-STORE or STOW-RS transmission:
- Instances may arrive over multiple successive HTTP requests or DICOM associations.
- Network interruptions may cause partial transfers that resume minutes later.
- Separate series from the same study (such as scout views and contrast phases) may finish acquisition at different times.
Downstream processing pipelines—such as AI inference engines or viewer indexing systems—must remain event-aware. Rather than triggering processing on the first received instance, your architecture should track incoming instance counts against study metadata, or apply debounce windows before invoking heavy downstream workflows.
4. Provide fast, deterministic acknowledgments
Medical devices and PACS gateways track transfer success using standard response codes:
- In DIMSE C-STORE, a status of
0x0000indicates success. - In DICOMweb STOW-RS, an HTTP
200 OKor202 Acceptedresponse with an XML or JSON response dataset indicates the server accepted the instances.
If your receiver delays its HTTP response while performing slow synchronous operations (such as running machine learning models or transcoding images), the sender’s network socket will time out. When a timeout occurs, the modality marks the transfer as failed and retries, creating duplicate data transfers and network congestion.
Your ingestion receiver should perform authentication, validate the payload structure, persist or stream the instances securely, and acknowledge receipt immediately. Long-running analytical tasks must execute asynchronously in decoupled background queues.
Summary
Medical imaging systems push data upon acquisition. Clinical workflows require real-time handoffs, scanners need immediate local buffer clearance, and firewalls enforce strict outbound-only perimeters.
When building healthcare integrations:
- Expect push notifications: Design your architecture around inbound webhook receivers rather than polling workers.
- Embrace outbound hospital traffic: Receive data pushed over outbound connections from hospital systems rather than attempting to pull across clinical firewalls.
- Stream binary data: Process multipart DICOM streams without accumulating multi-gigabyte studies in receiver memory.
- Decouple receipt from processing: Acknowledge transfers quickly so clinical senders can complete their storage handoffs without timing out.
Dicomly builds infrastructure for healthcare software teams that receive DICOM studies from hospitals. Why we built Dicomly →