How API Maker Works: The Life of a Request, from Your App to Your Data

Intro

0:00 API Maker is a server you install, not a library you add to your code. In this video, the life of one request, from your app to your databases and back, and the pieces that make it work.

A backend, the usual way

0:13 A backend usually means a web framework, an auth layer, a cache, a job runner, and a deploy pipeline, glued together by hand, each with its own rules. With API Maker, one server does all of it, every request takes the same path, through the same checks, and everything you build is a file in git. In this video : the life of a request, one base URL, two tokens and two gates, where your code runs, the servers, what a save does, and git.

The life of a request

0:43 Follow one request. Your app calls a URL, with the token of its API user in a header. Caddy ends HTTPS, and passes the call to API Maker, on one port for the APIs and the WebSockets. The token and its groups come first : no valid token is a four hundred and one, and no group that grants this API, a four hundred and three. Then your pre hooks run : they can add a filter, change the request, or answer at once.

1:13 The API itself : a table, read or written through its schema, your code in a sandbox, or a system API. With caching on, Redis answers first. Post hooks can reshape the answer, and the reply goes back in one envelope. Subscribers of WebSockets are told, and the call is logged and counted.

One base URL

1:34 Every API lives under one base URL, in four families. Schema APIs : the operations of every table, through its schema. Generated APIs : the same operations, without one. Custom APIs : your function, in one of eight languages, on the path and method you choose. System APIs : ready ones, for tokens, encryption, the cache, events and indexes. And code nobody calls over HTTP : events, schedulers, initializers, migrations, hooks and test cases.

2:09 API Maker runs it for you. In the panel, every table lists its APIs. The products of MongoDB : thirty four, seventeen through the schema, and the same seventeen without it. Nobody wrote them. A URL of a table reads left to right. The family, schema. The API path of the account, calmhome. The instance, mysql, the database, sales, and the table, orders. Then the operation : none, for get all.

2:41 The query follows in plain parameters. And the answer : success, the status code, and the data. Every API answers in this envelope.

Two tokens, two gates

2:51 Two tokens. The API user is an application : your web app, your mobile app, a partner. Its token goes in x-am-authorization, and its groups are the API gate : which APIs, tables and fields it may use. The person is a row of your users table, or a Google, Microsoft or AWS identity : an auth provider makes its token. A pre hook is the row gate : of the rows an API reaches, only the person's.

3:21 Public APIs skip both. A new account allows everything : replace its default API user and group before you go live.

Where your code runs

3:31 Your code runs beside the server, not inside it. A sandbox is a Docker container of the account and its language, with only the packages the account adds, and a time limit for every run. Eight languages : TypeScript on Node.js or Bun, Python, PHP, C#, Go, Rust, Java and Kotlin. Code marked run on native process runs on the machine itself : for a browser, or the lowest latency.

3:59 Settings and schemas are TypeScript that API Maker runs the moment you save. And all of it gets the same g : the request, the response, and every API of API Maker. From the dashboard, Sandbox Settings : the eight languages, each with the image it runs in, ready on this server. Python : its image, and the packages of the account. Nothing is downloaded while code runs.

The servers

4:26 On a server, API Maker is one program, run by systemd, its threads on every core. Caddy stands in front, for HTTPS. MongoDB holds the data of API Maker itself : accounts, schemas, code and logs. Your data stays in your databases, wherever they are. Redis holds the cache, the counters, and what the servers share. The admin panel is served by API Maker, on a port of its own.

4:55 More servers behind Caddy make a cluster : a save reaches every server through Redis, and each scheduler runs once per tick.

What a save does

5:04 A write through a schema API passes these stages, in order. Keys the schema does not know are refused. Values get their types, text is trimmed and cased, defaults filled in. Your conversion function runs. Fields are encrypted or hashed, ids are made, then the rules and your validator decide. Anything wrong comes back at once : four hundred, one entry per problem, and nothing is saved. Generated APIs skip all of it.

Everything in git

5:33 And everything you build is a file. Schemas, settings, custom APIs, hooks, events, schedulers, utility classes, migrations, test cases and the security report live in one git repository. The panel commits and pushes, and a pull on another server is the deployment. Secrets never go to git : each server keeps its own.

One path for every request

5:55 That is the point of one path. Every request meets the same gates, the same hooks, the same envelope and the same logs, whoever wrote the API : you, a teammate, or an AI assistant. Code an assistant writes can not skip a check : the check is not in its code.

Recap

6:12 To sum up. A request : token and groups, pre hooks, the API, post hooks, one envelope. Four families under one base URL. Two tokens, two gates. Code in sandboxes, in eight languages, with one g. One program per server, MongoDB and Redis beside it. Everything in git. Next : your first API, in ten minutes. API Maker. Build faster, spend smarter, deliver better.