API Maker

The backend engine for the AI era

Why RustEpisode 53 5:30 12 chapters November 2026

Why Rust: API Maker Load-Tested Live on a $5 Server

API Maker is written in Rust. Put it on the smallest server Linode sells, five dollars a month, and load it live: 1,900 requests a second from MongoDB, 9,100 from the cache, memory flat at about 51 MB, and a restart in about a tenth of a second.

In the playlists The complete course Performance

Chapters

What you will learn

  • The server: a Linode Nanode, 1 GB and one shared vCPU
  • A minute of load with autocannon: 1,900 requests a second
  • Memory flat at about 51 MB, the CPU at 40 percent
  • Cached reads: 9,100 requests a second
  • A restart in a tenth of a second
  • Underneath: one native program, no garbage collector
  • The published numbers, and WebSockets
In the docsBenchmarks
Transcript793 words · click a time to play from there

Intro

API Maker is written in Rust. In this video, we put it on the smallest server that Linode sells, for five dollars a month. Then we load it live, to see what Rust changes.

The usual way

A backend on a heavy runtime usually means problems. It needs a bigger server than its traffic needs. It pauses when a garbage collector runs. Its memory climbs with the load. And it takes seconds to start again. With API Maker, there is one native program, compiled for the machine. There is no garbage collector, so memory is freed the moment it is not used any more. So memory stays flat under load.

And after a restart, it answers in a fraction of a second. In this video: the server, a minute of load, memory and CPU while it runs, the cache, a restart, what Rust does underneath, and the published numbers, with WebSockets too.

The server

Here is the server. It has one shared virtual CPU, and one gigabyte of memory. That has to hold API Maker, its MongoDB, its Redis, and two sandboxes. API Maker is one program. At rest, it uses a few dozen megabytes, on two threads.

A minute of load

From a second server on the private network, we run autocannon. It keeps a hundred connections busy for sixty seconds, on get all of a MongoDB table, read from the database every time. It sends over a hundred thousand requests. That is close to two thousand a second. Half of them are answered within about fifty milliseconds, and almost all within a hundred.

Memory and CPU

Meanwhile, on the server, we look every five seconds. API Maker uses about fifty megabytes of memory, the same from the first look to the last. It uses less than half of the one core. There is no pause, and no growth. And the rest of the core? It goes to MongoDB, on the same machine, and to the Docker proxy in front of it. Here the database is the limit, not API Maker.

The cache

Now a table with caching on. Get by id is answered from Redis. We get several times more requests a second, and almost every one comes back within twenty milliseconds, on the same five dollar server.

A restart

Now a restart: stop, then start. The first answer of an API comes after a fraction of a second. So an upgrade or a restart costs only that. There is no warm up.

Underneath

Why does it hold up? API Maker is compiled to native code for the machine. Its requests run on Tokio, where a few threads serve thousands of connections. Here, it uses two threads. Rust frees memory when its owner is done with it, at a known place in the code. So there is no garbage collector to pause the server. The compiler refuses code that could use freed memory, or race on data.

And the database drivers, the TypeScript compiler, and the JavaScript engine for light code all run inside the same program.

The published numbers

The published benchmarks go further. They load Linode servers of every size, in the same way. Get all grows from over two thousand requests per second on the five dollar server, to over twelve thousand on eight dedicated cores. Today's run is a little lower. This small server landed on another processor, slower per core than the one of the published runs. WebSockets too. This same kind of server held tens of thousands of clients at once, each with its tokens and a subscription, until its memory was full.

One server with eight cores and sixteen gigabytes held millions, with a few kilobytes for each client.

Good to know

Good to know. A shared CPU is shared. Runs differ by a few percent, and a neighbour can take some of it. The database ran on the same machine. On its own server, API Maker would have the core to itself. Every published page has the whole output of autocannon, and the memory of each process. Find them at docs.apimaker.dev, under Benchmarks.

Built on standards

The core is Rust. The compiler refuses the use of freed memory, and data races, before the server ever runs. It is one program, the same on every server, checked before an upgrade uses it. And your code, written by your team or by an AI assistant, runs on top of it, in sandboxes, with time limits.

Recap

To sum up. One native program runs on a five dollar server. It serves about two thousand requests a second from MongoDB, and several times more from the cache. Memory stays flat under load. A restart takes a fraction of a second. And the published numbers go over twelve thousand requests per second, and millions of WebSocket clients. Next: API Maker on your own server, with one command. API Maker.

Build faster, spend smarter, deliver better.