Back to the blog
NvidiaBunAIInfrastructure

GPU shortage manufactured by Nvidia? The Bun lesson

November 15, 2026·5 min read·Diego Horvatti

Nvidia is being accused of giving money to AI startups so they would buy Nvidia's own GPUs. According to the TechPowerUp report, this may have helped create a GPU shortage that wasn't just organic demand. It was, in part, demand funded by the seller.

It's an accusation, not a conviction. But it touches on something every dev who has ever asked for a GPU cloud quote knows well: the price of the waiting line.

What Nvidia allegedly did, in plain English

The setup is simple. Nvidia invests in a new AI or GPU cloud company. That company uses part of the money to buy Nvidia cards. Nvidia books the sale as revenue. The startup shows the market it has a huge GPU fleet. Everyone looks at it and concludes: demand is infinite.

This move has a name in finance: circular financing. The money leaves one pocket and comes back to the same pocket, with an invoice in between.

It's no secret that Nvidia holds stakes in companies that are big customers of its own. GPU providers like CoreWeave are the most cited example. What's new in the accusation is the effect: the waiting line for H100s and similar chips wouldn't be just a sign of demand. It would also reflect supply steered toward whoever was in the right ecosystem.

Nvidia, as expected, doesn't confirm this reading. And to be fair: investing in customers isn't a crime, and plenty of companies do it. The question is how much it distorts the price signal.

Why the GPU shortage matters to people who write code

You might think: "I build APIs in TypeScript, I don't train models." Fair. But the GPU shortage reaches you in three ways.

  • Inference pricing. The LLM API you call from your backend has a cost tied to hardware. Expensive hardware turns into expensive tokens.
  • Architecture decisions. Lots of teams put AI into flows that didn't need it, because "everyone is doing it". Part of that "everyone" was paid for with circular money.
  • Quotas and rate limits. When the provider tightens limits, your production endpoint is the one that suffers, at 3 a.m.

If demand was inflated, so was the price. And technical decisions made with inflated prices age badly.

Demand funded by the seller isn't demand. It's inventory under another name.

Where Bun comes into this story

Bun is the perfect counterpoint to this news. It was born from an almost old-fashioned idea: doing more with the same hardware.

No GPU involved. Just Zig, JavaScriptCore and obsessive work to cut startup time, package installs and I/O overhead. Anthropic bought Bun at the end of 2025 precisely because a fast tool that's cheap to run becomes an advantage when you have thousands of agents running code all day.

Notice the difference in logic. One side of the market grows by selling more hardware. The other grows by making the hardware you already have do more. Both are legitimate. But only one of them lowers your bill at the end of the month.

An HTTP server in Bun is still just this:

Bun.serve({
  port: 3000,
  fetch(req) {
    return new Response("ok");
  },
});

No framework, no extra layer. On a 2 vCPU VPS this handles way more traffic than most side projects will ever see. And you pay a few dollars a month, not an annual GPU contract.

What changes in your workflow

The practical lesson isn't "run away from AI". It's "measure before buying the narrative". A few habits I've adopted:

1. Ask whether the problem needs a model. Sorting tickets by keyword, validating a tax ID, pulling a date out of standardized text: a regex and a pure function solve it. Calling an LLM for that is like taking an Uber to the fridge.

2. Measure the cost per request. Add a simple counter to your AI endpoint and look at the real number.

const start = performance.now();
const response = await generateSummary(text);
const ms = performance.now() - start;

console.log({ ms, tokens: response.usage.totalTokens });

With this log you quickly find out whether that feature costs cents or is quietly eating your budget.

3. Cache what repeats. Lots of the questions hitting your backend are identical. An in-memory or Redis cache keeps you from paying twice for the same token.

const cache = new Map<string, string>();

async function summarize(text: string) {
  const hit = cache.get(text);
  if (hit) return hit;
  const r = await generateSummary(text);
  cache.set(text, r.text);
  return r.text;
}

Simple, with an obvious limit: the Map grows forever. In production you swap it for an LRU or Redis with a TTL. But starting like this already shows how much you save.

4. Prefer efficient runtimes and tools in the rest of the stack. If AI is the expensive part, everything else needs to be cheap. Swapping npm install for bun install in CI already cuts minutes of build time per day. CI minutes are money too.

But isn't AI demand real?

Mostly, yes. No serious person thinks the AI boom is just an accounting illusion. Models got better, agent-based coding tools became routine, companies are paying for it.

The problem is something else. When the seller funds the buyer, you lose the ability to separate what's real from what's being pushed. It's like measuring a restaurant's popularity by counting the guests the owner invited for free. The place is packed. But you don't know how many would come back and pay.

For devs, this means one thing: don't use hype as a project metric. Use your own logs, your own costs, your own users.

My take

I think this story will end like almost every infrastructure bubble: part of the investment will turn into useful capacity, part will turn into idle data centers, and GPU prices will drop when the music stops.

Until then, the best protection is technical, not financial. Write code that runs well on cheap machines. Use AI where it solves a real problem. And be suspicious of any shortage that happens to benefit the very people doing the selling.

Bun is a good reminder that efficiency is still a strategy. It doesn't make headlines, but it shows up on the bill. If you want to see how I apply this in my projects, take a look at what I've been building.

LinkedIn summary

Nvidia is being accused of funding startups so they would buy Nvidia's own GPUs.

If that's true, part of the famous GPU shortage wasn't demand. It was inventory under another name.

This reaches people who write code: pricier tokens, tighter rate limits and AI shoved into flows a regex could handle.

Bun shows the opposite path: getting more out of the hardware you already have. It doesn't make headlines, but it shows up on the bill.

My advice: measure the cost per request, cache what repeats and don't use hype as a project metric.

I wrote about it on the blog, with code. If it makes sense to you, the link is in the comments.

#Nvidia #ArtificialIntelligence #Bun #SoftwareDevelopment #CloudComputing