Deploy a Django app

Add the production dependencies to requirements.txt:

django
gunicorn
whitenoise
dj-database-url
psycopg[binary]

We detect Django from manage.py and read WSGI_APPLICATION from your settings to build the start command, so keep that setting (every startproject has it). Each deploy runs python manage.py migrate and then gunicorn <project>.wsgi. Gunicorn reads the PORT variable we set and binds 0.0.0.0, so there is nothing to configure for the port.

Pin the Python version with a .python-version file (for example 3.13). A Heroku-style runtime.txt is not read.

Read everything secret or host-specific from the environment:

import os
import dj_database_url

SECRET_KEY = os.environ["SECRET_KEY"]
DEBUG = os.environ.get("DEBUG") == "1"

ALLOWED_HOSTS = os.environ.get("ALLOWED_HOSTS", "").split(",")
CSRF_TRUSTED_ORIGINS = [f"https://{h}" for h in ALLOWED_HOSTS if h]

# The platform terminates HTTPS and forwards the original scheme
SECURE_PROXY_SSL_HEADER = ("HTTP_X_FORWARDED_PROTO", "https")
SESSION_COOKIE_SECURE = True
CSRF_COOKIE_SECURE = True

DATABASES = {"default": dj_database_url.config(conn_max_age=600)}

Then set ALLOWED_HOSTSin the project's env vars to a comma-separated list, for example myapp.ethiodeploy.com,myapp.com,www.myapp.com.

Nothing runs collectstatic by default. Serve static files from the app itself with WhiteNoise:

MIDDLEWARE = [
    "django.middleware.security.SecurityMiddleware",
    "whitenoise.middleware.WhiteNoiseMiddleware",
    # ... the rest
]

STATIC_ROOT = BASE_DIR / "staticfiles"
STORAGES = {
    "default": {"BACKEND": "django.core.files.storage.FileSystemStorage"},
    "staticfiles": {"BACKEND": "whitenoise.storage.CompressedManifestStaticFilesStorage"},
}

Set the Build command in Settings → Build to python manage.py collectstatic --noinput. Env vars are available during the build, so settings that read SECRET_KEY still load.

User uploads (MEDIA_ROOT) are different: each deploy starts a fresh container, so files written to disk are lost on the next push. Store uploads in S3-compatible object storage with django-storages.

Every deploy requests your health check path (/ by default) and only goes live once it returns a 2xx or 3xx status. The platform keeps checking it after that. If / returns 404 or needs a login, add a route like /healthz that returns 200 and set it as the Health Check Path in Settings. Otherwise the deploy fails and the previous version keeps serving.

The check is sent with Host: <project-slug>.ethiodeploy.com, so keep that address in ALLOWED_HOSTS even after you add a custom domain. Without it Django answers the check with a 400 and the deploy fails.

Add a Postgres (or MySQL) addon and DATABASE_URL is injected automatically. dj_database_url.config() in the settings above reads it. Migrations run on every start, so a new model goes live with the push that adds it. The database is private to the project: browse it with the built-in schema browser and SQL editor.

If you replace the start command (for example to run ASGI), keep the migration step in it:

python manage.py migrate && gunicorn myproject.asgi:application -k uvicorn_worker.UvicornWorker

Addons are private to the project that owns them, so a separate worker project can't reach the same database or Redis. For a small app, run the worker in the same container by setting the Start command to:

celery -A myproject worker --concurrency 2 & python manage.py migrate && gunicorn myproject.wsgi

Add a Redis addon and point Celery at REDIS_URL. The worker isn't restarted on its own if it crashes, so watch the Logs tab. On the Free plan the container has 256 MB of memory, which fits a small app with one or two gunicorn workers but not much else.

1. Sign in with GitHub and install the EthioDeploy app on the repo.
2. Click “New Project” and pick the repo.
3. Watch the build in the dashboard. When the health check passes, your app is live at <project-slug>.ethiodeploy.com. Every push to the default branch redeploys, and the old version keeps serving until the new one is healthy.