Cómo fluyen las peticiones
Cómo el juego convierte tu Diseño y tus usuarios en demanda, la encamina por cada Nodo y encuentra el cuello de botella.
Every number in Quorum comes from one model. The Simulation takes your Design and the current demand and computes the Ledger: every rate, latency, error, and dollar on the screen. This page explains how the model moves requests through your board, and why it behaves like a real system.
Users send request kinds#
Users send request kinds, not generic "traffic": page views, API reads, logins, and checkouts. Each kind has three properties that matter to you:
A value. What one satisfied request earns. A checkout earns far more than a page view.
A cost profile. How much CPU it needs on an App Server, and which backend calls it makes.
A patience target. The Apdex target T, the latency under which a user is satisfied. See Apdex and revenue.
Each Era brings new kinds and changes the mix. The Garage serves only page views and API reads. By Series A, users also stream video, chat, and buy things:
- Vista de página15%
- Lectura de API25%
- Escritura de API10%
- Inicio de sesión4%
- Búsqueda10%
- Subida6%
- Bot8%
- Video10%
- Tiempo real8%
- Pago3%
- Petición de puja1%
Features, Ventures, and Product levers change that mix. A lever raises one kind's share and takes the difference from the other kinds, so total demand holds (Eras and Research).
The Eras reference pages list each Era's kinds and shares. Bots are a kind too. They earn nothing and do not count toward Apdex, but they still use your capacity.
App Servers turn requests into backend work#
An App Server rarely answers a request alone. It turns each request into backend kinds: read queries, write queries, transactions, searches, object reads and writes, tasks, charges, scans, and inferences. A page view, for example, sends two read queries to the database.
Backend kinds earn nothing by themselves. They carry load to the data tier and to managed services. A request keeps its original kind on every hop, though, so the read queries that a page view sends still count as page-view traffic when Analytics samples the Database. That is why Insight has a request kind (Insight and observability).
Demand follows the clock#
Demand is your user count times the requests each user sends, shaped by the clock and the mix:
The daily cycle peaks in the evening and falls in the morning, like real diurnal traffic. One sim second is one calendar minute, so a full day passes in 24 real minutes at normal speed. That forces a choice: size for the peak and pay for idle capacity at night, or let an Autoscaler follow the curve. Your Venture sets its own curve, and Features raise the use of the kinds they touch.
Incidents add demand on top. A traffic spike multiplies it, and attacks add bot traffic.
The flow solve#
Your Design is a graph with no loops, and the board refuses a Link that would create one. In each Step of a tenth of a sim second, the solve walks the graph from Users, one Node at a time, in order. At each Node it does six things:
Arrive. The Node receives a rate for each kind.
Accept or strand. A Node passes on kinds it does not handle. If no Link out accepts a kind, those requests are stranded and count as errors.
Serve. The Node answers what it can itself. A Cache answers its hits.
Transform. An App Server turns requests into backend kinds.
Split. The rest goes out on Links. A Load Balancer splits by its algorithm, and an API Gateway splits by its route table.
Limit. Capacity caps what the Node processes. See Capacity, utilization, and queues.
Why a slow database fills your App Servers#
Many runtimes hold a worker or a thread for each request until every call it makes returns. A request therefore occupies an App Server slot for its own CPU time plus the time it waits on the database. This is Little's law: slots in use equal the arrival rate times the time each request stays.
That makes a circle. The App Server's capacity depends on the database's latency, and the database's latency depends on how much the App Servers send. The solve walks the graph several times per Step and blends the call latencies until they settle.
Your App Servers show full load bars, and your Database is amber. The App Servers run PHP-FPM. What is the most likely fix?
Runtimes that wait without holding a slot, such as Node.js or Go, break this coupling. The Runtimes pages show which model each runtime uses.
The bottleneck marker#
The board marks one Node as the bottleneck: the Node that costs you the most revenue. The Simulation finds it with a sensitivity analysis. Once per sim second, it takes the three busiest Nodes above 60% utilization, re-solves the whole Design with each one at double capacity, and keeps the Node whose boost earns the most.
The marker points at the change that would pay, which is not always the reddest card. A Node at 95% that feeds an even slower Node may gain nothing from more capacity. For a step-by-step method, see Find the bottleneck.
The same Design gives the same result#
The model is deterministic. One seeded random generator in the save decides incident timing and targets, and everything else follows from the Design and the clock. The Simulation uses only exact arithmetic, so every browser and the server compute the same Ledger from the same actions. That is what makes Challenge scores fair.