API Maker

The backend engine for the AI era

AnalyticsEpisode 44 12:53 18 chapters November 2026

API Analytics and Monitoring Built In: RED Metrics, p95, Apdex, Live

API Maker measures every call of every API, with nothing to install and no code to write. Read the RED numbers, percentiles and Apdex, follow an error down to the request that caused it, and watch your servers live: memory, disk, Docker, storage and process logs.

In the playlists The complete course Run in production

Chapters

What you will learn

  • Every call counted after its answer, in one minute rollups
  • Slots, percentiles and Apdex
  • Health, alerts and the RED numbers
  • From the alert to the Errors tab, down to one request
  • Custom APIs and schedulers
  • Speed and traffic in every grid: the slowest API flagged
  • Live, memory, disk, Docker and storage
  • Every server, and the root user's view
In the docsServer dashboard
Transcript1842 words · click a time to play from there

Intro

API Maker measures every call of every API. There is nothing to install, and no code to write. In the next few minutes, you read those numbers, follow an error down to the request that caused it, and watch your servers live.

Monitoring without the glue

To see how their APIs behave in production, teams usually add an APM agent to every service, and a metrics middleware to every endpoint. They build dashboards, and write alert rules. And they open SSH on each server to read its memory and its logs. It takes weeks, the tools cost money every month, and each new endpoint must be measured again, whoever wrote it. In API Maker, every call is measured from its first request.

One page shows it all, with alerts built in. And every server answers the same questions. Here is the plan. How API Maker counts. Real traffic on six databases. The Overview. An error, followed down to its request. Percentiles and Apdex. Live numbers, memory, Docker, and storage. The view of the root user. And the servers and their logs.

How it counts

First, how it counts without slowing anything down. A caller sends a request, and API Maker answers it. Only after the answer is written, the call adds one to counters in memory. Each thread has its own counters, so threads never wait for each other. Once a minute, each server writes one small document for each API, with the counts of that minute. An index with a time to live keeps them for thirty days.

The Analytics page reads these summaries, not your logs. So turning logging off does not make it blind. Each summary holds the calls, the errors by status class, cache hits, bytes, and rows. It also holds the time of every call, sorted into twenty four slots, from one millisecond to one minute. A percentile is read as the top edge of its slot. So a p95 of twenty milliseconds means that ninety five percent of the calls finished within twenty.

It is never too hopeful. Apdex scores the same slots. Under half a second is good. Under two seconds is tolerated, and counts as half. And the start of a sandbox is never counted against your API.

Real traffic

Now, real traffic. For five minutes, the Calm Home shop calls its APIs on all six databases. Products from MongoDB, customers from PostgreSQL, orders from MySQL, stock from SQL Server, employees from Oracle, and coupons from MariaDB. There is also a custom API, and a scheduler. Real traffic brings real problems. A sign up form forgets the last name. A retry sends an email that is already taken. An old app calls without its token.

And a report sorts a million order events.

Overview

Open Analytics, in the Operations panel. Every number on the page is measured over the time range of the toolbar. Pick the last fifteen minutes. Live refreshes the page every thirty seconds. Pause it while you read. Then come seven tabs, from the Overview to the storage of the analytics themselves. At the top, you see the health of all servers, judged by rules built into API Maker. One rule fires here.

The error rate of the last fifteen minutes is above its five percent limit. Other rules watch the p95 latency, the memory, and the disk. They also watch a runtime that falls behind, a server that stops answering, and two versions running side by side. You set up no alerting tools. Below are the RED numbers. Rate: the calls, with the average, and the busiest minute. Errors: the error rate, and the successes, split by status class.

Duration: the p95, with p50 and p99 under it, then the minimum, average, and maximum. And cache hits, bandwidth, and the rows returned, across all six databases. The charts show traffic and latency, minute by minute. Not sure what a healthy number is? The question mark explains each one, with the range it should stay in. Further down, you see calls by category, traffic for each server, and four lists.

The busiest APIs. The APIs that take the most time in total. The slowest by p95. And the ones with the most errors. Any table turns into a chart in one click. Read the total time list before you cache or speed things up. A fast API called all day can cost more than a slow report.

Error drill-down

Now, let us follow an error. Click the error rate alert, and it opens the Errors tab. Client errors, the four hundreds, are kept apart from server errors, the five hundreds. The APIs that fail most are listed first: the insert of customers, on PostgreSQL. The APIs tab has one sub tab for each kind of API, each with its calls and its errors. Open Instance APIs, the generated APIs of your tables.

You see the same tiles, plus Apdex. It is one score that can compare a five millisecond lookup with a two second report. Filter by customers, and open the insert. You see its own numbers: runs, failures, percentiles, payload, and the status split. The four hundreds come from the sign up form, and the five hundreds come from the retries. Why did it fail? Sample requests keep the newest five failed calls and five good calls of every API.

They are kept in the memory of each server, never in a database. Open the newest one. The status is five hundred, because the database refused an email that is already taken. You see the body that the retry really sent, and the request id, to find the whole call in the Log Explorer.

Percentiles and Apdex

Now the slow report. Widen the range to six hours, filter by order events, and open its query API. Its p95 and p99 are counted in seconds, and its calls pile up in the slow slots. For the whole category, the distribution shows each slot with the running total. The heatmap shows when these APIs are busy, by day and hour. A million rows without an index. Index Maker, in video thirty, fixes exactly this.

Every kind of API

Every kind of API is measured the same way. Here are custom APIs, like Daily Sales Summary, with its cache hits and the time its code spent in the sandbox. And here are schedulers, like Restock Check, every thirty seconds. Nobody waits for a scheduler, so its duration matters more than its percentiles.

In every grid

These numbers also show up in the grids where you work. They are read once for each grid, never once for each row. Open Instance API, postgres, and crm. Each table shows its traffic: the calls of its APIs added up, with their average time. Open customers. Every API shows its speed, its calls over the day, and the size of its answers. The insert shows a red failure rate.

The pill of the grid opens its insights. You see the calls, the average, the p95, the failures, and the Apdex of the table. Then come its busiest APIs, its slowest ones, and its largest answers, if it has any. Then come the ones that fail most. One click opens the insert. You see its average and its Apdex, five latencies on one scale, and its calls and speed over the day.

You also see the four hundreds from the sign up form, next to the five hundreds from the retries. Now the report. In mysql, and sales, order events stands out in red. Its query API has the hourglass icon of the slowest API. Its average and its p95 are counted in seconds, and its Apdex says poor. Click Open in Analytics, and you land on its details, for the same day.

There is nothing to search for. The slow API finds you.

Live

The Live tab asks every server, every three seconds, what it counted since the last look. You see requests per second, errors, latency, and bandwidth. You see all the servers, their memory and disk, a live chart, and the busiest APIs right now. There is one card for each server, with its version, threads, memory, runtime delay, CPU, and uptime. You can watch a load test or a deploy, without SSH.

Memory & Disk

Memory and Disk keeps one sample for each server and minute, for thirty days. The operating system of this laptop reports how much of its memory is in use. API Maker itself takes only a small part of it. The history draws memory, CPU load, runtime delay, swap, and disk for each server. A restart shows as a break in the line.

Docker

The Docker tab reaches the Docker service of every server. An admin sees only the containers and images that API Maker built for the account. Here are the sandboxes of Calm Home that run its custom API and its scheduler. You get their logs, their CPU and memory history, a restart button, and a safe prune that frees disk without touching any data.

Storage

Storage Of Analytics shows what the analytics themselves cost: metric rows, vitals rows, thirty days kept, and a write every sixty seconds. Clear stats wipes your saved analytics, after you confirm. We keep ours.

Root user

The root user opens the same page from its own home, with every account of the installation in view. On the Live tab, only root can restart a server. The server finishes the requests it is answering, stops, and starts again, while the other servers take its traffic and its schedulers. Not today.

Servers

Back on the account, the Operations menu opens Servers. You see every server of the installation, with its version, threads, runtime, the runtimes of its sandboxes, and its machine. Then you see the settings that matter, from how long tokens last to the largest body accepted, and the database pools of your account. After a deploy, one look tells you that every server runs the same version, with the same settings.

Process logs

Native Process Logs reads the output file of any server. It is the file named by the log file path setting, which the service of the installer writes. Pick a server and reload, download the whole file, or reload it every five seconds. This file holds the start of the server, its threads, and everything it prints while it runs. No SSH to read each machine.

Standard

Why does it matter? Every API, written by you, by a teammate, or by an AI assistant, is measured the same way from its first call. Nobody has to remember a counter, a log line, or an alert. A lookup, a report, and a cron job get the same columns, percentiles, and rules. And the request path is never slowed.

Recap

To sum up. Every call is counted after its answer, in one minute summaries kept for thirty days. Every kind of API gets RED numbers, percentiles, and Apdex. An error can be followed down to the body that caused it. You get live numbers, memory, Docker, and storage. And every server, with its settings and its logs. Next, logging: every detail of a call, in the Log Explorer. API Maker.

Build faster, spend smarter, deliver better.