TL;DR
Get the latest gadgets delivered free with Prime
- Fast, free delivery on millions of items
- Prime Video, Amazon Music and more included
- Member-only deals all year
AWS engineer Marc Brooker published animations explaining how load spikes can trigger persistent performance problems in PostgreSQL and etcd. He says the animations were generated with Kiro and KiroCrew, while the underlying results came from traces captured in a real test environment.
Marc Brooker, an AWS engineer, published a set of system-behavior animations on October 23, 2026, showing how load spikes can contribute to persistent performance problems in PostgreSQL and etcd. Brooker says the animations were made with Kiro and KiroCrew, while the results they depict came from traces captured in a real test environment.
Brooker presents the animations as a way to help engineers build intuition about how systems work and fail. One example concerns PostgreSQL 16 running in a MicroVM: in the test he describes, a database handling 20 queries per second experiences a load spike. Queries consume memory, displacing some of the working set from the page cache; subsequent requests rely more on disk and run more slowly. The post says each query in that example uses 12 MB.
His etcd examples focus on metastable behavior, in which an initial load increase can set off effects that make performance worse and recovery harder. In one test, a write-load spike leaves peers appearing unavailable, prompting application-level resends. In another, a read rate rises from 500 to 1,000 reads per second; Brooker says time spent in garbage collection increases, average tenure rises, and less CPU remains for the read workload, creating a self-reinforcing loop that does not recover without intervention.
Brooker says the visuals were generated mostly with Opus 5.5 through Kiro and KiroCrew. He distinguishes the presentation from its evidence: the animations are generated, but the results are drawn from traces captured in a real test setup. The post does not provide a full experimental methods section or independent review of the tests.
How Load Spikes Can Persist
The examples illustrate why a system that performs adequately under ordinary demand may behave differently after a sudden increase in workload. When one slowdown triggers more memory pressure, retries, or background work, those effects can consume resources needed to serve the original workload. The result can be a feedback loop, rather than a brief slowdown that ends when the spike passes.
For engineers, the animations may make complex trace data easier to follow and discuss. They also draw attention to a testing challenge: Brooker argues that production experience alone may not expose every failure mode. The examples are not evidence that every PostgreSQL or etcd deployment will behave this way; they describe particular test conditions. Their practical value depends on whether teams can connect the illustrated behavior to their own workloads and measurements.
PostgreSQL performance tuning and query optimization book
As an affiliate, we earn on qualifying purchases.
As an affiliate, we earn on qualifying purchases.
From Abstract Models to Test Traces
Brooker previously wrote about metastable failures and created Stability Sim to help explain how retries and queues can make such behavior easier to trigger. In this post, he addresses skepticism that these effects occur in real systems, saying that operationally mature software can still exhibit them under specific conditions.
He also describes animations as one of several ways to use language models to support learning. In an earlier post about the Strands Decider, he said he asks a model questions to check his understanding. Here, the visualizations serve a different purpose: they turn traces from controlled tests into animated accounts of system behavior. Brooker identifies himself as an AWS engineer and says the views on his blog are his own.
“Animations can help us build an intuition for how and why systems work, or how and why they fail.”
— Marc Brooker, in his October 23 blog post
Limits of the Reported Tests
The post does not specify enough experimental detail to assess how broadly the results apply, including the complete hardware and software configurations, workload design, number of runs, or comparison with alternative configurations. The author describes the tests as real and says they generated the supporting traces, but the material provided does not include independent verification.
Brooker also marks one point as unconfirmed: he believes similar allocator-related effects might occur in a runtime without garbage collection, but says he has not reproduced that behavior. It is also unclear whether the reported systems recovered under other settings or after different forms of intervention.
Further Tests Could Clarify Scope
Brooker’s post presents the animations and their trace-based examples but does not announce a specific follow-up study, release schedule, or deployment recommendation. The immediate next step for readers seeking to apply the findings is to compare the scenarios with measurements from their own systems, including memory pressure, disk activity, retry rates, garbage-collection time, and recovery after load changes.
Further published methods and tests could clarify how repeatable the effects are and which configurations are most susceptible. Brooker says he has not reproduced the proposed allocator behavior in a runtime without garbage collection; whether he or other researchers pursue that question remains open.
Key Questions
What did Marc Brooker publish?
He published animations of system behavior, including test examples involving PostgreSQL 16 and etcd, to explain how load increases can be followed by persistent performance problems.
Were the system results generated by AI?
Brooker says the animations were generated with Kiro and KiroCrew, mostly using Opus 5.5. He says the underlying results came from traces captured in a real test environment; the post does not present the AI as having produced those test results.
What does the PostgreSQL example show?
In Brooker’s test, a load spike uses memory for queries, displacing part of the working set from the page cache. Requests then rely more on disk and run more slowly, according to his account.
Does the post show that all etcd clusters can get stuck?
No. It describes specific test scenarios and does not establish that every etcd cluster will behave the same way. Brooker says one example showed a feedback loop that required intervention, but the post does not provide enough detail to determine how widely that result applies.
What remains untested?
Brooker says he believes allocator work could produce similar effects in a runtime without garbage collection, but has not reproduced that behavior. The post also leaves broader repeatability and deployment-specific risk unresolved.
Source: hn
Fall Picks
fall essentials
As an affiliate, we earn on qualifying purchases.
