A simulator is only as honest as its assumptions, so RodGrid's traffic simulator publishes its own: the model is deterministic, its capacity numbers are shown inside the product, and this post walks through how it works.
A spreadsheet over the graph
There is no AI involved, and it needs no server. The simulator is a deterministic, steady-state calculator: you give it a requests-per-second number and it pushes that load through the diagram in topological order, reporting per-node utilization, latency, and error rate plus Grid-level totals. Run it twice on the same Grid and you get the same answer — which is what lets challenges grade against it fairly.
Capacity comes from the component type
Every node resolves to a capacity profile keyed by its semantic role — load balancer, cache, application service, relational database, queue, model API, and so on. Each profile is a handful of numbers: sustainable requests per second per instance, base latency, and a baseline error rate.
The absolute numbers are deliberately round, order-of-magnitude anchors. What teaches is the ratios — a cache absorbs roughly ten times what a relational database does, so it can take read load that would swamp the database, and with a good hit rate only the misses reach it. The in-product “Model assumptions” table is generated live from the same registry the engine reads, so the published numbers can never drift from the ones actually used.
Diagram components: Application Service, Redis, PostgreSQL.
Turn the simulator on over a Grid like this and raise traffic: the cache soaks up reads at ~10× the database's capacity, and the misses that fall through are what the database actually has to survive.
How load propagates
- Nodes are classified by role into a small set of behaviors: entry points, splitters (load balancers and gateways), caches, stores, async channels (queues/streams), services, and external dependencies. Shapes and annotation nodes are inert — they simply don't simulate.
- A node forwards only what it can actually serve: the minimum of what arrives and its capacity times its replica count. Each edge can also state calls per upstream request, so an occasional model call does not incorrectly receive every request. No phantom throughput downstream of a bottleneck.
- Traffic above a node's capacity goes unanswered, all of it, and counts against availability — no invented split into queued, rejected and erroring shares. Queues are the exception: what a queue, or the consumers behind it, cannot take is a growing backlog, not a failure.
- The wait in a node's queue follows a standard multi-server approximation (Sakasegawa), computed per replica, where the number of servers is how many requests one replica serves at once. That number decides how much utilization hurts. With the model's default variability, at 90% a wide pool barely queues, while a service that serves one request at a time waits, on average, nine times its service time, so a request takes ten service times in all. At 100% or more the wait has no bound, and the simulator says so instead of printing a number.
- Caches absorb their hit rate and forward misses plus writes; splitters divide across equivalent targets; async channels decouple the latency chain.
Replicas are just a property on the node — set a service to 4 replicas and its capacity multiplies, exactly as you'd hope, with third-party services as the deliberate exception: you don't scale someone else's API by drawing more of it.
What it deliberately is not
- Not a discrete-event simulation. No request-level queueing model, no jitter, no tail-latency distributions — a steady-state capacity check, by design.
- Not a vendor benchmark. The capacity numbers are representative anchors for reasoning, not quotes for any specific instance type.
- Not a bill. Provisioned infrastructure uses order-of-magnitude ranges. Usage-priced services with no default price, model APIs and other third parties among them, and the usage share of databases and other stores show “Usage-based — not estimated” until you provide active hours and relevant unit rates, and while any of them does, the panel shows no combined total. Components that do not carry request traffic, such as monitoring or CI/CD, can still carry cost—the traffic model and billing classification are separate.