All Briefings (54 articles)
2026-11-01 · jslet Research · 17 min read
An invoice prints two decimals, so a bill has to be denominated in something, and three unrelated failures all present as one bad decimal point. Representation error is around 1e-17 relative and breaks equality. Accumulation error over a million rows is around 1e-11 and produces the tails in Google's own billing export example, where the documented output prints $1005.004832999999984 beside $1005.00. Rounding error is not a floating point problem at all: one row of $0.0049 rounded to cents is $0.00, and a million such rows billed exactly are $4,900, so the decision about where to round moves more money than every mantissa decision combined. Covers why 53 bits are 15.9546 decimal digits and why 0.1 + 0.2 prints as 0.3 at 15 digits yet fails an assertion at 17, the five values that round down because 1.005 is stored as 1.00499999999999989, why multiplying by 100 makes Math.round worse, the 2^53 micros ceiling at $9,007,199,254.74 against the int64 ceiling at $9.22 trillion, the 19-digit identifier that becomes 1234567890123456768 and stays there, and the seven currencies with three decimal places where assuming cents turns a 100x error into a 10x one. Paired with Cloud Storage Cost, whose per-unit arithmetic runs on the same binary64.
2026-10-25 · jslet Research · 18 min read
A column length is declared in characters and enforced in bytes, and the exchange rate between the two runs from 1 to 4. That one ratio explains four numbers the industry treats as constants. 191 is 767 ÷ 4, the four-byte characters that fit the legacy InnoDB index key prefix. 768 is the same quotient under the 3,072-byte limit that is now the default. 255 is where a latin1 length prefix doubles, and 63 is where the same jump happens under utf8mb4. The same VARCHAR(255) reserves 256 bytes in one schema and 1,022 in the other, caps a table at 255 columns or 64, and either indexes cleanly or fails with ERROR 1071. SQL Server's 450 and 850 are the identical division at 900 and 1,700 bytes over a two-byte character, and PostgreSQL has no quotient at all because it counts characters. Covers the four things called a character, the 25-byte family emoji, the NFC and NFD byte drift that changes a field's capacity, the LENGTH over CHAR_LENGTH query that reveals your data's real width, and why 191 is usually the wrong fix today. Paired with the Character Counter, whose character total this briefing corrects from UTF-16 code units to code points.
2026-10-23 · jslet Research · 18 min read
Cloud volumes sell IOPS and throughput as two dials. They are one dial read at two I/O sizes. AWS gp3, Azure Premium SSD v2 and Ultra Disk, and GCP Hyperdisk Balanced all convert provisioned IOPS into provisionable throughput at almost exactly 0.25 MiB/s per IOPS, which makes one IOPS worth 256 KiB per second and gives each volume type a break-even I/O size where both ceilings arrive at once. On gp3 that size is 25.6 KiB; AWS prints it as a table footnote without naming it. Above it the throughput ceiling binds, so a volume provisioned at 80,000 IOPS delivers 32,000 when the average I/O is 64 KiB and 60% of the IOPS line item is unspendable. Below it the IOPS ceiling binds, so 8,000 IOPS already saturates 2,000 MiB/s at 256 KiB. Covers the same 0.25 meaning different bytes on AWS and Azure (4.86%, not the 7.37% GiB gap), Little's law and the concurrency a serial app cannot supply, the three separate granularities on one disk, and the iostat division that tells you which ceiling you hit. Paired with the IOPS to Throughput Estimator, whose volume reference table this briefing corrects against the current published specs.
2026-10-17 · jslet Research · 17 min read
A cron expression is not a schedule. It is a predicate evaluated once a minute against the local wall clock, and every surprise in it follows from that one fact. Steps select a residue class inside the field rather than an interval, so */59 fires twice an hour — exactly what */30 does — and every value from 30 through 59 collapses to the same load. The two day fields combine with OR, not AND, so 0 0 13 * 5 fires 61 times in 2026 (52 Fridays plus 12 thirteenths minus 3 overlaps) where three Friday the thirteenths were intended. A month is not a unit: an every-minute job fires 43,800 times in the annual-average month and 525,600 a year, not 43,200 and not 518,400, and 0 0 31 * * silently skips five months. Nothing remembers a missed minute, and three documented implementations disagree about what happens when the clocks change — Debian and OpenBSD catch up a forward jump and never re-run a repeated hour, FreeBSD with -s executes exactly once, and EventBridge skips spring and does not repeat autumn. Companion to the Cron Trigger Frequency Matrix.
2026-10-15 · jslet Research · 22 min read
A Unix timestamp is a serial number in a convention — 86,400 seconds to the day, one epoch, one width — and it is not a measure of time. POSIX defines each day as exactly 86,400 seconds, so the 27 leap seconds inserted since 1972 are absent from the count, 23:59:60 has no Unix value of its own, and subtracting two timestamps does not return the elapsed duration. Covers the 61-second minute and the time scales that disagree about it, with TAI running 37 seconds ahead of UTC and GPS 18; why dividing by 86,400 is a correct date function and a wrong duration function; the ten epochs actually running in production, from 1601 for Windows FILETIME to 1980 for GPS, with every offset written out; the counters that expire inside five years — NTP on 2036-02-07, 32-bit time_t on 2038-01-19 03:14:07, HFS+ in 2040, and GPS twice already; why Google smears the leap second over 20 hours while AWS uses 24, Meta goes quadratic after the event, and Cloudflare and NIST step through it, so two clouds can disagree by half a second with no protocol signal to detect it; the forty-year-old Excel phantom 29 February that Microsoft preserves on purpose; CGPM Resolution 4 raising the UT1−UTC ceiling by 2035 and the first negative leap second no software has been tested against; and six rules that keep a timestamp interpretable. Companion to the Unix Timestamp to Epoch Days Calculator.
2026-10-13 · jslet Research · 18 min read
PUE divides facility energy by IT energy, so the denominator is the load an operator spends the year trying to cut. A hall provisioned for 5,000 kW that reads 1.50 at full load reads 1.59 at 40% occupancy and 1.74 at 20% — the same building, 77% less power, a 16% worse score — because transformers, UPS units, chillers, pumps, lighting and controls carry a 300 kW fixed floor that does not follow the servers out. Covers where the overhead physically goes (cooling plant 26% of IT load, fan coils 6%, electrical losses 14%, other 3% — a PUE of 1.49, with cooling worth roughly three times what the power chain is worth), why Uptime Institute's weighted average has sat between 1.54 and 1.59 for six years while Google's 2025 fleet reported 1.09, why marginal PUE (1.44 in the model) is the number to price a capacity decision against rather than the average, why moving the IT meter from the rack to the UPS output shifts a reading by 0.14 — more than the industry improved in eleven years — what PUE cannot see at all (compute per watt, carbon, water), the EU reporting obligation that made annual PUE a legal figure for halls above 500 kW, and the four decisions that make a measured PUE survive scrutiny. Companion to the Datacenter PUE to Power Cost Calculator.
2026-10-12 · jslet Research · 14 min read
The overhead is not a percentage, it is a fixed toll. Every top-level key on a 64-bit Redis 7 pays 48 bytes of structure — a 24-byte dictionary entry, a 16-byte object header and two 4-byte SDS headers — before the key name or the value is counted, and jemalloc then rounds each allocation up to a size class. One gigabyte of data costs 1.68 GB at ten million 100-byte keys, 1.08 GB at a million 1 KB values and 1.00 GB at ten thousand 100 KB values: same bytes, 68% apart. Covers the packing trick Redis's own manual teaches (100,001 string keys use 11 MB against 1.7 MB packed into 100-field hashes), the encoding cliff that silently triples per-element cost, why hash-max-listpack-entries is 512 and not the 128 that tutorials keep quoting from the adjacent sorted-set default, why a 5 GB instance still reports 5 GB of RSS after shedding 2 GB of data, and the four commands that turn a dataset size into a real maxmemory. Companion to the Redis In-Memory Key Inflation Calculator.
2026-10-11 · jslet Research · 15 min read
A storage migration is priced by the direction its bytes travel, and most cost models do not have a direction in them. Moving 100 TB out of AWS over the public internet bills $7,791; moving the same 100 TB in bills nothing, because inbound transfer is $0.00/GB on every major provider. Six paths priced on one dataset span $0 to $8,771 — and the cumulative egress tier means the 100 TB bill is an effective $0.0779/GB rather than the $0.09 on the pricing page. Covers why the dual-write period bills twice and how the two lines are decomposed across two invoices so neither looks abnormal, why an eight-hour cutover at $5,000 per hour is 4.6 times the entire transfer bill and 80.2% of a $49,844 total, why a physical shipment steps by $1,400 the moment the load passes 100 TB and is still beaten by a Direct Connect port, and the five numbers that turn a network estimate into a budget with a dominant term. Companion to the Storage Migration TCO Calculator.
2026-10-09 · jslet Research · 14 min read
A cloud “month” is four different numbers to four different systems. The pricing calculator uses 730 hours — (365 × 24) ÷ 12 — the SLA table uses 720, and the invoice uses the calendar: 744 hours in a 31-day month, 672 in February. The spread is 10.7%, and because 730 × 12 = 8,760 = exactly 365 × 24, the convention is annually exact and wrong in every single month. Covers why an always-on instance bills 744 hours in October, why a one-year commitment covers 8,760 hours no matter how the calendar falls, why 99.9% is 43.2 minutes in a 30-day month but 44.64 in a 31-day one, and the four-line convention note that stops two months from living in one model.
2026-10-05 · jslet Research · 15 min read
A migration is a race between a transfer and a workload. Raw arithmetic says 100 TB over 10 Gbps is 23.3 hours; the same dataset on 1 Gbps with an eight-hour nightly window and a source regenerating 1% of its volume daily takes 49.5 days — and at a 2% change rate on a 100 Mbps link it never finishes at all. Covers the convergence ratio and why it diverges above 1.0, why shortening the transfer window costs the inverse square of the hours removed (24h to 4h multiplies the timeline by 15.8, not 6), why the incremental catch-up rounds form a geometric series that the standard three-phase plan truncates by up to 69%, why a single TCP stream cannot fill a long link, why 100 million 4 KB files cost 5.8 days of metadata against 59 minutes of payload, and the five numbers to collect before committing to a date.
2026-10-04 · jslet Research · 13 min read
Two numbers that look like one. Write the per-token cache as 2 × layers × kv_heads × (d_model / kv_heads) × bytes and the kv_heads terms cancel, leaving the full multi-head attention formula — so the grouped-query saving disappears and the estimate lands 8× too high. A 70B with 64 attention heads and 8 KV heads needs 2.62 GB at 8K context, not the 20.97 GB the cancelling form returns. Covers why the error equals query heads divided by KV heads, why cache precision is a dial separate from weight precision (INT4 weights leave an FP16 cache untouched — a 4× understatement running the other way), why a 27B model with 16 KV heads carries a larger per-token cache than a 70B with 8, and the concurrency maths that actually decides the fleet: 32 concurrent 128K sequences carry 1,342 GB of cache against 140 GB of weights.
2026-09-23 · jslet Research · 14 min read
The 70B class does not fit on one card, and quantization alone does not rescue it. Five numbers decide the answer: weights, KV cache, framework overhead, tensor-parallel efficiency and the card's floor. The KV cache is what turns a comfortable fit into a failed one — a 70B at INT4 holds the same 35 GB of weights at every context length, but its cache runs from 2.6 GB at 8K to 1,342 GB at 128K with 32 concurrent requests. Why MoE carries 9.6× the weight footprint of a dense 70B, why FP8 silently falls back to BF16 on Ampere, and when replica groups beat larger tensor-parallel groups.
2026-09-23 · jslet Research · 15 min read
Most capacity planning runs forwards: here is a card, here is what it can do. The provisioning question runs the other way — here is a traffic target, how much hardware does it take? Three answers fall out. Sharded throughput is not N×: efficiency runs 92% at two GPUs down to 48% at sixteen, and doubles cost per token by the time you reach eight. Replicas beat larger groups: four two-card replicas deliver 7.36× a single card against 5.04× for one eight-card group, on identical silicon. And the peak multiplier is the expensive lever — moving from 2× to 5× multiplies the bill by two and a half.
2026-09-18 · jslet Research · 17 min read
FP8 quotes 2× and delivers 1.15× to 1.84×, depending on which of four switches called "FP8" you actually flipped. NVIDIA's own TensorRT-LLM measurements put it at 1.45× on Llama 3 8B and 1.81× on 70B at batch 32 — and at batch 1, INT4 AWQ's 2.66× beats FP8's 1.84× outright, because decode is memory-bound and four-bit weights are half the bytes. The FP8 KV-cache break-even is 7,010 tokens, below which the flag is a regression rather than a saving. And on an A100 the instructions execute without a single error at exactly BF16 speed, because Ampere has no FP8 units — the trap that costs the most engineering time precisely because it never fails.
2026-09-12 · jslet Research · 18 min read
A lifecycle rule takes ninety seconds to write and looks like a free 46% discount. On a bucket of small objects it moves the bill the wrong way, because S3 prices storage classes per gigabyte and bills them per object. 90 million 4 KB log files cost $7.90/mo in S3 Standard and $137.33/mo in Standard-IA — identical bytes, billed against a 128 KB floor that multiplies them by 32. Then the transition charge lands: $4,500 once, against $4.50/mo of savings. Covers the 16.3-day break-even residence for Standard-IA, the 42.5% and 63.3% monthly read thresholds where Glacier stops winning, the per-object Intelligent-Tiering fee that scales with object count rather than bytes, and the compaction fix that turns the same 343 GB into $4.29/mo in the very same tier.
2026-09-02 · jslet Research · 18 min read
GitHub Actions quotes $0.006/minute for Linux — ten minutes of build time is six cents. The bill tells a different story: a five-person iOS team lands at roughly $1,540 a month once macOS compute, a Windows matrix, Linux fan-out, and artifact storage are stacked. Five structural costs sit between the per-minute rate and the invoice: the macOS premium, cache-miss amplification, concurrency queue latency, artifact storage drag, and per-job overhead.
2026-08-29 · jslet Research · 10 min read
Two teams run the same 99.9% SLO: one ships three times a week, the other discovers at quarter-end that a 30-minute outage ate 69% of the month. The difference is not discipline — it is whether the error budget is a decision mechanism or a document. Burn-rate alerting (14.4x/1h pages, 6x/6h, 1x/3d), the SLO-vs-SLA gap that creates your safety margin, and a graduated freeze policy written while everyone is calm.
2026-08-28 · jslet Research · 12 min read
Cross-AZ transfer bills $0.01/GB in each direction and never appears as a named line item — it hides inside EC2-Other and ELB usage types. A 10K rps three-tier app pays $5,013/month for the privilege of being highly available; a chatty microservice mesh pays $6,266. We mapped every free/paid boundary (including the same-AZ public-IP trap and the RDS Multi-AZ exemption), priced four architectures with 2026 rates, quantified the NAT Gateway stacking effect, and laid out when AZ-affinity routing is worth the engineering effort — and when the tax is simply the price of resilience.
2026-08-05 · jslet Research · 11 min read
We measured base64 inflation across real payloads: a 10-byte secret grows 60%, a 32-byte JWT signature key grows 37.5%, and a 200 KB screenshot becomes a 267 KB data URI. The theoretical 33% is the floor, not the rule — small payloads pay far more. And the trap almost everyone hits: gzipping base64 is 22% worse than gzipping the raw bytes. Includes the data-URI break-even analysis and a decision framework for when base64 is worth it.
2026-08-04 · jslet Research · 13 min read
We compiled 2,000 functions into bundles from 100 KB to 5 MB and measured parse time in Chrome. 1 MB JS = 30 ms on desktop, 90-150 ms on a mid-range phone. Gzip saves 85% of transmission but 0% of parsing — the browser decompresses back to full source before V8 starts. JSON.parse is 10-20x faster than JS object literals for data. Includes the mobile multiplier, a zone-based decision framework, and a 5-step migration checklist. Companion to The Image Weight Tax.
2026-08-23 · jslet Research · 7 min read
Measured on identical data: the same 1,000 records weigh 236KB as XML vs 162KB as compact JSON (a 46% premium) and parse 2.6x slower. The attribute-vs-element rewrite saves 81% — a trick most XML authors never use. Why XML survives (XSD contracts, namespaces, installed base) and a decision framework for when to convert to JSON.
2026-08-16 · jslet Research · 8 min read
Measured in Chrome 136: parsing a 6.5MB payload adds 13.8MB of heap — the object tree alone is 138% of the input, so peak memory is about 2.4x the file. A no-op reviver callback slows parsing 11.9x. And single-block JSON delays first data by 18ms while NDJSON shows the first record in microseconds — a 100x first-byte gap on slow networks. Includes the memory decision framework and a 5-step audit.
2026-08-11 · jslet Research · 9 min read
We traced Chrome's rendering pipeline: animating width on 3,000 elements triggers 110 layout passes in 1.8 seconds — 273ms of layout plus 213ms of paint, 27% of every frame budget. The identical motion with transform triggers zero layout. Includes the compositor rule, the paint double-bill, the mobile surcharge, fill-mode and replay traps, a property decision framework and a 5-step audit.
2026-08-08 · jslet Research · 10 min read
We benchmarked Chrome and put a price on CSS layout. Reflowing a 10,000-element grid takes 7.9ms — 47% of a frame budget, 2x the same content in block layout — and layout cost scales worse than linearly. The real fine is layout thrash: interleaving writes and reads made the same workload 101x slower (61ms vs 0.6ms). Includes the three layout taxes, the mobile multiplier, content-visibility guidance, a decision framework and a 5-step audit.
2026-08-02 · jslet Research · 12 min read
Images are 50-70% of a typical page's weight — and the format you choose quietly decides your CDN bill. We compressed 3,000 real images across JPG, PNG, and WebP. The median result: WebP q75 is 80% smaller than JPG q75 and 97% smaller than PNG. For a site serving 50,000 pageviews a month with 5 images per page, that's 300 GB of monthly egress disappearing — roughly half a typical CDN bill. Includes the bandwidth math, the JPG generation-loss trap, a 2026 format decision framework, and a 5-step migration checklist.
2026-07-26 · jslet Research · 16 min read
Datadog cardinality, Splunk ingest, and 1% head-sampling: three billing structures, each hiding spend on data you never query. The three pillars (logs, metrics, traces) each hide a structural pricing trap: Datadog's custom metric cardinality bills $0.10 per unique tag combination per month — one tag with 1,000 customer IDs = $100/month for a single metric. Splunk's ingest model charges $2-5/GB for data where 93% is never queried after 7 days. Trace head-sampling at 1% statistically guarantees you capture ~3 P99 traces during a latency incident. Self-hosted Grafana stack (Loki + Mimir + Tempo): 53% cheaper at 200 hosts, 69% cheaper at 500 hosts. Breakeven at ~70-100 hosts.
2026-07-26 · jslet Research · 15 min read
Your bitrate ladder says 1080p at 6 Mbps. But VBR encoding peaks at 12-15 Mbps during complex scenes (water, confetti, fast motion). HLS protocol overhead adds 15% in manifests and TS container padding. Live vs VOD bandwidth models are fundamentally different formulas — confusing them causes 3× estimation errors. Ad insertion, DVR window retention, and multi-CDN origin shield traffic each multiply base bandwidth. Encoder economics: H.264→ .265 saves 40% at 10× encoding cost; AV1 saves another 20% at 20× encoding cost. Includes the five streaming bandwidth multipliers and a CDN provisioning framework.
2026-07-26 · jslet Research · 15 min read
Serial latency: 50 microservices × P99=5ms = P99=250ms. Parallel fan-out: 10 backends × P99=50ms = composite P99 120-180ms because P(all under 50ms) = 0.99^10 = 90.4% — the slowest of 10 calls determines the user response time. Five structural latency traps: fan-out tail amplification (statistics invert in parallel), protocol stack tax (3 RTTs before first byte), serialization overhead (JSON vs Protobuf at 10+ hops), queueing (Little's Law — 80% utilization = 40% latency increase from queueing), and the physics floor (NY→ ondon = 56ms RTT minimum).
2026-07-26 · jslet Research · 16 min read
OOMKill at 2 AM is not a bug — it's your resource configuration. JVM process RSS = Xmx × 2.2 (heap + Metaspace + thread stacks + JIT code cache + glibc malloc arenas). Setting container limit = Xmx guarantees OOMKill. Request=limit wastes 43% of cluster capacity — the scheduler reserves the max, not the average. CFS CPU throttling creates a self-amplifying cycle: throttle →P99 latency spike →HPA scale-out →more throttled pods →cluster capacity exhausted. Includes runtime memory models for JVM, Go (1.5×), and Node.js (1.8×), plus a four-step VPA-based decision framework.
2026-07-26 · jslet Research · 15 min read
API Gateway pricing pages lead with $1.00-3.50 per million requests. The decoy: per-request rate. The hook: data transfer egress at $0.09/GB. At 500M requests/month with 50 KB responses, data transfer costs $2,550/month — 5× the request cost. Five structural multipliers: data transfer domination, throttling retry amplification (429 →retry →billable request →retry), protocol choice (gRPC saves 40% bandwidth), multi-region fragmentation (Azure APIM: 5 regions × $400/month = $2,000 before a single call), and self-hosted breakeven at ~500 rps. Two NGINX instances on reserved instances: $132.48/month. Same throughput on managed Gateway: $4,000+.
2026-07-26 · jslet Research · 16 min read
Lambda's pricing page shows $0.0000166667 per GB-second. A function at 10M invocations/month, 200ms, 256MB: $10.50 in compute and requests. Your bill says $427. The gap is five structural taxes: VPC cold starts that inflate concurrency 3×, provisioned concurrency premiums, CloudWatch Logs with default infinite retention that surpasses compute cost within 90 days, cross-AZ egress to RDS/ElastiCache that's invisible on the Lambda dashboard, and Step Functions state transitions at $0.000025 each that make orchestration 12.5× more expensive than the Lambdas it orchestrates. Includes the Lambda vs EC2 vs Fargate breakeven math at steady-state throughput.
2026-07-26 · jslet Research · 17 min read
A 3-year Standard RI at 40% off is not a discount — it's a 36-month cash advance to AWS with a breakeven that depends on exactly one variable: the spot interruption rate over the commitment period. At current spot pricing, a 1% move in interruption frequency flips a $200K RI commitment from savings to loss versus running the same workload on spot. This briefing deconstructs the breakeven surface across four variables (RI discount, spot discount, monthly runtime, recovery cost), the Convertible RI liquidity premium for GPU instances, the Savings Plan structural arbitrage in mixed fleets, cross-region spot diversification economics, and the three-tier allocation framework (base = RI, burst = spot, buffer = on-demand) that teams use to extract 60%+ savings without betting the farm on a single pricing model.
2026-07-21 · jslet Research · 16 min read
Four cloud providers run the same PostgreSQL. Four different bills. RDS doubles your compute the moment you check Multi-AZ. io1 IOPS can add $780/month to a $40 storage bill. And RDS is the only one of the four that charges for retained backups — a tax Aurora, Cloud SQL, and Azure DB don't levy. This briefing walks through the five structural pricing traps that compound with scale, then models four real workload profiles across AWS RDS, Amazon Aurora, Google Cloud SQL, and Azure DB with 2026 list prices. The gap between cheapest and most expensive is 2.1× — and the line items driving it are hiding in plain sight.
2026-07-21 · jslet Research · 15 min read
ALB and NLB bill by LCU — and you pay for the MAX dimension, not the sum. A balancer at 2 Gbps with 5 new connections/second bills 2 LCU. Add 50,000 connections/second and NLB drops to 63 LCU while ALB jumps to 2,000 — the binding dimension flips the economics by 38×. This briefing deconstructs LCU billing mechanics across all dimensions, models five workload profiles that flip the binding dimension in unexpected ways, and provides a decision framework for choosing ALB vs NLB — not on features, but on cost structure. Includes the rule-evaluation trap (50 rules at 5,000 rps = $1,168/month in LCU alone), the fixed hourly floor that dominates at low traffic, and the multi-load-balancer consolidation play.
2026-07-17 · jslet Research · 19 min read
Each NAT Gateway costs $0.045/hr — $32.85 per month per AZ — before a single byte of data passes through it. At 3 AZs for production HA, the idle cost alone is $98.55/month. Then the data processing meter starts: $0.045/GB in both directions. Then cross-AZ traffic through NAT GW gets counted twice at $0.01/GB per direction. This briefing deconstructs the three independent cost vectors that make NAT Gateway bills unpredictable, walks through three real bill scenarios — startup ($35/mo), mid-market SaaS ($354/mo before fixes), data-heavy platform ($1,179/mo) — and provides the VPC Endpoint arbitrage framework: moving S3, DynamoDB, ECR, and CloudWatch traffic off the NAT Gateway onto PrivateLink, where data processing drops from $0.045/GB to $0.00–0.01/GB. Includes EC2 self-managed NAT instance analysis (10× cheaper, 5× more operational work), the Terraform/CDK default trap, and break-even math for every decision point.
2026-07-15 · jslet Research · 16 min read
Every Kafka partition consumes ~0.50 MB of broker JVM heap before a single byte of message data hits disk — leader state, replica fetchers, ISR bookkeeping, producer ID snapshots, fetch session caches, and log segment indices. At 10,000 partitions across a cluster, the metadata tax alone consumes 50% of broker RAM. This briefing catalogs the per-partition memory cost with a line-item breakdown, identifies the five structural limits partition count imposes beyond RAM (file descriptor exhaustion, controlled shutdown time explosion, G1GC degradation, producer batching collapse, and controller overload during broker failure), walks through three real broker death scenarios — all traced back to partition count as root cause — and provides a practical partition budget framework that treats partition count as a finite cluster resource rather than a free configuration parameter.
2026-07-15 · jslet Research · 16 min read
Your CDN dashboard says 95% cache hit ratio. The bar is green. But 95% means one in twenty requests still hits your origin server — and at 500 million requests/month, those 25 million miss requests are costing you $1,200–2,500/month in origin egress and compute. The number to watch isn't hit ratio — it's miss ratio. Going from 95% to 99% cache hit ratio isn't a 4% improvement. It's an 80% reduction in origin traffic. This briefing deconstructs the six structural leaks that silently eat cache hit ratios from the inside: TTL misconfiguration, Vary-header fragmentation, query string noise, cookie-based bypass, AI crawler URL uniqueness, and invalidation cascades. Includes origin shield economics, byte hit vs. request hit ratio analysis, three real CDN bill walkthroughs at different scales, and a practical TTL engineering framework.
2026-07-13 · jslet Research · 14 min read
The NVIDIA spec sheet says the H100 has 15× the TFLOPS of a T4. So a 7B model should be 15× faster? Wrong — it's 150× faster. The missing variable is memory bandwidth. LLM inference decode is memory-bound, not compute-bound: each token requires reading every model parameter from VRAM. The T4's 300 GB/s yields 21 theoretical tok/s for a 7B FP16 model. The H100's 3,350 GB/s yields 239 tok/s. This briefing traces the arithmetic from parameter count to memory bandwidth to real-world throughput, with measured benchmark data across 12 models, 10 GPU types, and 5 quantization levels (incl. FP8). Includes GPU memory bandwidth comparison tables, quantization throughput tradeoffs, batch size latency analysis, and multi-GPU scaling efficiency data.
2026-07-13 · jslet Research · 9 min read
You change an A record. Your browser shows the new IP. The deployment dashboard says green. Then the Slack messages start — "API is down" from Singapore, "connection refused" from Frankfurt, "works fine here" from Virginia. DNS propagation is not one number — it's a distribution shaped by TTL, ISP resolver caching policy, and geographic anycast topology. Google DNS users see the change in 60 seconds. Deutsche Telekom users might wait 24 hours. This article models the actual time-to-visibility across 8 resolver populations with real cache policy data. Includes the pre-warming technique for instant DNS migrations, NS record migration guidance (and why it's different), and a practical 4-step DNS change playbook.
2026-07-12 · jslet Research · 17 min read
The pricing page says GPT-6 Sol costs $2.00 per million input tokens. Your napkin math says $40/day. The bill says $120. This briefing deconstructs the five structural leaks — workload ratio asymmetry, tokenizer variance, unused prompt caching (90–95% off cached input on Anthropic), batch processing (50% off), and rate-limit retry overhead — that make real LLM API costs 1.8–4× higher than the sticker price. Includes complete provider-by-provider pricing breakdown across OpenAI, Anthropic, Google, DeepSeek, Mistral, and Together AI. Full self-hosted vs API breakeven math for 7B to 405B parameter models — and the three questions that determine which side of the breakeven you're on.
2026-07-05 · jslet Research · 14 min read
Every ORM ships with a connection pool default of 100. The PostgreSQL wiki recommends (core_count × 2) + spindles — on an 8-core NVMe server, that's 17. The 83-connection gap isn't unused headroom — it's a throughput penalty measured in context-switch overhead, memory pressure, and lock contention. This briefing traces the formula line by line, explains why more connections actually decrease throughput once you pass the knee of the curve, covers engine-specific adjustments for PostgreSQL, MySQL, SQL Server, and Oracle, and provides the multi-instance sizing math for microservice deployments. Includes the concrete pgbench methodology to measure your own throughput curve, PgBouncer decision framework, and a practical deployment guide for autoscaling and serverless environments.
2026-06-30 · jslet Research · 16 min read
S3 Standard costs $0.023/GB. R2 costs $0.015/GB with zero egress. At 10 TB stored and 50 TB served, R2 is $150/mo and S3 is $4,730/mo — a 31× gap. The $/GB storage number on the pricing page is the least important variable. Egress is the one that bankrupts you. Full 6-vendor comparison (S3, GCP, Azure, R2, B2, Wasabi) across four workload profiles, the cold-storage calculus, and the minimum-retention fine print.
2026-07-03 · jslet Research · 14 min read
K8s says 110 pods per node. Your CNI says maybe 40. Your node has 40% idle CPU but the scheduler refuses pods — because the IP ceiling, ENI slot exhaustion, system reservations, or DaemonSet overhead already claimed the slots. This briefing deconstructs the four binding constraints across EKS, GKE, and AKS with real per-instance pod ceilings, quantifies the DaemonSet tax (4–8 pods per node before your app deploys), and explains the CPU vs memory overcommit asymmetry that determines whether you should lower requests or buy more nodes. Includes a five-rule node sizing framework.
2026-07-29 · jslet Research · 13 min read
UUID v4's 122 random bits make collisions impossible — but they also scatter writes across every B-tree page. UUID v7 (RFC 9562, May 2024) fixes this by putting a 48-bit Unix millisecond timestamp first. This single layout change produces 73% fewer page splits on Postgres, 40% higher INSERT throughput, and 18% smaller indexes. MySQL/InnoDB benefits even more (56%) because clustered indexes move entire rows on page split. Covers B-tree internals, real benchmarks across Postgres/MySQL/SQLite, InnoDB vs Postgres storage engine comparison, migration strategy with zero downtime, the privacy cost of timestamp leakage, and when v4 still wins. Companion to the UUID collision probability briefing.
2026-07-02 · jslet Research · 13 min read
UUID v4: 122 random bits, 5.3×10³⁻?possible values. You need 2.71 quintillion UUIDs for a 50% collision chance. At 1 billion per second, that's 85 years. The math says you'll never see one in your lifetime. The RNG bugs disagree — and they've been right. This briefing runs the birthday paradox math across real distributed-system generation rates, compares all UUID versions (v1/v4/v7), catalogs the production collision cases (spoiler: every one was a bad RNG, not the birthday paradox), and provides a practical decision framework for UUID version selection. Includes the UUID v7 case for new systems, the RNG entropy checklist, and why a UNIQUE constraint is better insurance than a longer UUID.
2026-07-01 · jslet Research · 13 min read
The rebuild time difference between RAID 5 and RAID 6 on an 8×20TB array is 7 hours. The URE survival probability difference is five orders of magnitude. This briefing is a head-to-head rebuild comparison across drive sizes — with full rebuild time tables, URE probability curves at 20TB scale, and the economic case for why optimizing for capacity over survival is the most expensive mistake in storage provisioning. Includes the RAID 10 comparison, the SSD footnote, the ZFS RAIDZ1 exception, and a practical decision framework.
2026-06-28 · jslet Research · 14 min read
bcrypt cost 12 on your 8-character password: ~3 years on a single RTX 4090. SHA-256 unsalted on the same password: less time than it took to scroll to this page. The hash algorithm gap is 5 million to 1 — and it swamps every other variable in password security. This briefing deconstructs the 12-character password across five attacker tiers and six hash functions, prices out the cloud GPU economics of cracking (bcrypt: $5M, NTLM: $0.25), and explains why the password-length arms race is fighting the wrong battle. Includes the practical hash-choosing framework: Argon2id, bcrypt, and why SHA-256 should never touch a password database.
2026-06-28 · jslet Research · 19 min read
99.9% uptime = 8.76 hours downtime/year. 99.999% = 5 minutes 15 seconds — less time than your last database failover. Going from 3 to 5 nines costs roughly 4× more in infrastructure and 8× more in engineering time. This briefing prices out the real architecture behind each SLA tier: single-AZ, multi-AZ, multi-region active-active. Includes cloud provider SLA reality check (spoiler: the credits are a coupon, not insurance), breakeven economics, and why five nines is uneconomical below ~$200M in annual revenue. If you've ever written "99.99%" on an architecture diagram without knowing what it costs to build, this is the number.
2026-06-27 · jslet Research · 16 min read
The paper says 72 GPU-hours on 8×A100. Your cloud bill says 90. This article maps the five structural leaks that make real GPU training cost 20–50% more than methodology-section math: utilization loss, Xid errors and NCCL timeouts, hyperparameter search multipliers, checkpoint storage compounding, and cross-cloud data egress. Includes full provider pricing comparison (Vast.ai, Lambda Labs, RunPod, AWS, GCP, Azure), three real workload cost models — fine-tuning a 70B model with LoRA ($254–636), training a 7B model from scratch ($6K), and a full 70B pretraining run ($80–160K) — plus the VRAM napkin math for training vs fine-tuning decisions.
2026-06-26 · jslet Research · 15 min read
RAID 5 was designed when drives were 500 GB. At 12 TB, the math breaks. An 8×12TB array with consumer HDDs faces a 99.9% rebuild failure probability from unrecoverable read errors alone — and that's before accounting for the 30+ hour rebuild window with zero parity protection. This briefing runs the full URE probability model with real drive specs from Seagate, WD, and Toshiba datasheets, Backblaze Q1 2026 field data, and a decision framework covering RAID 5/6/10 and erasure coding. Includes the ZFS RAIDZ1 exception, the SSD caveat, and a practical migration checklist for teams stuck on RAID 5 today.
2026-06-23 · jslet Research · 8 min read
Every VPN protocol imposes a per-packet overhead tax that reduces usable throughput below the raw link speed. This encyclopedia catalogs the measured overhead for WireGuard, IPsec (tunnel and transport modes), OpenVPN (UDP and TCP), and IKEv2 across common MTU sizes. WireGuard loses 4.2% at 1500-byte MTU. OpenVPN over TCP loses up to 30% — and the TCP-over-TCP retransmission cascade makes things far worse. Includes protocol selection guidance by use case and the napkin math for calculating your actual usable throughput.
2026-06-22 · jslet Research · 18 min read
Observability now consumes 15–25% of total cloud spend at mid-scale companies. Datadog at 200 hosts: $36,270/month. Self-built LGTM: $4,900/month. Same telemetry, 86% less. This briefing models five observability solutions — Datadog, Grafana Cloud, Splunk, New Relic, and self-hosted LGTM — across three workload scales (seed, mid-market, enterprise). Includes the pricing model anatomy, the four structural reasons SaaS observability costs spiral, honest self-hosting overhead estimates, and a scale-based decision framework.
2026-06-21 · jslet Research · 12 min read
Everyone benchmarks compute. Nobody benchmarks egress — until the bill arrives. AWS charges up to $0.09/GB for public internet egress. DigitalOcean includes up to 11 TB of free egress per Droplet. Three real workload scenarios priced through both models: a small SaaS API (450 GB/month), a media processing pipeline (5.6 TB/month), and a centralized logging sink (12.7 TB/month). Includes breakeven math, the CloudFront counterargument, and a practical migration playbook.
2026-06-20 · jslet Research · 22 min read
For the first time in internet history, bots outnumber humans online — 53% of all web traffic is automated. AI crawler traffic grew 300% YoY. Anthropic's ClaudeBot achieves a 73,000:1 crawl-to-referral ratio. The social contract that built the open web — let us index you, and we'll send you humans — has collapsed. This report analyzes traffic composition data from Imperva, Cloudflare, and Akamai; quantifies the infrastructure cost impact on CDN egress and origin servers; and details the emerging industry responses.