Clever Templates Help

Deploy an app in seven steps

From a GitHub repo to a live HTTPS URL on a box you own — here's the whole flow, start to finish.

1

Start a deploy

From the dashboard, click Deploy — or pick a ready-made starter from Templates. Either way you land in the new-project flow.

2

Connect GitHub

Authenticate with the Clever GitHub App and grant access to the repositories you want to deploy. You only do this once.

3

Pick a repository

Choose the repo (and branch) to ship. Clever detects your framework — a Next.js app gets a Dockerfile injected automatically; bring your own Dockerfile for anything else.

4

Watch it build

Clever clones, builds a container image, and streams the live build log to the project page. Colours and progress show up in real time.

5

Get a live HTTPS URL

When the build finishes, your app is live on its own subdomain with automatic HTTPS. Share the link — it's running on a box you own.

6

Add environment variables

Your project page has an Environment Variables card. Add API keys, feature flags, anything your app reads from the environment — they're encrypted at rest and injected into your container. Runtime values apply on save; build values need a redeploy.

7

Add a database

Need to store data? Click Add MySQL Database on the project page. Clever creates a database and a user just for that project, and injects the connection details into your app's environment — nothing to configure.

Runtime vs build variables

Every variable has a target. Picking the wrong one is the most common reason a value "doesn't work", so it's worth 30 seconds:

Runtime

Read by your app each time it starts or serves a request.

Save the variable and Clever restarts your container with it. No rebuild, live in seconds.

Database URLs, API keys, secrets — anything your server code reads.

Build

Baked into your compiled output during the build.

Saving is not enough — you must redeploy. The value is compiled in, so it only changes when the app is rebuilt.

Anything your framework inlines into the browser bundle.

Build values are not secret. If a framework inlines a value into the JavaScript bundle, anyone can read it in the page source. Never put a key or password in a build variable — use Runtime.

Naming

Clever passes whatever names you give it and doesn't care about prefixes — the convention is your framework's, not ours. Next.js inlines NEXT_PUBLIC_*, Vite uses VITE_*, SvelteKit uses PUBLIC_*. ASP.NET Core has no build-time convention at all and reads ConnectionStrings__* at runtime. Use what your framework expects.

Good to know

Values are encrypted at rest and masked in the UI until you click Reveal.
They're kept out of build logs — a value that appears in build output is redacted.
If your repo ships its own Dockerfile, a build variable needs a matching ARG line in it. Docker silently ignores build arguments it wasn't told to expect; Clever warns you in the build log when this happens.
Some names are reserved — DATABASE_URL and MYSQL_* are set automatically for projects with a database, so you can't override them.

Want to see it work? Deploy the Environment Variables Demo template — a one-page app that shows exactly what its container can see.

Databases

Each project can have its own MySQL database. It's opt-in — a static site doesn't carry one it never uses.

What you get

Clever creates a database and a dedicated user for the project, generates a password, and injects the connection details as environment variables. Your app reads them like any other config — there's nothing to fill in:

MYSQL_HOST, MYSQL_PORT, MYSQL_DATABASE, MYSQL_USER, MYSQL_PASSWORD — the individual values, readable from any language
DATABASE_URL — the URL form, for Prisma, Rails, Django, Sequelize and most ORMs
ConnectionStrings__DefaultConnection — the .NET form, picked up automatically by ASP.NET Core configuration

They're runtime values, so they're never compiled into your bundle and never appear in a build log. Adding a database restarts your app so it picks them up.

Isolation

Your user is granted privileges on your database and nothing else. Other projects on the same server can't read it, and SHOW DATABASES only lists your own. The server has no public port — it's reachable from your project's containers and nowhere else on the internet.

Managing it

Reveal password shows the credentials and the full connection URL, so you can copy them for migrations or a local client.
Reset password issues a new one. Your app briefly fails to connect until it restarts, and anything still using the old password stops working.
Delete database destroys the database and everything in it. There is no undo, and deleting the project deletes its database too.

Back up anything you care about. Clever takes a nightly dump of all databases, but that's a safety net for the server — not a substitute for exporting data you'd hate to lose.