Product
You wrote the app.
We run the rest.
The Apps, the database and the models it calls. One key, one balance.
Latest deployment
Release v2.4.0
- GitHub / main
- Auto build / 42s
- Container started / port 3000
Release controls
Source
Repository or image
Runtime
State and restarts
Team
Roles and API keys
The platform
Seven things it does, as one system
Ordered the way the work happens rather than by how interesting each part is. Start at the one that matches the question you arrived with.
Connect
A repository, and one key you never see
Connect GitHub or GitLab once. The OAuth token stays in the control plane — a build server never gets it. Each app is given its own read-only deploy key instead, and that is the only credential that reaches the machine doing the build. Pushes arrive at a signed webhook and become deploys.
- GitHub and GitLab, connected once with OAuth
- A read-only deploy key per app — the only credential a build server sees
- Signed webhooks, so a push on your branch is a deploy
- Or bring a container image you already published and skip the build
Connected source
GitHubRepository
Branch
- Deploy key / read-only, this app only
- Webhook / signed, verified per push
a1c9f42 pushed · deploy queued
Build
Source in, container out
You should not have to describe your project to a build system that can read it. Most stacks are detected with zero configuration. Keep a Dockerfile and we use that instead. Static output skips the runtime entirely.
- Automatic detection of your stack
- Your Dockerfile, if you prefer it
- Static output served directly
-> detected: package.json, no Dockerfile-> provider: auto-detected (node 22)-> npm ci --omit=dev-> npm run buildimage built in 41s
Run
Route the service you built
Choose the port your process listens on, then connect a hostname when you are ready. After DNS verification, request a Let's Encrypt certificate from the dashboard instead of stitching the routing and certificate steps together yourself.
- Custom hostname verification and certificate requests
- Route a hostname and path to the port you choose
- Default platform addresses for provisioned apps
- Stop, start, or redeploy on demand
Attach a domain
Hostname
Certificate
https://app.acme.com
port 3000 · letsencrypt · added just now
Data
A database, without a second vendor
The usual answer is an account somewhere else, a second bill, and a connection over the public internet. Here a database is just another thing in your project: it comes up beside your app, private by default, and attaching it writes the connection string in for you. Need to reach it from your laptop instead? Publish it deliberately — the request is confirmed and recorded, and it answers on a name in our zone, so the connection string survives the database moving.
- PostgreSQL, MySQL, MariaDB, MongoDB and Redis
- Private by default — reachable only from inside your own project
- Connection string written into an app as a secret
- External access is opt-in, confirmed, and recorded
- Managed backups into our own storage, on or off per database
PostgreSQL
:5432 · backups available
Name
Plan
DATABASE_URL added to web
written in as a secret · app redeploying
Operate
When it breaks, the answer is on screen
A failed deploy should tell you why. Follow the build, inspect runtime logs, read back previous releases, and see who triggered them. Alongside them: what the container is doing right now — CPU, memory, and network and disk throughput both ways — with the state, health check and restart count next to the controls you need after reading them.
- Build and runtime logs in one app view
- CPU, memory, and network and disk throughput per container
- Container state, health checks and restart count
- Plain-language reason a container stopped
- Full history with status, duration and attribution
v2.4.0 done 18s Ada Lovelacev2.3.9 done 22s CI (API key)v2.3.8 error 7s Ada Lovelace build failed: missing DATABASE_URL
Scale
The numbers on the plan are the numbers on the container
A plan is two limits and a rate. The CPU and memory are applied to the container itself, so a process that asks for more does not quietly get it at a neighbour's expense. The rate is hourly and stops at the monthly price the plan is advertised at, and both apps and model calls draw down one prepaid balance.
- CPU and memory enforced as real container limits
- Metered hourly, and never past the advertised monthly price
- One prepaid balance for containers, databases and tokens alike
- Change plan, stop, start or redeploy without leaving the app
Enforced as container limits
Hourly- CPU
- 2 vCPU
- Memory
- 4096 MB
Metered this month
capped at the monthly price
drawn from one prepaid balance
Intelligence
The AI half, on the same control plane
The endpoint sits next to your apps, the key that deploys them authorizes it, and every call draws down the same prepaid credit as the containers. Nothing to procure, no second payment method, and nothing to reconcile at the end of the month.
- Chat completions, embeddings, images and video on the OpenAI request and response shapes, streaming included
- One organization API key for applications, automation, coding tools, and inference
- Inference cost and app cost from a single prepaid balance, reported side by side
- A public catalogue of every listed model, its capabilities, and what it charges — by the token, or per image or second
- Models offering zero data retention are labelled as such in the catalogue
- Embeddings your coding tool can index a repository with — and multimodal ones that index pictures into the same vector space — on the same endpoint and key
const client = new OpenAI({ baseURL: "https://inference.maxlayer.cloud/v1", apiKey: process.env.MAXLAYER_API_KEY,});ready for chat, embeddings, images, video
In the box
What every application gets
No add-ons and no tiers gating any of it. The plan sets the size of the container; everything below comes with all of them.
Build and ship
Fifteen runtimes detected
Node, Bun, Deno, Python, Go, PHP, Java, Ruby, .NET, Rust, Elixir, Gleam, C/C++, static sites and plain shell — read from the files in your repository, with nothing to declare.
Frameworks get their own start command
Next.js, Astro, Vite and Angular; Django, FastAPI and Flask; Laravel, Rails, Spring Boot and Phoenix. Detected by name, not served as a generic process.
Or bring your own build
A Dockerfile in the repository takes precedence over detection, and a prebuilt image from a registry skips the build entirely.
Push, and it ships
A signed webhook turns a push into a deploy. Each app gets its own read-only deploy key, and that is the only credential a build server ever holds.
Route and reach
A working address immediately
Every app gets a hostname on our own zone the moment it deploys, so there is something to open before you have decided on a domain.
Your domains, with certificates
Point a hostname at the app and the certificate is issued and renewed for you. No ACME client to run and no expiry to diarise.
Your database, by name
Apps and databases share one private project network, so an app connects to its database by name with nothing exposed to the internet.
Configuration and secrets
Environment variables per app, and secrets that are write-only once saved. Changing either redeploys the app that reads it.
Run and watch
Build logs and deploy history
What the build did, and every release before this one, with the commit each came from.
Container state and restarts
Running, stopped or restarting, and how many times it has restarted — read live rather than from a cache that can disagree.
CPU and memory per container
Actual usage against the ceiling your plan sets, sampled on an interval.
Stop it, and stop paying
Stop, start or restart an app whenever you like. A stopped app keeps its configuration and its domain and draws no credit. Changing plan resizes the container in place.
Four things deliberately not on that list, because they do not exist yet: an application runs as a single container, so there is no autoscaling and no second replica for redundancy; there is no one-click rollback, though every release is recorded; and pull requests do not get preview environments. If any of those is load-bearing for you, tell us before you migrate.
People and machines
Your team, and your automation
Access that matches responsibility — for the humans, and for the scripts.
- Roles
- Viewer, developer, admin, owner
- Each one a superset of the last.
- API keys
- Scoped to a team and a role
- Hashed at rest, dead the moment you revoke one.
- Secrets
- Write-only once saved
- Replace them freely; nothing reads them back out.
- Audit
- Sensitive actions are recorded
- Both tenant and platform, so what happened can be traced.
API
Anything you can click, you can script
The dashboard is just one client of a documented REST API — creating apps, updating environments, triggering deploys, reading logs. It gets no endpoints you do not.
Asked first
The questions we get before the signup
Including the ones that are not in our favour.
Do I need a Dockerfile?
No. The build detects your stack itself and works out how to build it, which covers most stacks with nothing to configure. Already keep a Dockerfile and would rather use it? Choose the dockerfile build type and we will.
Do you back up managed databases?
Yes, and there is nothing to set up: backups are on or off per database, stored by Maxlayer in our own storage on the server your database runs on, and they cost an extra 30% of the database's plan while on. Two limits we would rather state than have you discover: Redis cannot be backed up, and restoring is manual — a backup is a dump file, and putting it back is something you do.
Do I need a separate account for the AI part?
No, and that is most of the point. The organization API key that deploys your apps authorizes chat completions, embeddings, images and video, every call draws from the same prepaid credit as your containers, and the usage shows up in the same dashboard. The public model catalogue lists every model we sell, its capabilities, and what it charges — a rate per million tokens where the model has one, and the provider's own price per image or per second where it does not — so you can read the price before you send a request.
What if I only want the apps, or only the inference?
Then that is what you pay for. Nothing here is a bundle: credit is credit, and it is drawn by whatever you actually run. An account that never calls a model is never charged for one, and an account that only calls models never has to deploy anything. All-in-one means one place and one balance, not a package with parts you did not ask for.
Can I see my container's runtime logs?
Yes. The Logs tab gives you the container's runtime output alongside the build and deploy output for each release. It is there to help you diagnose a running service; if you need long-term retention, aggregation, or alerts, keep sending application logs to the log system you already use.
Do you show CPU and memory usage?
Yes, per container: CPU, memory against the limit, and network and disk throughput both ways. This answer used to be no — the readings were not sampled reliably enough to draw, and we would rather leave a gauge out than fill it with a guess. They are now. You also still get the thing that matters most when something is wrong: the restart count and the exit reason. A container killed for exceeding its memory limit says exactly that, rather than leaving you to look up what exit code 137 means.
Can I connect a self-managed GitLab?
Not yet — gitlab.com only. A self-managed instance lives on its own hostname and the connection has nowhere to put it. GitHub and gitlab.com both work today; Bitbucket is in the interface but the adapter behind it is not built, so it is not offered. If your repository is somewhere we do not reach, building the image yourself and giving us that is the way in.
Can I connect to a managed database from my laptop?
Yes, and it is deliberately more than a toggle: publishing a database is confirmed and recorded, because it moves a port from private to reachable. Two things worth knowing before you do. Once open, the port is reachable by anyone who finds it — narrowing that is a firewall rule on the server, not a setting here — and it answers on a hostname in our zone rather than the server's address, which is DNS only. The name means your connection string survives the database moving; it does not hide the machine.
What happens when my credit runs out?
Your apps stop, and they start again when you top up. There is no auto-recharge yet, so a balance heading for zero is something to watch rather than something we quietly cover — the billing page shows the balance and what it is burning per hour. Nothing is deleted when you run out: the app, its configuration, its databases and its history are all still there.
What stops a secret leaking back out?
Marking a variable secret makes it write-only in the dashboard and API after it is saved. Your application receives it; the interface returns a masked value instead. Replace a secret whenever you need to, and editing other variables leaves it untouched.
Can I do all of this without the dashboard?
Yes. The dashboard is one client of a documented REST API — creating apps, updating environments, triggering deploys and reading logs are all endpoints. Issue a key with the role that job needs and nothing more.
Who on my team can deploy?
Whoever you decide. Viewers read, developers deploy and change configuration, admins manage members and keys, owners own the organization. Roles are enforced by the API on every request, not merely hidden in the interface.
What happens if we outgrow you?
Your application is a container built from your repository, so it runs anywhere else that takes containers. No proprietary manifest to unpick, nothing to rewrite. We would rather earn the next top-up than make leaving expensive.
Ship something today
Connect a repository and watch it build, then call a model with the same key. Apps from $8 a month, tokens by the million, nothing to cancel.
- GitHub + GitLab
- Container images
- OpenAI-compatible AI
- Pay as you run