API Maker
The backend engine for the AI era
Index MakerEpisode 30 9:40 13 chapters November 2026
Index Maker watches the database queries of your APIs, tells you which ones read a whole table, and gives them the right index, on six database engines. Follow one slow API on a table of a million order events: one run of its custom API in API Testing, a scanning period, query shapes, one verdict on six engines, suggestions ranked by cost, the index form, and the same call fast again.
In the playlists The complete course Performance
Index Maker watches the database queries of your APIs. It tells you which ones read a whole table, and it gives them the right index, on six database engines.
Most teams find a missing index when production is already slow. Then someone turns on the slow query log of one database. They read query plans in six different formats. They add an index by guessing, and forget it in the next environment. And new queries, written by people or by AI assistants, keep coming. With API Maker, a scanning period records the real traffic of your APIs. Every engine gives the same verdict.
The index is created from the suggestion, with a name that is the same everywhere. In this video: a slow API, a scanning period, what it records, the index check on every engine, the suggestion and the index form, and the same call, now fast.
Calm Home keeps the history of every order in sales dot order events. It is a MySQL table with one million rows. The order tracking page asks for the events of one request id. But nobody added an index on request id. So the table is read from the first row to the last, for one answer. In API Testing, pick Get all of order events, with a find on one request id.
Send. One row comes back, and the bar shows the time: hundreds of milliseconds, for one row, on every call. With real traffic, that is seconds of database time every minute.
Behind that page is a custom API, Order Tracking. Send it from API Testing, and open its Index Maker tab. It shows every database call of this one run. There are eight calls on five tables, with their time, their rows, and how many used an index. What matters most comes first: order events reads the whole table. It also finds a query inside a loop. The products are asked four times, once for each item.
One query with dollar in gets them all in one call. The timeline shows when each call ran. Order events takes most of the run, while every other call takes a few milliseconds. Suggestions names the index it needs, on request id. That was one run of one API. To see every API under real traffic, record a scanning period.
Index Maker is in the Database menu. The page has two cards. Automatic indexes, on the left, runs Index Maker by itself, and it has its own video. Scanning periods, on the right, is where you record on purpose. A scanning period is a window of time. During it, API Maker records the database queries of your APIs. Click Add new, give it a name, and start it now. In Run for, pick ten minutes.
Save it. There is no slow query log to turn on, no profiler, and no restart. The chip says it is recording, and when it ends. By default, a period watches every instance API, and the system APIs that query a database. Pick a category, and the panes below make it smaller. Untick all instances, then pick mysql, sales, and order events. Then save the scope with the icon of the row.
While the period records, the shop runs as usual. Order tracking asks MySQL by request id. Product pages ask MongoDB by SKU. Category pages ask MongoDB by category. The account page asks PostgreSQL by email. Calls that differ only in their values are one query shape. So forty calls with forty request ids are one shape, with its calls, rows, and time. Up to a hundred samples keep the real values.
Cached answers and failed calls are not recorded.
Now the period has data. Select it, and view the analysis. Check index usage asks every database, in its own way, if each shape uses an index. The summary shows the queries recorded, the query shapes, the time spent reading whole tables, and the slowest shape. The ring shows how much of the work an index served. Each engine explains a query in its own words. MongoDB says index scan or collection scan.
MySQL and MariaDB name the key of the plan. SQL Server says seek or scan. PostgreSQL is asked with sequential scans switched off, so an index that can serve is used. Oracle prints its plan lines. Index Maker turns all of them into one verdict: full, partial, or none. Below the summary, where an index helps most ranks the shapes without an index by their cost: calls times average time.
Order events by request id comes first, by far. DB Queries lists every shape the period recorded, with its operation, its table, its verdict, its calls, and its time. The eye icon opens the samples: forty calls of order events, each with its own request id, and each reading the whole table.
Suggestions keeps the shapes that read a whole table, the most costly first. Each one offers three ways. Create the index now, on this server. Add it to the migration script, so every environment creates it on deploy. Or let Index Maker decide. Add to script asks first. The script is the topic of the next video, so not now.
Create index opens the index form, already filled from the recorded query. Request id is marked as used in the query, and it is selected. The name is built from the table and the fields, so it is the same in every environment. On the right, you see the size of the table, its existing indexes, and the fields that no plain index can hold, with the reason. The options follow the engine: index type and method for MySQL, or unique, hashed, and text for MongoDB.
We leave the script for the next video, and create the index. Now click Check index usage again. The time spent reading whole tables drops to almost nothing, and the ring grows. The recorded times stay as they were, because they are the history of the period. In DB Queries, order events now says full: the index serves the query from start to end.
Back in API Testing, we pick the same API again: Get all of order events, with the same find on the same request id. Send. The same row comes back, now in milliseconds. Nothing changed in the API, the code, or the app. Just one index, on the right column. And Order Tracking? We send it again. Its Index Maker tab has one thing left to look at: the products, asked one by one.
On the timeline, order events is now a short bar, like the others. Every index that Index Maker creates is written to its log: the operation, the table, the name, the fields, where it came from, and when. And on the Instance API page, the index list of order events shows it, next to the primary key. From there, you can also create or drop indexes of any table, on any engine.
The name is always built the same way: am ix, the table, the fields, and a short hash of both. It does not matter if the index was made by hand, from a suggestion, or in automatic mode, on development or production. The same index gets the same name, cut to the length limit of each database. So no environment ends up with two copies of one index.
Here are the best practices. Record during real traffic, not on an empty server. Check index usage after every release that adds queries. Index the most costly shape first, not every suggestion. Switch on log internal queries when deep populate or unique checks are involved. And keep the indexes in the migration script, so every environment gets them.
That was Index Maker. A scanning period records the real queries of your APIs. Six engines give one verdict. Suggestions come with the most costly first. And an index comes from the form, with one name everywhere. Next, Index Maker on its own: automatic indexes. API Maker. Build faster. Spend smarter. Deliver better.
Length 9:08Automatic indexes
Length 5:30Why Rust
Length 15:18Built in
Length 7:03Scale out