The choice between transaction Bundles and per-resource POSTs sounds like a small implementation detail until your pipeline starts pushing a few thousand resources a minute. At that point the answer stops being a matter of style and starts being a matter of whether the FHIR server stays up. The short version: both patterns work, and the right one depends on what shape of pressure your ingestion path is actually under. The longer version is below.
For broader context across the form and FHIR layers that consume these writes, the FHIR fundamentals collection covers the surrounding pieces.
What Each Pattern Actually Does
A FHIR transaction Bundle wraps several resources into one POST and asks the server to commit them atomically. Either every resource lands or none do. Inter-resource references can be resolved inside the Bundle using urn:uuid: placeholders, which is genuinely useful when you are writing a Patient, an Encounter, and a few Observations that have to point at each other.
A series of individual POSTs treats each resource as its own write, with its own success or failure. There is no atomicity between resources. References between resources have to be resolved by the writer beforehand, often by writing the parent and reading its server-assigned ID before sending the children.
Where Bundles Win
Bundles win when atomicity matters. An encounter with several observations should either fully land or not land at all; a partial write that drops the Observations but keeps the Encounter is a clinical-record bug waiting to surface. The Bundle is the cleanest way to enforce this without bolting on a custom transaction manager.
Bundles also reduce per-write HTTP overhead. One POST instead of twelve is meaningful on a high-latency link, especially when the FHIR server is on the other side of a region boundary or a VPN tunnel. The wire savings show up clearly under load.
Where Individual POSTs Win
Per-resource POSTs win when the writer needs fine-grained retry behaviour. A single failed POST inside a Bundle aborts the whole Bundle; the retry has to replay the entire group. With per-resource writes, only the failed resource retries, which is friendlier to a pipeline that is already replaying retransmits from upstream.
Per-resource writes also win for streaming-shaped pipelines where the resources arrive at different times. Holding a partial Bundle in memory while waiting for the next segment is a recipe for memory bloat and lost state when the worker restarts.
The Throughput Question
This is where most teams expect a clean answer and do not get one. On a fast FHIR server with batched Bundles of ten to fifty resources each, the throughput of Bundle writes usually beats per-resource POSTs by a meaningful margin. On a slower or transactional FHIR server, the locking cost of large Bundles can drag throughput below the per-resource path, especially when the same Patient appears in many concurrent Bundles. Tools like Interbox bundle parallel writes with deduplication to minimize FHIR server load into the standard worker chain, which is one way to keep the per-resource path fast without inviting the duplicate-write problem that usually comes with it.
For NHS-style form workflows that feed downstream writes, the patterns in top 5 SDC form builders for NHS-style workflows in 2026 cover the form-side shape, and the complete guide to FHIR form builders for UK healthcare in 2026 sets the broader context.
The Practical Answer
For most ingestion pipelines in 2026, the right pattern is moderate-size transaction Bundles (often five to twenty related resources each) wrapped in a retry strategy that splits on failure. Per-resource POSTs are the right fallback for streaming feeds where the resources do not naturally group, or for older FHIR servers where transaction locking is genuinely painful.
Sources
- HL7 FHIR R4 spec - Bundle resource - batch vs transaction processing semantics and atomicity rules