Newsletter #74
It’s been a while since I paid for anything AI-related (not since my Claude subscription to test out Claude Code). Today I decided to subscribe to Z
Goodbye Microservices: From 100s of problem children to 1 superstar
Twilio Segment recounts why they moved away from a microservices architecture for forwarding events to server-side destinations. Initially, all events flowed through a single shared queue, so whenever one destination slowed down or failed, retries caused head-of-line blocking across the entire system. To isolate failures, the team created a dedicated service and queue per destination and split each destination’s code into its own repository. That worked well at first, but once the number of destinations grew past 140, shared libraries drifted out of sync across repositories, each service had a distinct traffic profile that made autoscaling painful to configure, and three engineers were spending most of their time just keeping the lights on.
Their solution was to consolidate everything back into a single service inside a monorepo, unify 120 dependencies onto a single version each, and build a Traffic Recorder to record and replay HTTP traffic during tests—shrinking the test suite for all 140+ destinations from an hour down to a few milliseconds. The result: noticeably faster development velocity (46 shared library improvements in a year compared to 32 previously), simpler scaling, and no more middle-of-the-night pages from traffic spikes. The trade-offs are harder fault isolation, less effective in-process caching, and the risk that upgrading a shared library can break multiple destinations at once. The lesson: moving back to a monolith requires a rock-solid test suite and a clear-eyed acceptance of the trade-offs.
5 engineering dogmas it’s time to retire
Anton Zaides proposes rethinking five familiar “truths” in software engineering. First, “don’t reinvent the wheel, use a library”: over-relying on third-party dependencies exposes projects to security vulnerabilities and constant update churn, famously illustrated when the ~11-line left-pad package was unpublished from npm and broke builds at Facebook, Spotify, and Netflix. Second, “every PR must be reviewed”: code reviews are valuable, but rigid mandatory review gates slow teams down; at Pylon, engineers merge their own PRs and only request reviews when they want feedback, when a change is risky, or when onboarding, and pair programming is a strong alternative. Third, “2–4 week sprints are the modern way to work”: Basecamp’s Shape Up—with 6-week cycles followed by a 1–2 week scheduled cool-down off project work—shows there are viable ways to organize work beyond Scrum and Kanban.
Fourth, “every change should be behind a feature flag”: when overused, hundreds of active flags make the codebase complex, combinatorially hard to test, and create a false sense of security; sometimes thorough testing in staging followed by a direct release is all you need. Fifth, “if your code needs comments, it’s too complex”: extremes in either direction miss the mark, as a one- or two-line comment can save hours for the next person reading the code. He concludes that none of these dogmas are completely wrong, but a good engineering manager knows how to balance them against their team’s reality.
What Does a Database for SSDs Look Like?
Marc Brooker asks what a relational database designed from scratch for SSDs in 2025 would look like, given that Postgres and MySQL were born in the era of spinning disks while modern NVMe SSDs are roughly 1,000x faster in both throughput and latency. Re-evaluating Jim Gray’s “five-minute rule” against current EC2 pricing, a buffer pool should cache pages expected to be re-read within about 30 seconds to optimize cost. Because SSDs are throughput-bound for transfers above ~32 KB and IOPS-bound for smaller blocks, average transfer sizes shouldn’t be much smaller than 32 KB. And since writing to a local SSD only provides single-machine durability, a modern database should synchronously replicate across Availability Zones (AZs)—paying cross-AZ latency only at commit time—while using high-precision hardware clocks to support strongly consistent scale-out reads.
On write-ahead logging (WAL), he argues that flushing to a local disk on a single machine is both unnecessary and insufficient; instead, transactions should commit to a distributed log that guarantees durability across multiple machines and AZs, recovering by replaying the log on any replica. His conclusion: keep the relational model, SQL, atomicity, isolation (defaulting to SNAPSHOT), and strong consistency, but turn durability, read/write scalability, and high availability into distributed problems while stripping out most legacy optimizations built around local disk durability and recovery.
The Economics of System Design: FinOps, Auto-Scaling, and Spot Instances
This post emphasizes that cost is often an afterthought in system design, even though an estimated 30% of cloud spend is wasted on underutilized resources. Small inefficiencies like a redundant query or an idle server might be negligible with 100 users, but balloon into massive bills at millions of users. Cost should therefore be treated as a first-class concern from the initial design phase, because retrofitting cost efficiency onto an inherently expensive architecture is far harder.
The author outlines five strategies: design for efficiency from day one by weighing the overhead of microservices and favoring simplicity; right-size resources and use autoscaling and pay-per-use serverless offerings; add caching layers like Redis and optimize queries (fetching only needed fields and indexing properly) to reduce database load; regularly hunt down and terminate idle resources like forgotten test environments and schedule non-production systems to shut down overnight; and finally, monitor spend, set cost alerts, and build a FinOps culture where engineers treat cost as a performance metric. A well-designed system isn’t just scalable and fast—it’s also cost-effective.
The Big-O Complexity of Vibe Coders
Today, vibe coding (programming by conversing with an LLM) is mostly judged by how quickly it produces results, but the author predicts that as enterprise LLM adoption scales, the question will shift to how costs grow—much like analyzing an algorithm’s Big-O complexity. Teams that don’t use vibe coding move slowly, while teams that abuse it with rapid fire-and-retry prompting rack up huge token bills without understanding why. Every prompt and every correction consumes tokens, so a workflow with many quick retry loops can exhibit closer to O(n²) token complexity rather than O(n). Vague prompts widen the solution space and force repeated corrections, whereas precise prompts that state constraints up front converge much faster.
In the author’s view, the best vibe coders aren’t the ones who iterate the fastest, but the ones with the lowest token “Big-O” per shipped outcome; vibe coding makes individuals faster, while token-efficient vibe coding lets whole teams scale. That said, this lens doesn’t apply to creative or exploratory work like brainstorming or exploring dead ends, which is inherently token-inefficient yet still valuable and shouldn’t be forced into an optimization metric.
Design is more than code
Karri Saarinen, co-founder of Linear, argues that the “should designers code?” debate is far too narrow. The bigger question is how the designer’s role evolves with AI and modern tools, and what we lose if we push designers to jump straight into code. Design takes many forms depending on the domain, customers, and people involved—and even engineers regularly step away from code to sketch architecture or weigh trade-offs. In his view, the first step is “problem design”: questioning whether the problem is real and who defines it rather than taking it as a given, since the most common reason design projects drag on or fail is an unclear problem where everyone has a different mental model.
Next comes “solution design,” which has two phases: a conceptual phase to find the overall shape (at Linear, for example, a project is modeled as a distinct entity with its own properties rather than just a label grouping issues), and an execution phase that brings the idea to the screen, where code and real materials are essential. He likens the upfront work to preparing the goal, context, and prompt for an agent. What worries him isn’t the tooling itself, but the erosion of deliberate thought when building straight in production becomes the default; to him, design is always about finding the right problem, the right intent, and the right vision.
How we saved 70% CPU and 60% memory in Refinery
Honeycomb shares how Refinery 3.0, their Go-based tail-based trace sampling proxy, cut CPU usage by 70% and memory usage by 60% on their internal cluster—enough to shrink a 72-node cluster in half. Profiling revealed that the root cause was deserializing every incoming span in full into a map[string]any with hundreds of fields: roughly 50% of CPU time went to memory allocation and nearly a quarter to garbage collection, while the actual sampling logic took only about 12%—and most spans were ultimately discarded anyway.
The fix was to stop deserializing altogether: Refinery now selectively extracts only the handful of fields needed for sampling directly from the serialized MessagePack payload and keeps the span in its compact serialized form. In benchmarks, selective extraction took about 17 ns with zero allocations, compared to roughly 296 ns and 9 allocations when unmarshaling into a map. Other input formats (JSON, OTLP) are transcoded directly into MessagePack on ingest. The team also optimized metrics instrumentation, pooled large buffers for reuse, and parallelized the decision loop. The resulting code is longer and more complex, but it didn’t require fancy algorithms or a rewrite in Rust—just redefining what the process actually needed to do and doing only that.
From Junior to Senior: 7 API Design Patterns That Scale
This article walks through seven architectural decisions that help APIs scale—and that distinguish junior developers (who focus on internal logic) from seniors (who focus on how systems communicate). First, resource-oriented design: instead of RPC-style endpoints like POST /updateUserEmail, use nouns like /users and let HTTP methods (GET, POST, PUT, PATCH, DELETE) express the action, making the API predictable. Second, return proper HTTP status codes instead of always returning 200 OK with an error message in the body, since monitoring tools, load balancers, and caches rely on status codes; distinguishing 4xx (client error) from 5xx (server error) is crucial during debugging. Third, pagination: offset pagination slows down as datasets grow because the database still has to scan past skipped rows, whereas cursor-based pagination uses an indexed value to keep performance steady.
Fourth, idempotency keys prevent duplicate processing of retried requests, such as charging a customer twice when they tap submit again on a flaky connection. Fifth, rate limiting protects the system from overload. Sixth, API versioning prevents breaking existing clients. Seventh, comprehensive documentation with OpenAPI/Swagger keeps teams aligned. Good API design lays a stable foundation for business growth, while poor design quickly becomes a bottleneck.
Bonus
Images

Verdict: Z.ai processes individual URLs relatively quickly and looked pretty decent at first, though the more URLs I added, the longer and more English-heavy the summaries became. I had to ask it to trim them down a bit. Hopefully I can tune it further (since I already paid for it and it’s non-refundable, haha).
This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026; reviewed and edited by Codex with GPT 6.1 Sol on 09/11/2026, and re-verified by Claude Code with Sonnet 5.5 on 16/11/2026.
Comments