Writing·

What does it cost to run 32 bidders in the bidstream?

Early notes on ARTF economics: running bidders as containers inside the auction, and what that costs in compute, memory and latency.

By Dennis Yurkevich

Exchanges have started running other companies' code inside the auction, as containers next to the impression. We wanted to know what that costs in compute, memory and latency, and how the cost changes as more bidders take part.

We built a small auction and ran container bidders on a single 8-vCPU cloud machine costing $0.40 an hour. With 32 fixed-bid bidders executing on every impression, the highest tested passing rate rose from 2,000 to 8,000 impressions per second when we batched requests. Both rates passed two 15-second repeats. At 8,000/s, compute costs about $0.03 per million impressions auctioned (offered to all 32 bidders, not bought), assuming traffic averages half that tested rate. These short runs do not establish sustained production capacity.

This is an early exploration with synthetic traffic and simple bidders. Below is what we built, what we measured, the optimisations that helped, and what we plan to test next.

Background: containers in the bidstream

In a conventional programmatic auction, the exchange sends a bid request over the internet to each buyer's platform and waits for a reply. Exchanges typically allow 100 ms or more for that round trip2.

IAB Tech Lab's Agentic Real-Time Framework (ARTF) v1.0, released in November 2025, standardises a different model. Partners package their logic as OCI containers and the exchange runs them inside its own infrastructure. ARTF v1.0 defines one call, GetMutations. Through it, a container proposes changes to a request or response, such as activating segments or deals, adjusting floors, or shading a bid price. It does not define a way for a container to submit a new bid.

Bidding from inside the exchange is happening anyway, outside the standard:

  • Index Exchange and Bedrock Platform: in April 2026, Bedrock deployed its bidder as a container inside Index Cloud, keeping full control of its decisioning and bidding. In September, PMG began a pilot using Bedrock as its bidding layer. Index reports about 4 ms response times for the containerised bidder, against up to 250 ms over the public cloud.
  • Data and curation containers: PubMatic (Decision Fabric), OpenX (OpenXBuild) and Magnite run or plan partner containers for enrichment and curation, with response windows of roughly 5–10 ms.

We are not designing a bid-submission protocol here. We assume bidders will run inside exchanges, as Bedrock already does. For cost, it makes little difference whether a container returns a bid or a mutation: an eligible container receives a request, runs its logic and must answer in time. That execution is what we measured.

The setup

One machine runs the auction and every bidder containerLOAD GENERATORSecond 8-vCPU VMSynthetic impressionsover HTTPSERVING MACHINEGCP c4-standard-88 vCPU30 GiB RAM$0.40 / hourrequestresultgRPCAuction workerRust1Find eligible bidders2Call them in parallel3Pick a winner by 50 msBIDDER CONTAINERSActive: 1–32 called per impressionLoaded: up to 96 held in memoryEACH BIDDERcontainerd · runc or gVisor2 vCPU · 512 MiB limit · 6.8 MiB image
Test architecture · one serving machine, one load generator

Everything that serves an auction runs on one Google Cloud c4-standard-8 virtual machine: 8 vCPUs (Intel Xeon Platinum 8581C), 30 GiB of RAM, Ubuntu 24.04. At the on-demand list price it costs $0.39534 an hour, or about $290 a month1. A second machine of the same size generates synthetic impressions, so load generation does not compete with the auction for CPU.

For each impression, the auction worker:

  1. Works out which bidders are eligible. Bidders exclude countries through blocklists, and excluded bidders are never called.
  2. Calls every eligible bidder over gRPC, in parallel.
  3. Collects the bids and returns a result before a 50 ms deadline2.

The worker is written in Rust. Each bidder is a small Rust service packaged as a 6.8 MiB OCI image. It is started by containerd and run under either runc (the standard Linux container runtime) or gVisor (a sandbox that puts a user-space kernel between the container and the host). We also ran the same binary as a plain process, with no container at all, as a control. Every bidder gets the same limits: 2 vCPUs and 512 MiB of memory.

We tested two kinds of bidder logic and kept each one fixed throughout:

  • Fixed bid: returns a constant price. This measures the cost of the plumbing alone.
  • Click model: a logistic regression that predicts click probability from 10 categorical fields: campaign plus 9 anonymised attributes. Each field is hashed into one of 65,536 buckets, so a prediction is 10 weight lookups, a sum and a sigmoid. We trained it on 40,000 rows of Criteo's public attribution dataset. The bid is the floor price plus the predicted score. It is a realistic shape of computation, not a tuned commercial model.

We varied three things: active bidders per impression (1 to 32, the bidders that actually run), loaded bidders (up to 96, the bidders held in memory), and traffic (impressions per second).

A test point counts as a pass only when 99% of auctions complete within 40 ms, at most 0.1% of auctions or bidder calls error, and the load generator drops no scheduled starts. Scheduling delay counts toward measured latency. Each point was repeated, and a point passes only when every repeat passes.

How big is 8,000 impressions a second?

Our test rates sound large but are small next to real exchange traffic. Large exchanges handle millions of requests per second. The traffic a particular buying platform receives depends on its QPS limits and which opportunities are routed to it3.

One test machine versus global platform trafficAverage requests per second, log scale. Company figures are global and count different things.1k10k100k1M10M100MRequests per secondOur test machine, passing rangeOur test machine, passing range: 2k to 10k per second2k–10kOpenX, stated capacity (2026)OpenX, stated capacity (2026): 3M per second3MIndex Exchange, slot requests (2022)Index Exchange, slot requests (2022): 3.1M per second3.1MThe Trade Desk, ad opportunities (2019)The Trade Desk, ad opportunities (2019): 9.1M per second9.1MPubMatic, impressions processed (2025)PubMatic, impressions processed (2025): 10.7M per second10.7M
Company figures from the sources listed under References, converted to per-second averages; stated capacity is labelled separately

The company figures are not like for like. PubMatic counts every ad request it processes, Index counts ad slots, and The Trade Desk counts opportunities it evaluates. They are global and overlap, because the same impression is often offered through several exchanges. The order of magnitude is the useful part.

These figures do not establish UK traffic or the number of machines needed to serve it. That would require the actual routed traffic, bidder mix, peaks and redundancy requirements.

Capacity: each active bidder costs CPU

At a fixed 5,000 impressions per second, measured CPU rose from 0.12 cores with no eligible bidders to 5.68 cores with eight. A finer sweep filled in the gap between eight and sixteen: CPU levelled off around 6.3 cores while latency rose. These counters cover the worker, bidders and container runtime, not total host utilisation.

CPU use and timely throughput as more bidders run0 active bidders: 0.12 CPU cores, 5000 timely impressions per second, 3 of 3 repeats passed. 1 active bidders: 0.76 CPU cores, 4998 timely impressions per second, 3 of 3 repeats passed. 2 active bidders: 1.54 CPU cores, 4997 timely impressions per second, 3 of 3 repeats passed. 4 active bidders: 2.91 CPU cores, 4999 timely impressions per second, 3 of 3 repeats passed. 6 active bidders: 4.27 CPU cores, 4998 timely impressions per second, 3 of 3 repeats passed. 8 active bidders: 5.68 CPU cores, 4998 timely impressions per second, 3 of 3 repeats passed. 9 active bidders: 6.13 CPU cores, 4996 timely impressions per second, 3 of 3 repeats passed. 10 active bidders: 6.26 CPU cores, 4996 timely impressions per second, 3 of 3 repeats passed. 11 active bidders: 6.30 CPU cores, 4996 timely impressions per second, 3 of 3 repeats passed. 12 active bidders: 6.34 CPU cores, 4995 timely impressions per second, 3 of 3 repeats passed. 13 active bidders: 6.36 CPU cores, 4994 timely impressions per second, 2 of 3 repeats passed. 14 active bidders: 6.33 CPU cores, 4116 timely impressions per second, 0 of 3 repeats passed. 16 active bidders: 6.18 CPU cores, 3189 timely impressions per second, 0 of 3 repeats passed. 20 active bidders: 5.81 CPU cores, 2276 timely impressions per second, 0 of 3 repeats passed. 24 active bidders: 5.40 CPU cores, 1461 timely impressions per second, 0 of 3 repeats passed. 32 active bidders: 5.09 CPU cores, 992 timely impressions per second, 0 of 3 repeats passed.CPU use and timely throughput as more bidders run5,000 impressions/s · 32 loaded click-model bidders · runcMean and range of three 60-second repeats · × at least one repeat failed a checkCPU cores used024688 vCPU provisioned0 active: 0.12; range 0.12–0.12; 3/3 repeats passed1 active: 0.76; range 0.76–0.77; 3/3 repeats passed2 active: 1.54; range 1.53–1.55; 3/3 repeats passed4 active: 2.91; range 2.88–2.94; 3/3 repeats passed6 active: 4.27; range 4.25–4.30; 3/3 repeats passed8 active: 5.68; range 5.62–5.71; 3/3 repeats passed9 active: 6.13; range 6.11–6.15; 3/3 repeats passed10 active: 6.26; range 6.24–6.28; 3/3 repeats passed11 active: 6.30; range 6.27–6.31; 3/3 repeats passed12 active: 6.34; range 6.33–6.35; 3/3 repeats passed13 active: 6.36; range 6.35–6.36; 2/3 repeats passed14 active: 6.33; range 6.30–6.36; 0/3 repeats passed16 active: 6.18; range 6.11–6.22; 0/3 repeats passed20 active: 5.81; range 5.69–5.88; 0/3 repeats passed24 active: 5.40; range 5.28–5.49; 0/3 repeats passed32 active: 5.09; range 5.03–5.19; 0/3 repeats passedImpressions completed within 50 ms / second01,0002,0003,0004,0005,0005,000 offered / second0 active: 5000; range 4999.91–4999.98; 3/3 repeats passed1 active: 4998; range 4996.58–4999.97; 3/3 repeats passed2 active: 4997; range 4996.53–4996.53; 3/3 repeats passed4 active: 4999; range 4996.54–4999.92; 3/3 repeats passed6 active: 4998; range 4996.50–4999.86; 3/3 repeats passed8 active: 4998; range 4996.50–4999.84; 3/3 repeats passed9 active: 4996; range 4996.40–4996.51; 3/3 repeats passed10 active: 4996; range 4996.27–4996.36; 3/3 repeats passed11 active: 4996; range 4996.20–4996.34; 3/3 repeats passed12 active: 4995; range 4991.75–4996.21; 3/3 repeats passed13 active: 4994; range 4991.82–4995.86; 2/3 repeats passed14 active: 4116; range 3400.58–4978.89; 0/3 repeats passed16 active: 3189; range 2989.11–3304.52; 0/3 repeats passed20 active: 2276; range 1955.64–2463.22; 0/3 repeats passed24 active: 1461; range 1172.37–1688.05; 0/3 repeats passed32 active: 992; range 928.02–1104.11; 0/3 repeats passed04810121416202432Active bidders per impression
26 October follow-up · Three 60-second repeats per point, mean and range shown · 32 bidders loaded · Crosses mark at least one failed repeat

Twelve active bidders passed all three repeats. Thirteen passed two; the third breached the latency limit. Fourteen and above failed every repeat. At sixteen, only about 3,000–3,300 impressions per second completed within 50 ms. At thirty-two, that fell to about 930–1,100.

The plateau does not show that all eight host CPUs were consumed. It shows the service reaching a limit: measured CPU stopped rising while response times and errors worsened. Coordinating the bidders may be the bottleneck; we still need to test that. Two overloaded 24-bidder windows also dropped scheduled generator starts; those failures remain visible in the measurements.

So the traffic one machine can carry falls as the number of active bidders rises. With the fixed-bid bidders, the highest tested rate where every repeat passed was:

Active bidders per impressionHighest passing rateBidder calls per second
88,000 impressions/s64,000
164,500 impressions/s72,000
322,000 impressions/s64,000

The click model gave almost the same limits (4,000/s at 16 active). In a matched comparison on the same machine, it used 11–12% more CPU than the fixed bid. At this model size, the cost of the model is small next to the cost of sending each request to a bidder and getting the answer back.

Isolation: runc and gVisor have different costs

We ran the same bidder binary three ways: as a plain Linux process, as a container under runc, and as a container under gVisor. runc and native processes had similar CPU use and latency in this test. This comparison used click-model bidders at 2,000 impressions per second, with 16 bidders loaded and two 20-second repeats per point.

runc and native CPU use were similar; gVisor used up to 2.4x moreCPU cores at 2,000 impressions/s, click-model bidders, 16 loaded. All points passed.Plain processruncgVisor024681 active4 active16 activeActive bidders per impressionPlain process, 1 active: 0.27 cores0.3runc, 1 active: 0.26 cores0.3gVisor, 1 active: 0.62 cores0.6Plain process, 4 active: 1.18 cores1.2runc, 4 active: 1.18 cores1.2gVisor, 4 active: 2.33 cores2.3Plain process, 16 active: 4.11 cores4.1runc, 16 active: 4.10 cores4.1gVisor, 16 active: 6.70 cores6.7
Two 20-second repeats per point, mean shown · CPU includes the container runtime's own processes

gVisor is a different matter. It intercepts the container's system calls in a user-space kernel, which gives a stronger boundary for untrusted code and costs CPU on every request. At 16 active bidders:

Plain processruncgVisor
CPU cores4.14.16.7
99th-percentile latency4.3 ms4.3–4.5 ms11.9–12.3 ms
Worker and bidder memory22 MiB24 MiB288 MiB

A separate fixed-bid sweep, with 32 bidders loaded and 16 active, reached a highest tested passing rate of 4,500/s under runc and 2,500/s under gVisor. Each point used two 15-second repeats. Native-process capacity was not swept. These are observed passing rates for this workload, rather than exact capacity limits.

The isolation boundary affects the resource budget, but these host-networked lab configurations were not security-qualified for hostile buyer code.

Memory and cold starts

CPU tracks the bidders that run. Memory tracks the bidders that are loaded, whether they run or not. We gave each bidder 64 MiB of private state, kept 4 bidders active per impression, and increased the number registered on the machine.

Idle bidders still hold memory: 96 loaded used 6.5 GiB, 16 used 1.2 GiBWorker, bidder and runtime memory (GiB). Each bidder holds 64 MiB of state. 4 active per impression at 1,000/s; all points passed.02468326496Registered biddersAll registered bidders loaded, 32 registered: 2.22 GiB2.2All registered bidders loaded, 64 registered: 4.36 GiB4.4All registered bidders loaded, 96 registered: 6.50 GiB6.5All loadedOnly bidders that can be eligible loaded (16), 32 registered: 1.16 GiB1.2Only bidders that can be eligible loaded (16), 64 registered: 1.16 GiB1.2Only bidders that can be eligible loaded (16), 96 registered: 1.16 GiB1.2Only eligible loaded
Two 15-second repeats per point for each bidder type; values nearly identical across them · proportional set size (PSS)

In this test only 16 of the registered bidders could ever be eligible for the traffic we sent. Loading only those 16 kept memory at 1.2 GiB however many were registered. Loading all 96 used 6.5 GiB, with no change in the work done per impression.

The obvious response is to unload idle bidders and start them when needed. The catch is start-up time.

Every cold start took longer than the 50 ms auctionTime from start command to first successful health check, image already on disk. Range over 10 starts. Log scale.10 ms100 ms1.0 s10.0 s50 ms auction deadlinePlain processPlain process: 54 ms to 62 ms54 ms–62 msruncrunc: 101 ms to 109 ms101 ms–109 msgVisorgVisor: 5.2 s to 5.8 s5.2 s–5.8 s
Five starts per runtime for each bidder type · each bidder initialises 64 MiB of state before reporting ready

No runtime came back in time to bid on the impression that triggered the start. Even a plain process took about 55–62 ms. A runc container took about 100–110 ms, and gVisor took over 5 seconds. These times exclude downloading the image. So an exchange that unloads bidders to save memory will miss auctions while they restart, unless it starts them ahead of demand.

Optimisations: change the platform, not the bidder

Next we left both bidders' logic untouched and changed only how the worker delivers requests to them. Batching was the largest gain. Instead of one gRPC call per impression per bidder, the worker groups the requests waiting for the same bidder into a single call. Every bidder decision still runs; there are just fewer calls to make.

Batching kept 4x more traffic flowing at 32 bidders per impressionHighest tested impressions/s where every repeat passed. Fixed-bid bidder, same 8-vCPU machine.02,5005,0007,50010,0001481632Active bidders per impressionBaseline, 1 active: 8,000/sBaseline, 4 active: 8,000/sBaseline, 8 active: 8,000/sBaseline, 16 active: 4,500/sBaseline, 32 active: 2,000/sBaseline 2,000/sBatched, 4 active: 5,000/sBatched, 8 active: 10,000/sBatched, 16 active: 10,000/sBatched, 32 active: 8,000/sBatched 8,000/sBatched was only tested up to 5,000/s at 4 active, so its lower point there is a test limit, not a slowdown.
32 bidders loaded, runc · two 15-second repeats per point; a point counts only when both pass

With 32 active fixed-bid bidders, batching took the highest tested passing rate from 2,000 to 8,000 impressions per second on the same machine. The click model reached 7,000/s with batching.

We ran a longer comparison at 5,000/s with 32 active bidders: three 60-second repeats per setup. For fixed bids, the unbatched setup failed all three (99th-percentile latency 119.4–127.1 ms), while batching passed all three (5.7–6.0 ms). For the click model, the corresponding ranges were 122.7–129.5 ms and 6.6–7.2 ms, again with all baseline repeats failing and all batched repeats passing. These longer runs confirm the comparison at 5,000/s; the 8,000/s result comes from the shorter sweep.

Batching gains most when there is a lot to batch. At 32 active bidders and 2,000/s, each call carried 3.7–3.8 requests on average; at 4 active, barely more than one.

We tested each change on its own at 16 active bidders and 2,000 impressions/s:

ChangeCPU change, fixed bidCPU change, click model
Batch requests to each bidder-39%-40%
Run four bidders per process-22%-23%
Pin work to specific CPUs-13%-11%
Precompute which bidders are eligible-3%+1%
Parse each request once, not per bidder-3%0%
Lower the per-bidder concurrency limit-3%-2%

Running four bidders in one process saves CPU but removes the isolation between them. It is only an option for bidders from the same owner. The last three changes made little difference at this scale. CPU pinning reduced CPU use but increased worst p99 latency from 5.14 to 6.01 ms for fixed bids and from 5.24 to 5.84 ms for the click model; both settings still passed.

We also split traffic across two machines. A 4,000/4,000 split of 8,000 impressions per second passed; a 6,000/2,000 split failed every run, even though the two machines together had the same total capacity. Spare capacity on the quieter machine did not help the busier one.

The economics: what does a bidder cost?

The machine costs $0.39534 an hour whether it is busy or idle. Its cost per impression therefore depends on how much traffic it serves on average. Real traffic rises and falls through the day, so we assume the machine averages half its highest tested passing rate. This example uses fixed-bid bidders:

32 active biddersHighest tested passing rateCompute per million impressionsAllocated compute per million bidder evaluations
Unbatched2,000/s$0.11$0.0034
Batched8,000/s$0.027$0.00086

The last column divides the whole machine bill equally among 32 identical, equally active bidders. Each impression produces one evaluation per bidder. This is an average allocation, not a measured marginal cost or a customer price.

Whether that is cheap depends on what the bidder earns from those requests. Three terms matter:

  • CPM: the price paid per 1,000 impressions won. Open-market display CPMs are around $1–2; for example, $1.21 in the US in January 2023 (Operative) and a £1.05 average publisher eCPM in the UK in 2024 (Pubstack).
  • Bid rate: the share of requests a bidder bids on. Index Exchange notes that DSPs often bid on fewer than 5% of the opportunities they receive.
  • Win rate: the share of requests that end in an impression the bidder pays for. This is the number that matters here, because the bidder's code runs on every request but media is bought only on wins.

So the compute cost relative to media spend is: cost per request ÷ (win rate × CPM ÷ 1,000).

Allocated compute rises as wins become rarerCompute cost as a share of the bidder's media spend, $1 CPM, 32 active bidders, machine at 50% average load. Log scales.example DSPwin rates0.0001%0.001%0.01%0.1%1%10%100%1,000%compute equals media spend1 in 1,000,0001 in 100,0001 in 10,0001 in 1,0001 in 1001 in 10Requests won by the bidder (win rate)Unbatched, 2,000 impressions/s, win rate 1 in 1,000,000: compute 3.4e+2% of spendUnbatched, 2,000 impressions/s, win rate 1 in 100,000: compute 34% of spendUnbatched, 2,000 impressions/s, win rate 1 in 10,000: compute 3.4% of spendUnbatched, 2,000 impressions/s, win rate 1 in 1,000: compute 0.34% of spendUnbatched, 2,000 impressions/s, win rate 1 in 100: compute 0.034% of spendUnbatched, 2,000 impressions/s, win rate 1 in 10: compute 0.0034% of spendUnbatchedBatched, 8,000 impressions/s, win rate 1 in 1,000,000: compute 86% of spendBatched, 8,000 impressions/s, win rate 1 in 100,000: compute 8.6% of spendBatched, 8,000 impressions/s, win rate 1 in 10,000: compute 0.86% of spendBatched, 8,000 impressions/s, win rate 1 in 1,000: compute 0.086% of spendBatched, 8,000 impressions/s, win rate 1 in 100: compute 0.0086% of spendBatched, 8,000 impressions/s, win rate 1 in 10: compute 0.00086% of spendBatched
Calculated from measured capacity and the machine's list price · CPM and win rates are assumptions; shaded band from worked examples in O'Kelley (2016)

At a $1 CPM with batching, a bidder that wins 1 request in 1,000 spends about $1 on media per million requests and is allocated $0.00086 in compute: 0.09%. At 1 win in 100,000 that rises to 8.6%. At 1 in a million, compute is 86% of media spend; without batching it is more than three times the spend. A bidder that receives a broad stream of traffic but rarely buys still consumes compute on every evaluation, so filtering what reaches a bidder matters as much as how fast it runs.

These figures cover the serving machine only. Storage, networking, logging, redundancy and operations come on top.

What we're working on next

  1. Dedicated hardware. Cloud vCPUs are shared with other tenants. Repeating the tests on bare metal removes that source of variation from latency and capacity results.
  2. Faster cold starts. Every start we measured missed the 50 ms deadline. Options we want to measure on the same harness:
    • Warm pools that keep a few spare instances ready.
    • Firecracker microVMs. They are specified to boot in 125 ms or less, and snapshots can restore in a few milliseconds. However, one study measured over 200 ms before a restored function finished its first run (FaaSnap).
    • WebAssembly runtimes such as Wasmtime, which reported about 5 microseconds to instantiate a particular precompiled module in a 2022 benchmark, with loading and preparation done beforehand. That measures module instantiation, not a complete bidder cold start.
  3. Cheaper strong isolation. gVisor roughly halved the highest passing rate in the fixed-bid comparison above. Firecracker and WebAssembly offer different trade-offs between isolation and overhead, and we want numbers for both.
  4. A realistic bidder mix. Real bidders carry larger models and more state. In an earlier test, a deliberately CPU-heavy bidder used about four times the CPU of our click model. Cost needs to be estimated per class of bidder, not per bidder.
  5. Fleets. A scheduler that decides which bidders run on which machine and spreads traffic evenly, with a load balancer in front. Our two-machine test showed uneven placement fails before total capacity runs out.
  6. Longer runs and bursts. Hours rather than minutes, with repeated traffic spikes. After one spike, latency recovered before memory returned to its earlier level.
  7. The full cost. Network, storage, logging, monitoring and redundancy on top of serving compute.

If you run containers inside an exchange, or bid from one, we would like to compare numbers.

Notes

  1. Machine price. Google Cloud on-demand list price for c4-standard-8 in us-central1 (Iowa), $0.39534 per hour, checked 23 October 2026 (pricing). Disk and network are extra. The load generator is not counted in serving cost.

  2. The 50 ms deadline is our choice, not a standard. OpenRTB's tmax field lets each exchange set its own limit; the OpenRTB 2.6 spec uses 120 ms as an example. Google Authorized Buyers deadlines typically range from 80 to 1,000 ms, and Index Exchange sets a minimum tmax of 100 ms. ARTF sets no fixed budget. Those limits include an internet round trip, which a bidder inside the exchange does not need, so we used a tighter 50 ms deadline and required 99% of auctions to finish within 40 ms. Exchanges quote 4–10 ms windows for their container products. In our passing tests, the 99th percentile was typically 3–30 ms.

  3. Traffic visible to a buying platform. Index Exchange uses an illustrative estimate of 10 million QPS across the open internet, then explains that individual DSPs might cap reception at 1–3 million QPS. The 10 million figure is not traffic received by one DSP. Neither this estimate nor a country's share of digital ad spend establishes its share of routed bid requests.

  4. How we measured. Latency runs from when each request was scheduled to be sent, so queueing under load counts. CPU comes from Linux cgroup counters, cross-checked against per-process clocks, and includes the container runtime's own processes. Memory is proportional set size (PSS), which splits shared pages between the processes using them. Bidders use host networking; TLS and Kubernetes are not in the measured path. Traffic and inventory are synthetic.

References

Standards and specifications: ARTF v1.0 · OpenRTB 2.6 · OCI runtime spec

Software: containerd · runc · gVisor · gRPC · Firecracker · Wasmtime instantiation performance

Containers in exchanges: Bedrock in Index Cloud (Apr 2026) · PMG pilot (Sep 2026) · Index Cloud efficiency (Oct 2026) · PubMatic Decision Fabric (Jun 2026) · OpenXBuild · Magnite (Aug 2026)

Volumes: PubMatic FY2025 results (336.8tn impressions processed) · Index Exchange, 270bn slot requests a day (2022) · OpenX, 3M QPS (Sep 2026) · The Trade Desk 2019 10-K (790bn opportunities a day) · Index Exchange on QPS

Prices and win rates: Operative, US open-market CPM · Pubstack UK benchmark · O'Kelley, win-rate examples (2016)

Cold starts: Firecracker, NSDI 2020 · FaaSnap, EuroSys 2022

Model data: Criteo attribution dataset (CC BY-NC-SA 4.0)

← All writingArc
Speak to a founderPick a time.Open in a new tab ↗