Features
Everything you need to deploy, manage, and scale your applications — without the infrastructure headache.
Code to production in one command
Push your code and deploy. We build your containers from your Dockerfile and switch traffic to the new version once it passes its health checks. No infrastructure to configure.
One-command deployments
A single CLI command builds, deploys, and puts your app live. HTTPS, health checks, and load balancing happen automatically.
Multi-service applications
Deploy several Docker containers as one app — a web front end, an API, a worker. Each service runs its own number of replicas.
Clean container builds
Every build starts from a fresh clone of your branch — no stale layer cache, no "works on the last build" surprises. Base images come through our registry cache rather than straight from Docker Hub.
Git-native workflow
Deploy any branch on demand — from the CLI, the dashboard, the API, or a secret-authenticated hook you call from your own CI. Every branch gets its own URL, database and storage.
Build-then-deploy pipeline
Build your containers once. Deploying an image that is already in the registry needs no rebuild.
Deployment cancellation
Changed your mind? Cancel a queued or running deployment with one command.
Every branch, in parallel
Run main, dev and a feature branch at the same time. Each gets its own URL, its own database, its own storage and its own deploy history — a real staging environment without a second account.
Checked before you build
When you register a repository we check that we can reach it, that its appmecca.yaml is valid and that its Dockerfiles exist — before you spend a build.
Scheduled jobs, built in
Declare cron jobs in the same config file: a schedule, and an endpoint in your app that we call on it. Trigger, pause and review them from the CLI without redeploying. No separate scheduler to host.
# Register once — we check the repo before you build
$ mecca register git@github.com:you/myapp.git
# Then deploy, as often as you like
$ mecca app deploy myapp
# Your app answers at one HTTPS address:
# https://myapp-yourteam.us.appmecca.netManaged PostgreSQL, zero admin
Set database.enabled and your app gets PostgreSQL on its first deploy, backed up automatically before every deploy. You declare a connection budget in your config; we keep the fleet inside the instance's limit.
Managed PostgreSQL
Your database is created on your app's first deploy and its connection string arrives as DATABASE_URL. AWS RDS underneath, run by us — just connect and use it.
Backed up before every deploy
If your app has a database, it is dumped automatically before every deploy, so a bad migration is recoverable. On demand, mecca app backup takes a full checksummed bundle: the database plus every storage drive.
Restore what you need
Every bundle is checksummed, and a restore checks it before touching your data. Restoring an uploaded dump takes a safety backup first and rolls back automatically if the restore fails. Restore the whole bundle, just the database, or just one drive.
# The database is created for you on first deploy —
# just set database.enabled in appmecca.yaml.
# Take a bundle whenever you want one
$ mecca app backup myapp -d "pre-migration"
# List what you can restore
$ mecca app backups myapp
# Restore one, by the bundle prefix the list shows
$ mecca app restore myapp <bundle>
# Or bring an existing database with you
$ mecca app restore-upload myapp --file prod.dumpOne line of config each
The things every real app needs and nobody enjoys provisioning. Declare them in appmecca.yaml and the credentials arrive as environment variables inside your container — nothing to copy, nothing to commit.
Redis, when you want it
Sessions, queues, rate limits, computed values. Set redis.enabled and REDIS_URL shows up in your container. It is off by default, so nothing runs that you didn't ask for.
Persistent file storage
A shared drive that survives deploys and is mounted into every replica — uploads, generated media, anything that shouldn't live in the container. Browse, upload and download it from the CLI or the dashboard without shelling in.
Private object storage
Name a bucket in your config and get a private, encrypted S3 bucket with credentials scoped to that app alone — not our keys, not shared keys.
Built-in email for notifications
Set email.enabled and your app gets an endpoint it can POST JSON to. No AWS credentials in your container, no SMTP passwords, no SDK. Bounces and complaints are suppressed automatically.
HTTPS, custom domains, load balancing
Every app gets an HTTPS address on day one. Publish it and you can add up to two custom domains of your own; certificates are issued and renewed for you, free.
Automatic HTTPS
Every app gets HTTPS out of the box. SSL certificates are provisioned automatically and renewed. No manual cert management.
Custom domains
Add your own domain to a public app with one command, up to two per app. Add two DNS records — one for traffic, one for certificate validation — and we issue the certificate, wire the routing and keep it renewed. Apex domains work with DNS providers that support ALIAS or ANAME records, such as Cloudflare, Namecheap and DNSimple.
Load balancing
Automatic load balancing across all healthy instances. Health checks are continuous, with automatic removal of unhealthy targets.
Service discovery
Services discover each other by name via private DNS. Your database arrives separately as a DATABASE_URL environment variable — nothing to look up.
Built to stay up
Run one to three replicas of any service, spread across hosts in different availability zones, behind health checks that pull a failing instance out of rotation.
Replica scaling
Run 1–3 replicas of any service — you set the count. The load balancer spreads traffic across the healthy ones.
Intelligent placement
Services are placed on the least-loaded hosts. The scheduler spreads your workload to maximize efficiency.
Health monitoring
Health checks about once a minute pull a failing instance out of rotation, and a crashed container restarts on its own.
Deploys switch over only when healthy
New containers must pass their health checks before the load balancer switches over. If they fail, the switch doesn't happen and your current version keeps serving.
Built for more than one person
Multi-tenancy isn't bolted on: every app belongs to a group, and a group is your team.
Teams and invites
Invite teammates by email. Everyone in your group can see and operate its apps, and every request is checked against group membership.
Private until you publish
New apps are private until you publish them. Anonymous visitors get a sign-in page and only your team gets through — good for internal tools, and for staging you don't want indexed.
Sign in how you like
Sign in with Google, GitHub or GitLab, or with a one-time code sent to your email. There are no passwords.
Deploy hooks
Give your CI a secret URL: a POST to it rebuilds and redeploys your app. Or add a GitHub or GitLab webhook once, and every push to a branch you switch on rebuilds and redeploys it.
Tools that respect your time
From the CLI to the dashboard to the agent guide, every tool is designed to get out of your way.
Powerful CLI
One command-line tool for everything: deploy, roll back, stream logs, set variables, manage domains and storage, back up and restore. Read commands emit structured output with --json.
Web dashboard
Every app, service, database, domain and drive you own, in one place. Watch a deploy phase through live, read logs, edit variables, restore a backup.
Live log streaming
Stream container logs in real-time with colored output. Filter by app, service, deployment, or log level. Follow mode for live monitoring.
Environment variables
Set variables per app and branch, or import a whole .env file in one call. Reference a sibling service with a template and we resolve the URL at deploy time. Database and service credentials are injected for you — never checked in, never pasted.
Deployment history & rollback
Your recent builds stay addressable as images. List them with mecca app versions, see which one is serving, and roll back by deploying an older tag — it redeploys an existing image, so there is no build to wait for.
One-shot diagnostics
When something is wrong, mecca debug gathers it all at once: resolved URLs, per-service health, the last deploy errors, and which configured variables actually reached the container. No hunting across five screens.
Your AI deploys it for you
We publish a single-file guide that teaches any coding assistant how AppMecca works. Drop it into your project and your agent can write the config, deploy, and read the logs back — without you narrating the infrastructure.
# Your agent, in your IDE (an illustration):
You: Deploy this to AppMecca.
Agent: Reading APPMECCA.md...
This is a Django app with Postgres and
a React frontend — two services.
✓ Wrote appmecca.yaml
✓ mecca register
✓ mecca app deploy myapp
✓ Health checks passing
Agent: Live at
myapp-yourteam.us.appmecca.net
# Same commands you'd type. It just types them.A guide written for machines
One file covering the config format, the Dockerfile contract, every backing service and the traps that waste the most time. The commands, config keys and environment variables it names are checked against the platform's own code by an automated test.
Model-agnostic by design
It assumes nothing about which assistant reads it. Append it to CLAUDE.md, AGENTS.md, .cursorrules, GEMINI.md or your Copilot instructions — whichever file your tool already loads.
An operating procedure, not just a reference
The last chapter is an ordered runbook for taking a project live — what to inspect, what to ask you and when, and how to verify each step actually worked before moving on.
Everything is scriptable
Read commands emit structured output with --json, and the same REST API sits behind the CLI and the dashboard, so your agent can drive the platform the way you do. Your CI can call a deploy hook.
Bring an existing app with you
Your app stays a standard Docker container and your database stays standard PostgreSQL. Bring your Dockerfiles, upload a dump of your database, and deploy.
Coming from Heroku?
Give each Procfile process its own service in appmecca.yaml, backed by a Dockerfile you control. Bring your config across in one call with mecca var load myapp .env.
Bring your database
Take a pg_dump from Heroku, Railway or Render and upload it — from the CLI or by dragging it into the dashboard. We take a safety backup first, restore, and hand you a per-table row count.
No lock-in
Standard Docker. Standard PostgreSQL. Migrate away anytime. Your Dockerfiles and data are always yours to take.