Build1 distinct publisher2 min readPublished
A dev.to walkthrough insists on four measured states and four load inputs before anyone commits to a resource number, which is sound engineering, though the supplied text stops before it prices the testing it calls not free.
The Engineer · Build desk

Compiled by The EngineerSomething wrong?How this is made
Follow any of these and your For You feed starts watching them — no settings page required.
build
Every viewer hits your HLS key endpoint in the same second, and almost nobody tests it1 distinct publisher
build
Three services you can delete: queue, cache and search in one Postgres1 distinct publisher
build
Reversibility decides which of six services may guess and which must refuse1 distinct publisher
build
PHP-FPM's dynamic pool is a one-second idle-worker loop, not a capacity plan1 distinct publisher
Start with the state that sets the ceiling. The four states are not four numbers of equal weight. Idle is the floor, what you pay for whenever the pod is up and doing nothing [5]. Normal load, the band the system occupies 90-95% of the time, is what most of the infrastructure bill is made of [6]. Peak is less a capacity figure than a commitment: the article's framing is that you have tested up to that number and you own it [7]. Startup is the odd one, because heavy initialization, cache pre-loads and migrations can push consumption well above idle [4], which makes it the state that decides how tight a pod's upper bound can be set without the process dying on the way up.
The placeholder in the CTO section is where the arithmetic gets interesting. Multiply it out and you get 1,536MB of memory with 6 cores at the floor, 12,800MB with 50 cores at the top, an 8.3x spread [17]. That range is honest about being a range. It is also useless for capacity planning, and the distance between its ends is roughly the size of the argument a sizing meeting is trying to have without data.
On bigger pods versus more pods, the outline poses the question as a section heading [14] and the supplied text never reaches an answer, so here is mine with the context attached. Once a load generator can hold a fixed request rate, this is measurable in an afternoon:
1. Run a single instance at the resources you think it needs. 2. Raise concurrency until latency crosses your budget, and record requests per second per core at that point. 3. Double the pod's CPU and memory and repeat step 2. 4. Compare throughput per core across the two runs.
If throughput per core holds, the workload scales inside the pod and fewer, larger pods buy you less orchestration overhead per unit of work. If it flattens, something in the process is serialised, the extra cores will sit idle, and you spend the same money on more replicas instead. My context is JVM services with generous heaps, where doubling usually does hold; I would not carry that result to a single-threaded worker without rerunning the same four steps.
One crack worth pinning down before you copy the method. Normal load appears twice with different definitions: 90-95% of the time in the state list, a flat 95% average in the four-question checklist [19]. Five points of tail is exactly where the peak run gets its inputs, so it matters which one your measurement actually covered.
Ranked by verification strength, evidence, and original report placement.
The dev.to article "Stop Guessing Your App's Resource Requirements", by mfdilawar, explains a step-by-step approach to right-sizing an application's resources, written primarily for developers with sections addressed specifically to managers and CTOs.
The article's stated aim is to spend just enough time upfront on sizing to avoid spending exponentially more time and money at later stages.
The article says correct resource numbers require understanding requirements across four distinct states: startup, idle, normal load and peak load.
The article says some apps run heavy initialization scripts, pre-load caches or run migrations at startup, and that resource consumption there can spike significantly above idle.
The article defines idle as the app running under no load, and calls it the floor: the minimum you will always be paying for.
The article defines normal load as the load the system sees 90-95% of the time, says it is what you size for, and says the infrastructure bill is mostly based on it.
Distinct publishers with included, body-backed reporting in this cluster.
dev.to
1 article · August 29, 2026
Evidence-backed comparisons of source perspectives and observed adoption signals. Read the methodology
Which Builder, Operator, and Investor concerns the observed source mix emphasized—not a truth score.
Evidence, demonstrated adoption, hype gap, incentives, and confidence are assessed independently, each on its own current evidence. How these are measured.
A method described, never demonstrated
What the sizing case rests on is definition and rule of thumb, not measurement. The one concrete configuration — 3 to 25 pods at 512MB and 2 cores — arrives with mfdilawar's own instruction to treat it as directional, and the dollar figures that would anchor the cost argument are promised and never delivered in what dev.to gives us. The engineering logic holds together and does not contradict itself; the numbers under it are missing by the author's own admission.
No adoption signal
Nothing in this reporting shows the method being used. There is no team that ran the loop, no cluster that was re-sized, no before-and-after bill — not even an anonymised example. That is not a criticism of a how-to piece, but it does mean there is nothing here to measure uptake against.
Modest claims, unpaid promises
For the genre this is unusually restrained: the central assertion is that you cannot trust your own numbers yet, and the single figure on offer comes with an instruction to caveat it. The overstatement sits in the billing rather than the reasoning — over-provisioning is promised a real-dollar price tag further down the page, testing gets a heading that calls it not free, and neither bill is ever settled in what dev.to publishes here. An 8.3x spread between floor and ceiling is also doing less work than a stakeholder will hear.
Nothing to sell at the end of it
No vendor, no tool, no pricing tier, no benchmark that flatters anybody. This is one practitioner publishing on a developer community platform, and the work recommended — iterative load testing over weeks, not a half-day task — is work the author is not selling. What remains is the ordinary reputational return on writing an authoritative guide, plus a CTO callout that hands architects a defensible line to use in a meeting.
One author, one post, cut short
We are reading a single dev.to piece by a single author, and the copy stops mid-word before its most checkable sections. The definitional material is solid enough to summarise with confidence; the prescriptive figures are one person's experience, and a term as central as normal load is defined two slightly different ways within a few hundred words.