Our CTO shared a blog on GitHub’s reliability, what we’ve already done, and what more we need to do to.
Monthly commits and merged PRs alone have nearly doubled since April. As the home for devs, availability is critical. I'm sorry for the pain and thankful for the support. 🙏
Another FDE here! 👋 Are you more excited to hear about a day in the life of an OpenAI FDE, about strategies for being effective with AI tools, or what we’ve learned by deploying in specific industries?
Also…do you want videos? 👀
A good technical LLM interview question:
Your LLM chatbot takes 12s before it generates the first token, and the users are complaining.
So you move the model onto a GPU with 3x the computing power.
The time to first token barely improves.
Why did this happen?
(answer below)
Latency in an LLM app is a placement problem disguised as a model problem.
If you profile the 12 seconds, the model's prefill itself may only account for around 1.5 seconds of it.
So halving the prefill step saves just 750ms out of 12000, which is under 7%.
The rest is spread across stages that never touch the GPU.
The request first travels to whatever region the app runs in, and a cross-continent round trip could cost over a second before any code executes.
Then the request handler starts. On a container-based serverless platform under load, this adds several seconds of cold start, paid before auth, rate limiting, or prompt assembly even begins.
Retrieval adds its own hop, and the response streams back across the same distance.
Optimizing a stage that was already fast cannot alter the latency that's majorly affected by other stages.
Those other stages are slow for a structural reason.
An LLM app runs two workloads that want opposite machines.
- The request path is short, spiky, and needs to sit close to users
- Inference is long-running, GPU-bound, and billed hourly, whether requests arrive or not.
So the actual decision is not which model to run, but where each of these two workloads runs.
There are three options, each with its own tradeoffs:
> A dedicated GPU box removes inference cold starts, but it bills around the clock and lives in one location, so distant users wait out the round trip on every request
> Container-based serverless scales to zero, but the request path pays a cold start, and most of these platforms have no GPU behind them.
> Edge runtimes start in under a millisecond, because a WebAssembly module carries no OS or container image to boot. They handle the request path well and cannot hold a model.
So the answer is not to pick one, but to split the app across two of them.
The request path runs close to users, and inference runs on a dedicated GPU it calls into.
That also explains the failed upgrade. More compute made a stage that was already fast faster, and left the 10.5 seconds around it untouched.
To actually learn how it's done in practice, Akamai's GitHub has a reference implementation for each half.
- vllm-on-lke serves Qwen2.5-7B-Instruct behind an OpenAI-compatible endpoint on one RTX 4000 Ada GPU in Linode Kubernetes Engine, with Terraform creating the cluster, both firewalls, and the GPU operator in one apply.
- akamai-functions-llm-chatbot covers the front, where a WebAssembly API checks a KV cache and only calls the GPU-backed instance on a miss.
Both are available on Akamai’s new Developer Hub, alongside their tutorials and code samples.
It also links to Edge Case, their Discord, where four developer advocates architect and deploy a production app live every other Wednesday.
If you create a new Akamai Cloud account, you can also get $300 in credits for joining.
Join here: https://t.co/ge5fJ7jbtS
That said, this post treats generation as a single 1.5s block, but that block has its own structure, and knowing it well tells you whether a model is slow to start or slow to stream.
I wrote a first-principles walkthrough of it, covering the prefill and decode split, KV caching, and where the time actually goes inside each one.
Read it below.
Thanks to Akamai Cloud for partnering today!
Ex-Google Jeff Dean:
"The biggest shift in AI right now - AI agents and graph-based engineering aren't hitting a wall.
They're pushing compute requirements so far that we'd have had to double every computer Google owned"
A decade of Google AI infrastructure, in 25 minutes, from the person who built it.
He sits on Google's best research for months before the world ever sees it.
Watch it, then read the guide below on building a agents that runs without you
生成AI使っててこれは編集者の仕事に近いんじゃないかと天啓を得ており、手当たり次第に有名な編集者の本(Peter Ginna 編『What Editors Do: The Art, Craft, and Business of Book Editing』(University of Chicago Press, 2017)、花森安治、菅付雅信など)買い集めてたところだった。
Interviewed a Senior Backend Engineer recently.
Strong candidate.
Microservices? ✅
Kafka? ✅
Redis? ✅
Load balancing? ✅
Then I asked:
"You're designing an API used by 10 million users."
One user starts sending 10,000 requests per second.
Your backend is getting hammered.
You need to enforce:
100 requests per minute per user.
Sounds easy.
Then I added a few constraints:
→ 100+ application servers
→ Requests can hit any server
→ Multiple requests can arrive simultaneously
→ Servers can scale up/down dynamically
→ The limit must be consistent across servers
→ You can't maintain the counter in application memory
Now the obvious solution doesn't work.
How do you design a distributed rate limiter?
Where do you maintain the counters?
How do you handle concurrent requests?
What happens when 1,000 requests arrive at exactly the same time?
And which algorithm would you choose?
Fixed Window?
Sliding Window?
Token Bucket?
Leaky Bucket?
Your turn. 👇
How would you design it?
There's a reason Redis is commonly involved in this problem.
📌 Bookmark this.
The solution comes tomorrow.