API Maker

The backend engine for the AI era

Root & adminsEpisode 43 6:41 13 chapters November 2026

Root User, Admin Accounts and Installation Settings Explained

One API Maker installation can serve many projects. The root user opens an admin account for each one and sets what every server of the installation runs with, from one page: Deployment Settings checked by every server first, where each value comes from, sealed exports and Security Settings.

Next: Analytics Read the docs

In the playlists The complete course Run in production

Chapters

What you will learn

  • Three roles
  • The home of root, and a new admin account
  • What an account gets, and sample code to copy
  • Deployment Settings, every server asked first
  • Where each value comes from
  • Export with its secrets sealed, Security Settings, and a new installation step by step
In the docsAPI Maker configuration
Transcript879 words · click a time to play from there

Intro

One API Maker installation can serve many projects. The root user opens an account for each one. And from one page, it sets what every server of the installation runs with.

Running servers, the usual way

Running servers is usually messy. Each server has its own environment file, edited over SSH. Nobody knows which server runs which value. A typo shows up only when a server does not start. And a new project waits for a database script. With API Maker, root opens an account in one dialog. The settings of every server live on one page. Every server is asked before a value is saved.

And the export seals its secrets with a password. In this video: three roles, the home of root, a new admin account, Deployment Settings, a change checked by every server, where each value comes from, an export with sealed secrets, and Security Settings.

Three roles

The root user runs the installation. It opens admin accounts, one for each project or each customer, each with its own API path. An admin builds the APIs of the project, and adds developers, each in their own workspace.

The home of root

Root signs in to a home with three sections: the analytics of every account, the admin accounts, and the settings of the installation. Root builds no API, so the menus of a project are not there. Its user menu has My Security, for its own second factor, and Logout.

A new admin account

Admin Users lists the accounts of the installation. Add one. The name is Tom Becker, with the email he signs in with, a password, and an API path. Calm dash Q A is refused. The path is part of every address, so it must be lower case. calmhome_qa is right. With Insert Default Data off, only the default secret, group, and API user are made. With it on, which is the default here, a sample shop is made too.

Save it. The account is made with a secret, a group, an API user, and a sample shop, ready to use. Every new account gets a default secret, a default group, and the API user default. With Insert Default Data, it also gets a sample shop on MongoDB, with schemas, auth providers, and custom APIs to learn from. Its API path is unique in the installation. Turn Active off, and it cannot sign in.

Delete it, and everything it owns goes with it. Tom signs in for the first time. He sees his own dashboard, and code to learn from. Open his custom APIs, and the samples. Most of them are No-Access, so only code of the account reaches them. The sign in samples are public. Open Deep Populate Orders. Its settings say why, and its code explains each line. People copy them, and so do AI assistants.

Close it. From the menu, open Utility Classes. DefaultUtils has helpers that any code can use.

Deployment Settings

Deployment Settings is one page for every server. The bar says how many servers answered. The cards go from logging, databases, and Redis, to security, where secrets show as not set or as dots, never as plain text. API Access lets the code of your sign up system make accounts, as video seventy two shows. Then come the sandboxes. Each setting says what it is, its default, its range, and its name in a dot env file.

Every server asked first

Change the time a run of code can take, to fourteen seconds. The row says unsaved. Click Save. Every server is asked if it could start with the new value. It applies after a restart. Click Cancel, and discard.

More cards

Nothing was saved. SSR websites has its own card: the threads that render, the memory and time of a page, and the size of the page cache. Servers lists every server that answered, with its version and its folders, and a button to restart it. And History keeps every change, with who made it. Secrets show as dots.

Where each value comes from

A value can come from six places. The built in default, a settings file, this page, the dot env file of a server, the environment of its process, and the command line, which wins. Each row says where its value comes from, on each server.

A sealed export

Export writes the saved values to a file. You can keep it, or import it into another installation. Values go as they are, but secrets are sealed with a password, typed twice. Nobody can read them without it, not even API Maker.

Security Settings

Security Settings decides how everybody signs in: one time codes by email, an authenticator app, and recovery codes. You can tune the codes: their length, how long they last, and how many tries. And a card opens Outgoing Email, the page of the mail server that sends them.

First steps

On a new installation, root does it in this order. New passwords for the two default people. The log database and Redis. The mail server, then two step sign in. Its own second factor. An admin account for each project. And a sealed export of the settings.

Recap

To sum up. Root opens an admin account for each project. Every server reads one page of settings. Every server checks each change first. Each value says where it comes from. And exports seal their secrets. Next: analytics and observability. API Maker. Build faster, spend smarter, deliver better.