API Maker
The backend engine for the AI era
Table designerEpisode 54 12:35 16 chapters November 2026
Make databases and tables on MongoDB, MySQL, MariaDB, PostgreSQL, SQL Server and Oracle right in the API Maker panel. Design column by column, read the statements written for your engine before they run, run scripts of your own, edit tables as ALTER statements, and keep the schemas of API Maker in step, both ways.
In the playlists The complete course Databases & schemas
MongoDB, MySQL, MariaDB, PostgreSQL, SQL Server, and Oracle. You can make their databases and tables right in the panel. You design them column by column. The statements are written for your engine, and shown before they run. And the schemas of API Maker stay in sync.
Making a table usually means extra work. You need a SQL client for each engine, and six ways to write CREATE TABLE. You write ALTER statements by hand, and one typo loses a column of data. And your APIs learn about the change only when a call fails. With API Maker, there is one designer for six engines. The statements are written for your engine, and shown before they run.
And the schema of every table stays in sync with it. In this video: a new database, a table designed column by column, one design on six engines, your own scripts, a table edited, a table and its schema back in sync, MongoDB collections, removing safely, and renaming, with the schemas along.
Calm Home starts a loyalty program, Calm Rewards, and it needs a database. Open Instance API, pick the PostgreSQL server of the instance postgres, and click Add New Database. Its name is loyalty. PostgreSQL takes an owner, a template to copy, an encoding, and a locale. If they are empty, the server uses its own. Below, you see what will run on the server, written as you type. Click Save Database.
loyalty is there, with no table yet. Each engine asks for what its databases need. On MySQL, a new database has a character set and a collation, and it runs only when no database of that name exists. On Oracle, a database is a user. Until it has a password, the dialog says so. The password is sent once, kept nowhere, and shown as stars. Then come its tablespace, and what the user can do, as grants.
And MongoDB keeps a database only once it holds a collection. So a first collection
is made with it. Now its first table. Click Design a new table. The designer reads what PostgreSQL offers, and starts with a key, id, a bigint that the database numbers. Its footer always says where the design stands. Here, the table needs a name. Name it members, and add a comment. It is ready. The statements are written while you design. Add a column. Name it customer_id, the customer of the CRM.
Its type comes from the list of PostgreSQL: fifty four types in groups, each with what it holds. Type bigint. Pick it. Every member has one, and no customer joins twice. Then, add the points. It is an integer, never empty, with a default value of zero. Under More, add a check: points never go below zero. The usual columns take one click. Created and updated are two dates that the database fills.
Now the indexes. Add one, on points, the largest first, for the leaderboard. Its name is made for you. Open the SQL tab. There are three statements, written by the server for PostgreSQL. First the table, with its key, its unique customer, and its check. Then the index, and the comment. Nothing has run yet.
Here is the same design on every engine: a key, an email, an amount, a yes or no, and two dates, all quick columns. MySQL numbers the key with AUTO_INCREMENT, sets updated_at on every change, and names its engine and character set. PostgreSQL uses an identity, timestamps with their time zone, and now. SQL Server uses IDENTITY one one, a named constraint for each default, and a batch that ends with GO.
Oracle uses NUMBER nineteen, an identity on null, and a check that keeps a yes or no to one and zero. MongoDB uses a collection that checks every document against a JSON schema, and a unique index. And MariaDB writes what MySQL writes. One design, and each database gets what it understands.
Click Create table. It is made. And API Maker asks: make its schema now? The APIs with a schema check every write against it. Its code is written from the table: the key numbered by the database, the required columns, and their types. You can change it before it is saved. Make the schema. Now public.members has its schema, and its twenty eight APIs are live, without a line of code.
Here is how it works. The panel sends the design, never SQL. The Rust core of API Maker checks it against what the engine allows, and writes the statements for that engine. You see them first. They run on your database, in one transaction where the engine has them. Then the schema follows the table, and the APIs are ready.
Some tables are quicker to write than to click. Open Run a SQL script. We write two tables and an index: rewards, and redemptions, which points to members and to rewards. On the right, you see the three statements as PostgreSQL will get them, each with its line. It is all or nothing. PostgreSQL takes back what a failed script made. Click Run. The second statement fails: relation public.member does not exist, with its code and its line.
So the first one was taken back, and the third never ran. Nothing changed. Add the missing s, and Run again. Three statements are committed. Both tables are listed. Tables made by a script get their schemas from Bulk Schema Creation, as video two shows.
The program grows, with tiers and birthday rewards. Pick public.members, and click Edit the table. The designer reads it back from PostgreSQL, with every field filled: the columns, the key, the index, the check, and the comment. There is no change yet. points becomes a bigint, marked as edited. Add a new column, tier, of sixteen characters, never empty, with silver by default, so the existing members get one too.
And then, add birthday, a date. Did we remove updated_at by mistake? It waits below, with what it was, and the footer warns that a change can lose data. Put it back, and it never left. The SQL tab lists the three changes and their ALTER statements. They run all or none. Click Apply changes. Now the schema follows the table. The current schema is on the left, and the new one on the right, with tier and birthday added.
Your checks and comments are kept. Update the schema.
Tables also change outside API Maker, with a migration, or a colleague with a SQL client. Someone added referral_code to members, and dropped birthday. The row of members now has a mark. It means the table and its schema differ, and the tooltip says how. A click lists it, field by field. referral_code is not in the schema. birthday is not in the table. You can settle each one either way.
First, referral_code. The schema follows the table. Only what differs changes, and it is shown before it is saved. It is saved. Then birthday, the other way. The table follows the schema. The designer opens with birthday filled in from the schema, for you to review. The schema only says a date, and for a birthday, a day is enough. Click Apply changes. The mark is gone. The table and its schema say the same again.
MongoDB works the same way. On catalog, click Design a new collection. Name it gift_cards. Add a field, code. Every document has it, never twice. Then add a pattern of ten capital letters or digits. Quick add an Amount, named balance, never below zero, and the two dates. In the options, only the fields above are allowed in. Its shell script uses createCollection with a JSON schema validator, and the unique index.
Click Create collection, and make its schema.
Now removing, safely. Pick public.redemptions, and Permanently Delete. The dialog says what goes: rows, indexes, and keys. It shows the statement, and it takes the API Maker schema along. You type the name to confirm. It is removed. The database loyalty_test is where a colleague tried things. Pick DROP DATABASE, with its connections closed first, on any version of PostgreSQL. Type its name, and it is gone, with its schema.
Names change too. At the launch, the rewards are called perks, and the database takes the name of the program. Pick public.rewards, click Edit the table, and give its new name, perks. It is one statement: ALTER TABLE, RENAME TO. Click Apply changes. The table is renamed, and its schema goes with it. public.perks has its twenty eight APIs, under the new name. Now the database. Click Edit, and name it calm_rewards.
The schemas of its tables follow it. PostgreSQL renames a database only when nobody uses it, so the connections to it are closed first. Click Update Database. It is renamed, and two schemas moved with it. Here is calm_rewards, with members and perks.
Good to know. A table that is not made yet is kept in the browser. Open the designer again, and Restore brings it back. Before it applies, the designer reads the table again. If it changed in the meantime, it asks. PostgreSQL and SQL Server take back a failed script. MySQL, MariaDB, and Oracle run each statement by itself, and the designer says so. Scripts are split the way each client splits them: GO, the slash after a PL/SQL block, and DELIMITER.
And with Remember my choice, schemas follow their tables without asking.
It is built on standards. Nothing runs before you see it, and a change that can lose data is named. Schemas stay in sync with their tables, so the APIs check what the tables really hold. A script written by an AI assistant runs statement by statement, each with its result, its line, and its error. And removing always shows the statement, and asks for the name.
To sum up. You make databases from the panel, on six engines. You design tables column by column, with statements written for your engine. You run your own scripts, all or nothing. You edit tables, with the ALTER statements shown first. Schemas stay in sync with their tables, both ways, and are renamed with them. Next: schemas in depth. API Maker. Build faster, spend smarter, deliver better.
Length 7:01Schemas
Length 5:43Data types
Length 6:42Data safety
Length 4:56ER diagram