Skip to content
Deploy.et
UPDATED SEPTEMBER 2026

Your first deployment
starts here.

Deploy.et runs apps from Git, Linux servers and S3-compatible storage, billed in birr. You can also watch servers and databases you already run elsewhere, for free. Everything here is done from the Deploy.et app.

Deploying an app?

Start with Prepare your app and Environment variables.

Already have servers?

See Your own servers and Databases.

01 / Deploying an app

  1. Choose an app plan in the app. The Free plan hosts static sites; paid plans run servers, with the memory shown on each plan.
  2. Point us at a public repository on GitHub, GitLab, Bitbucket, Codeberg or SourceHut, and choose a branch.
  3. Pick how it builds. Detect automatically handles Node, Python, Go, PHP, Ruby and more. Static site is for plain HTML, CSS and JS, or a framework that exports static files.
  4. We build and start it at its own deploy.et address. It usually takes a couple of minutes.
  5. To ship a change, push to your branch and tap Redeploy on the app’s page.
Private repositories and automatic deploys

Both are coming. For now repositories must be public, and new commits deploy when you tap Redeploy.

02 / Prepare your app

Every app needs three things: it listens on the port you set when creating it (reading PORT with that as the fallback is best), it listens on 0.0.0.0 rather than localhost, and it has a production start command.

Next.js

package.json
{
  "scripts": {
    "build": "next build",
    "start": "next start -p ${PORT:-3000}"
  }
}

Node.js (Express)

server.js
const express = require("express");
const app = express();

app.get("/", (req, res) => res.send("ok"));

const port = process.env.PORT || 3000;
app.listen(port, "0.0.0.0", () => console.log(`Listening on ${port}`));

Django

Add gunicorn and dj-database-url to requirements.txt, read settings from the environment, and give it a start command in a Procfile.

settings.py
import os
import dj_database_url

DEBUG = False
ALLOWED_HOSTS = [".deploy.et"]
CSRF_TRUSTED_ORIGINS = ["https://*.deploy.et"]
DATABASES = {"default": dj_database_url.config(conn_max_age=600)}
STATIC_ROOT = BASE_DIR / "staticfiles"
Procfile
web: gunicorn myproject.wsgi --bind 0.0.0.0:${PORT:-3000}

FastAPI

Procfile
web: uvicorn main:app --host 0.0.0.0 --port ${PORT:-3000}
No Dockerfiles

Apps are built with Nixpacks, which detects your language from files like package.json, requirements.txt, go.mod or composer.json. A Dockerfile in your repository is ignored. Need full control of the runtime? Use a VPS.

Commit your lockfile

Include package-lock.json, pnpm-lock.yaml, poetry.lock, or a pinned requirements.txt, so builds on our servers match your laptop.

03 / Environment variables

Add variables and secrets on your app’s page in the Deploy.et app. They’re encrypted before they’re stored and only decrypted when your app starts. Changes apply on the next deploy — tap Redeploy after saving.

Nothing is added for you except what you set, so connection details for a database or bucket go in here too, for example DATABASE_URL or the S3_* values below.

Never commit secrets

Keep a .env.example file with placeholder values so your team knows which variables exist, and add .env to .gitignore.

04 / Object storage

Each storage plan is its own S3-compatible account with a fixed quota. Use it for uploads, images, exports and backups — anything that shouldn’t live on your app’s disk. Any tool that works with Amazon S3 works here.

  1. Order a storage plan in the app and pay the invoice.
  2. We email you the storage console sign-in. Set a password and create a bucket. Buckets are private by default.
  3. Create an access key for your app.
  4. Add the endpoint from your storage page, the region, the bucket name and the key to your app’s environment variables. The examples below use S3_ENDPOINT, S3_REGION, S3_BUCKET, S3_ACCESS_KEY_ID and S3_SECRET_ACCESS_KEY.

JavaScript / TypeScript

npm install @aws-sdk/client-s3 @aws-sdk/s3-request-presigner
import { S3Client, PutObjectCommand, GetObjectCommand } from "@aws-sdk/client-s3";
import { getSignedUrl } from "@aws-sdk/s3-request-presigner";

const s3 = new S3Client({
  endpoint: process.env.S3_ENDPOINT,
  region: process.env.S3_REGION,
  forcePathStyle: true,
  credentials: {
    accessKeyId: process.env.S3_ACCESS_KEY_ID!,
    secretAccessKey: process.env.S3_SECRET_ACCESS_KEY!,
  },
});

// Upload a file
await s3.send(new PutObjectCommand({
  Bucket: process.env.S3_BUCKET,
  Key: "avatars/user-42.png",
  Body: fileBuffer,
  ContentType: "image/png",
}));

// Share a private file for 1 hour
const url = await getSignedUrl(
  s3,
  new GetObjectCommand({ Bucket: process.env.S3_BUCKET, Key: "avatars/user-42.png" }),
  { expiresIn: 3600 },
);

Python

pip install boto3
import os
import boto3
from botocore.config import Config

s3 = boto3.client(
    "s3",
    endpoint_url=os.environ["S3_ENDPOINT"],
    region_name=os.environ["S3_REGION"],
    aws_access_key_id=os.environ["S3_ACCESS_KEY_ID"],
    aws_secret_access_key=os.environ["S3_SECRET_ACCESS_KEY"],
    config=Config(s3={"addressing_style": "path"}),
)
bucket = os.environ["S3_BUCKET"]

s3.upload_file("report.pdf", bucket, "reports/report.pdf")

url = s3.generate_presigned_url(
    "get_object",
    Params={"Bucket": bucket, "Key": "reports/report.pdf"},
    ExpiresIn=3600,
)

Django file uploads

Install django-storages[s3] so FileField and ImageField uploads go straight to your bucket.

settings.py
STORAGES = {
    "default": {
        "BACKEND": "storages.backends.s3.S3Storage",
        "OPTIONS": {
            "endpoint_url": os.environ["S3_ENDPOINT"],
            "region_name": os.environ["S3_REGION"],
            "bucket_name": os.environ["S3_BUCKET"],
            "access_key": os.environ["S3_ACCESS_KEY_ID"],
            "secret_key": os.environ["S3_SECRET_ACCESS_KEY"],
            "addressing_style": "path",
        },
    },
    "staticfiles": {"BACKEND": "django.contrib.staticfiles.storage.StaticFilesStorage"},
}
Command-line tools

rclone, mc (the MinIO client), s3cmd and the AWS CLI all work with your endpoint and keys. Cancelled storage is deleted after 7 days, so copy off what you need first.

05 / Moving from MinIO

MinIO and Deploy.et storage both speak the S3 API, so there’s no code to rewrite. Copy your objects, then change your storage environment variables.

Option A: rclone

~/.config/rclone/rclone.conf
[old]
type = s3
provider = Minio
endpoint = https://minio.example.com
access_key_id = YOUR_MINIO_KEY
secret_access_key = YOUR_MINIO_SECRET

[deployet]
type = s3
provider = Other
endpoint = YOUR_S3_ENDPOINT
access_key_id = YOUR_DEPLOYET_KEY
secret_access_key = YOUR_DEPLOYET_SECRET
Terminal
# 1. Copy everything (safe to run again; it only copies what changed)
rclone sync old:my-bucket deployet:my-bucket --progress

# 2. Confirm both sides match
rclone check old:my-bucket deployet:my-bucket

Option B: mc (MinIO client)

Terminal
mc alias set old https://minio.example.com YOUR_MINIO_KEY YOUR_MINIO_SECRET
mc alias set deployet YOUR_S3_ENDPOINT YOUR_DEPLOYET_KEY YOUR_DEPLOYET_SECRET

mc mirror old/my-bucket deployet/my-bucket

Switch your app over

  1. Create the bucket first, with the same name if you can.
  2. Run the copy once while your old app is still live.
  3. Update the endpoint, region and keys in your app’s environment variables, and redeploy.
  4. Run the copy one last time to catch files uploaded during the switch.
  5. Keep MinIO running for a few days before shutting it down.
Using public links?

If your app stores full MinIO URLs in the database, like https://minio.example.com/my-bucket/photo.jpg, update those rows too. Storing only the object key, like photo.jpg, avoids this next time.

06 / Databases

Managed PostgreSQL and Redis aren’t open yet — they come once automated backups are running. Until then, run PostgreSQL on a Deploy.et VPS or use any hosted provider, and put its connection string in your app’s DATABASE_URL.

Watch it from the app — free

Add any PostgreSQL, Redis or S3 bucket under Services → Your own infrastructure. Every 5 minutes we connect, check it answers, measure its size and connection count, and disconnect. The data in it is never read, and the connection details are stored encrypted.

Give the check its own read-only user:

PostgreSQL
CREATE ROLE deployet_check LOGIN PASSWORD 'choose-a-password';
GRANT CONNECT ON DATABASE app TO deployet_check;
Connection details

Add ?sslmode=require to a PostgreSQL URL if your provider needs TLS, and use rediss:// for Redis over TLS. The database must be reachable from the internet; private and internal addresses are never checked.

07 / VPS

  1. Choose a plan, monthly or yearly (yearly is 11 months’ price on VPS 8 and up), and an operating system. Servers run in a data centre near Frankfurt.
  2. Pick an SSH key — there’s no root password. Add keys under Account → SSH keys.
  3. Once the invoice is paid, the server is built in a few minutes and its IP address appears on its page.
Terminal
ssh root@YOUR_SERVER_IP
Backups are yours

Servers have no automatic backups. A cancelled server is removed at the end of its billing period, with everything on it.

08 / Your own servers

Monitor any Linux server with systemd — at another provider, in your office or at home — for free, with or without a plan.

  1. In the app, go to Services → Connect a server and name it.
  2. Run the install command it shows on the server. It installs a small agent that reports every 30 seconds over HTTPS. No ports are opened, and we never get a way into the server.
  3. The server appears within a minute with its CPU, memory, disk, load and services.

Read the script before running it: deploy.et/agent.sh. From the app you can restart a service the agent watches, or reboot — the agent can’t do anything else.

Watch your own services

Common services — nginx, Docker, PostgreSQL, Redis and more — are watched automatically. Add yours, then restart the agent:

/etc/deploy-et/agent.env
DEPLOY_ET_SERVICES="myapp worker"
Terminal
sudo systemctl restart deploy-et-agent

Remove it

Terminal
sudo deploy-et-agent uninstall

Then remove the server in the app to delete its history.

09 / Your app’s address

Every app gets its own deploy.et address, made from the app’s name plus a short code, like my-app-a1b2c3.deploy.et. HTTPS certificates are issued and renewed for you.

Custom domains aren’t supported

Deploy.et doesn’t sell domains or connect domains you already own. Need your own domain? Run the app on a VPS.

10 / Billing

  1. Everything is billed in birr, VAT included, with no card needed.
  2. A new order must be paid within 24 hours, or it’s cancelled automatically. You can also cancel an unpaid order from its invoice.
  3. Pay by bank or telebirr transfer with the invoice number in the description, then submit the transaction reference in Billing. Each reference can only be used once.
  4. Renewal invoices arrive 3 days before the renewal date. A service is suspended 5 days after its invoice falls due, and resumes as soon as it’s paid.

11 / Troubleshooting

The build succeeds but the app never goes live

Your app is listening on a different port from the one you set when creating it, or only on 127.0.0.1. Listen on that port — or on PORT with it as the fallback — and on 0.0.0.0.

“Last build failed”

The app’s page shows why. The usual causes are a missing lockfile, or a Node version your code doesn’t support — set engines.node in package.json.

The app crashes right after starting

Most often a missing environment variable, or a database it can’t reach. Check the variables on the app’s page, then tap Redeploy.

Uploaded files disappear after a deploy

The app’s own disk is replaced on every deploy. Save uploads to object storage instead.

The build runs out of memory

Large Next.js or webpack builds can need more memory. Remove unused dependencies, or move to a plan with more memory.

“Access Denied” from object storage

Check that you’re using the keys for that bucket, that the key can write if you’re uploading, and that path-style addressing is on.

My server shows Offline

On the server, run sudo systemctl status deploy-et-agent and sudo journalctl -u deploy-et-agent -n 50. The server must be able to make outbound HTTPS requests to api.deploy.et.

A database shows Down

Its page shows the last error. The database must be reachable from the internet, and its firewall must allow connections from outside. Private addresses aren’t checked.

12 / Referrals

Your referral code is on the Account tab in the app. A referral counts once the person you invited verifies their email and holds an active paid app plan. While 5 of your referrals are active, your Developer plan (799 ETB / month) is covered.

Referrals that cancel stop counting. Full terms are in the Terms of Service.