Author

Random Bulletin

17-year internet software developer specializing in AI applications, networking, architecture, and open source. Led the delivery of network services handling hundreds of millions of concurrent devices and tens of millions of QPS, and has three years of experience designing and building an agent platform. Follow to stay updated.

Articles

Likes

Views

Comments

Latest from Random Bulletin

81 recent articles

Random Bulletin

Jul 28, 2026 · Operations

From Wiki Docs to Executable Incident Plans: Cutting MTTR from Hours to Minutes

The article explains how to evolve static wiki‑based incident response plans into structured, executable, auditable systems—adding one‑click execution, gray‑scale rollbacks, permission controls, chaos‑engineered rehearsals, and alert integration—to reduce mean‑time‑to‑recovery from hours to minutes in high‑throughput environments.

MTTR reductionchaos engineeringincident response

0 likes · 19 min read

From Wiki Docs to Executable Incident Plans: Cutting MTTR from Hours to Minutes

Random Bulletin

Jul 27, 2026 · Backend Development

Isolation Strategies for Ten‑Million‑QPS Services: No Isolation, Thread‑Pool, Semaphore

The article explains how sharing a single thread pool can cause a slow downstream service to cripple an entire high‑traffic system, compares thread‑pool and semaphore isolation—detailing their strengths, costs, and suitable scenarios—and provides practical guidelines, framework support, and design decisions for implementing robust isolation in microservices.

circuit breakermicroservicesresilience

0 likes · 21 min read

Isolation Strategies for Ten‑Million‑QPS Services: No Isolation, Thread‑Pool, Semaphore

Random Bulletin

Jul 25, 2026 · Backend Development

Circuit Breaker Strategies: Evolving from Simple to Hierarchical for 10M QPS Systems

The article analyzes how a slow downstream service can trigger a site‑wide cascade failure, explains the three‑state circuit‑breaker model, compares simple global thresholds with layered multi‑metric, multi‑granularity approaches, and evaluates Hystrix, Sentinel, and Envoy implementations for high‑throughput back‑ends.

EnvoyFault ToleranceHystrix

0 likes · 19 min read

Circuit Breaker Strategies: Evolving from Simple to Hierarchical for 10M QPS Systems

Random Bulletin

Jul 24, 2026 · Backend Development

Context Propagation at Ten‑Million QPS: From ThreadLocal to Explicit

The article examines a real‑world incident where ThreadLocal leakage caused user data mix‑ups, then walks through the evolution of context propagation—from implicit ThreadLocal to TTL patches, Reactor Context, ScopedValue, and Go's explicit context—highlighting trade‑offs and best practices for high‑throughput systems.

ContextPropagationGoContextReactor

0 likes · 15 min read

Context Propagation at Ten‑Million QPS: From ThreadLocal to Explicit

Random Bulletin

Jul 23, 2026 · Backend Development

From Threads to Coroutines: Scaling to Millions of QPS

The article explains why the traditional one‑request‑one‑thread model collapses at tens of thousands of connections due to memory, scheduling and cache costs, and shows how user‑space coroutine scheduling, stack‑less designs, Go's GMP model, Java virtual threads and CSP channels enable millions of concurrent connections with synchronous‑style code while highlighting trade‑offs and pitfalls.

CSPGoJava virtual threads

0 likes · 21 min read

From Threads to Coroutines: Scaling to Millions of QPS

Random Bulletin

Jul 22, 2026 · Backend Development

Lock Optimization at Ten‑Million QPS: From Coarse Locks to Lock‑Free Designs

When a service’s QPS jumps from two to eight million, a single global lock can turn a multi‑core machine into a bottleneck, so the article walks through coarse‑lock problems, fine‑grained locking, read‑write separation, optimistic reads, CAS‑based lock‑free techniques, LongAdder and advanced data structures, showing when each step is appropriate for high‑throughput systems.

CASLongAdderjava

0 likes · 19 min read

Lock Optimization at Ten‑Million QPS: From Coarse Locks to Lock‑Free Designs

Random Bulletin

Jul 21, 2026 · Backend Development

Thread Pool Design for Million‑QPS Systems: From Shared to Isolated

The article explains how a shared thread pool can turn a localized slowdown into a system‑wide outage, then walks through the bulkhead isolation pattern, bounded queues, trade‑offs between thread‑pool and semaphore isolation, sizing formulas, monitoring metrics, and dynamic tuning for high‑QPS services.

High QPSbulkhead patternconcurrency

0 likes · 16 min read

Thread Pool Design for Million‑QPS Systems: From Shared to Isolated

Random Bulletin

Jul 19, 2026 · Backend Development

From BIO to Async IO: Evolving Thread Models for Million‑QPS Servers

An online gateway crashed despite low CPU and memory because its one‑connection‑one‑thread BIO model exhausted threads, prompting a deep dive into thread‑pool limits, epoll, Reactor patterns, Proactor, and back‑pressure, showing how each evolution decouples connections from resource consumption to achieve million‑QPS scalability.

BIOReactorasync IO

0 likes · 18 min read

From BIO to Async IO: Evolving Thread Models for Million‑QPS Servers

Random Bulletin

Jul 17, 2026 · Backend Development

Ten‑Million QPS Architecture: From Strong to Eventual Consistency with Layered Design

The article examines why ultra‑high‑throughput systems must move from costly strong consistency to eventual consistency, explaining consistency layering, the trade‑offs of coordination latency, availability, and tail latency, and how local message tables, idempotent delivery, compensation (Saga) and periodic reconciliation together ensure data eventually aligns without sacrificing performance.

Distributed Systemscompensationconsistency

0 likes · 17 min read

Ten‑Million QPS Architecture: From Strong to Eventual Consistency with Layered Design

Random Bulletin

Jul 17, 2026 · Backend Development

Why Moving from Real‑Time to Batch Is Essential for Scaling to Tens of Millions QPS

Scaling a service from millions to tens of millions of queries per second fails not because of data size but due to per‑request fixed costs, and the article shows how batching aggregates these costs, dramatically boosts throughput, reduces latency, and introduces new challenges such as memory pressure and partial failures.

High QPSbatch processinglatency tradeoff

0 likes · 17 min read

Why Moving from Real‑Time to Batch Is Essential for Scaling to Tens of Millions QPS