All Briefings (28 articles)
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-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
Observability now consumes 15-25% of total cloud spend —often exceeding the infrastructure it monitors. 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—.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—,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, 7 GPU types, and 4 quantization levels. 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-4o costs $2.50 per million input tokens. Your napkin math says $18.25/day. The bill says $54. This briefing deconstructs the five structural leaks —workload ratio asymmetry, tokenizer variance, unused prompt caching (90% off on Anthropic), batch processing (50% off), and rate-limit retry overhead —that make real LLM API costs 1.8—× higher than the sticker price. Includes complete provider-by-provider pricing breakdown across OpenAI, Anthropic, Google, DeepSeek, Mistral, and Meta/Groq. 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— 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—0% 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—36), training a 7B model from scratch ($6K), and a full 70B pretraining run ($80—60K) —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—5% 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.