Python

Django, Flask, and FastAPI deployed from Git

Connect a repository and push. We detect your framework, build on a slim Python image, and run it under Gunicorn or Uvicorn in an isolated container - health-checked, and rolled back in one click when you need it.

Start free trial See pricing

14 days free. No credit card. No commitment.

Push to deploy

GitHub, GitLab, Bitbucket

Gunicorn / Uvicorn

Configured for you

One-click rollback

Promote any build

Same price

On renewal, every year

99.99%

Uptime, last 12 mo

Daily

Backups kept up to 30 days

190+

Tasks Ellie handles

Frameworks

Detected from your project, served correctly

We look at your code, decide which framework you are running, and wire up the right server command. Every one of these is a starting point you can override in the build settings.

Django

WSGI

The full-stack option. Recognised the moment we see a manage.py, and served through gunicorn.

Detected from: manage.py
Start command: $ gunicorn <project>.wsgi:application --bind 0.0.0.0:$PORT
Environment: DJANGO_SECRET_KEY, and DJANGO_ALLOWED_HOSTS set to your domain in production.

Flask

WSGI

The small one. Detected from your dependencies rather than a marker file, so nothing extra to add.

Detected from: requirements.txt or Pipfile
Start command: $ gunicorn app:app --bind 0.0.0.0:$PORT
Environment: SECRET_KEY.

FastAPI

ASGI

The async one. Served through uvicorn, and it needs no configuration from you at all.

Detected from: requirements.txt or Pipfile
Start command: $ uvicorn main:app --host 0.0.0.0 --port $PORT
Environment: None required.

What you get

A real deployment pipeline, built in

Connect a repository once and every push runs through the same build, health-check, and promote pipeline - with rollback always one click away.

Git push deploys

GitHub, GitLab, or Bitbucket over OAuth or a token. A push registers a webhook and triggers a build automatically.

Framework detection

Django, Flask, or FastAPI recognized from your project. Install and start commands set for you, fully overridable.

Slim Python image

Builds run on a glibc-based slim image, so compiled wheels like numpy and Pillow install without a fight.

MySQL ready

Your database host is injected into the container. Connect over TCP with credentials you manage in the panel.

Blue/green deploys

A new build starts on a fresh port and only takes traffic after a health check passes. A failed build never reaches visitors.

One-click rollback

Every successful build is kept. Promote a previous one back to live in seconds - no rebuild, no Git revert.

Env vars & secrets

Build-time and runtime variables in the panel. Mark any as a secret and the value is sealed - write-only, never shown again.

Live logs

Stream your app output and platform events straight from the panel. See tracebacks and restarts without SSH.

How it works

Push. Build. Live.

Three Git providers, one pipeline. Choose ship-on-every-push, or build-and-hold until you promote it yourself.

Connect your repository

Link GitHub, GitLab, or Bitbucket via OAuth or a token, pick the repo and branch, and a push webhook is registered for you.

We detect and build

Each push clones the commit, detects Django, Flask, or FastAPI, installs your requirements on a slim Python image, and packages a versioned container image.

Health-check and promote

The container has to answer on its port within 30 seconds before it goes live. On Auto deploy it promotes itself; on Build only it waits for you.

Build #v12

Current

Repositoryapi-service / main

FrameworkFastAPI

Python3.12

Port8000

Build log

✓ Detected FastAPI

✓ pip install -r requirements.txt

✓ Image built (python:3.12-slim)

✓ uvicorn bound 0.0.0.0:8000

✓ Health check passed · promoted

The pipeline

What happens between push and live

Five stages, every time, with the previous build kept the whole way through.

Push
A commit lands on the tracked branch.
Detect
manage.py, requirements.txt or pyproject.toml tells us the framework and the server to run it with.
Build
Dependencies install in a resource-capped container. The result is a versioned image.
Health check
The new container must answer on its port within 30 seconds.
Live
It takes over traffic. The previous build stays, one click away.

Runtime

A real container, with a live view of it

Your app is a managed service with its own resources, automatic restarts, and logs you can read without opening SSH.

A glibc image, not musl
The Python image is slim but glibc-based, so packages with compiled wheels - numpy, psycopg, pillow, cryptography - install from the wheel instead of building from source on every deploy.
Three versions, pinned
Python 3.13, 3.12 or 3.11. Pick one in the panel or pin it in your repo, and it stays pinned across deploys.
Managed as a service
The container runs as its own system service. If the process dies it restarts within seconds, without anyone watching it.
MySQL over TCP
The database host is injected into the container. Connect with the credentials you already manage in the panel - no socket path to guess.

Databases, right where you expect them

Create MySQL databases and users in the panel, then reach them from your container over TCP. The database host is injected for you, and phpMyAdmin is one click away for browsing.

See the developer tooling

Pricing

Simple, transparent pricing

Every plan includes managed WordPress, SSH access, daily backups, and enterprise-grade security. Start with a 14-day free trial.

Startup

Great for growing businesses

$7.99/mo

$94.99 billed annually

Get started

1 website
10 GB storage
~10,000 visits/month
5 MySQL databases
250,000 inodes
5 FTP users

What's included:

SSL & Domain

Free SSL certificate
Free starter domain

Apps & CMS

1-click WordPress
Managed WordPress
WordPress staging

Advanced

For professional websites

$14.99/mo

$179.99 billed annually

Choose plan

5 websites
20 GB storage
~110,000 visits/month
10 MySQL databases
500,000 inodes
10 FTP users

Everything in Startup, plus:

Backups

14 days of backup history

Performance

Memcached object cache
Redis object cache

Monitoring

5 minutes between checks

Pro

Maximum performance and features

$22.99/mo

$274.99 billed annually

Go pro

10 websites
40 GB storage
~200,000 visits/month
20 MySQL databases
750,000 inodes
20 FTP users

Everything in Advanced, plus:

Deployment

2 SSR applications

Backups

30 days of backup history

Monitoring

1 minute between checks

Compare plans

Ship it

Deploy your Python app in minutes

Connect a repo, push, and watch it go live under Gunicorn or Uvicorn. Included in every plan. Start free for 14 days, no credit card.

Start your free trial

Questions

Frequently asked questions

Which Python frameworks are supported?

Django, Flask, and FastAPI are first-class. Django is detected from manage.py; Flask and FastAPI are detected from your dependencies. Anything WSGI or ASGI that these cover will run. When you connect a repo we set the install and start commands for you, and you can override them.

Which Python version can I run?

Python 3.13, 3.12, or 3.11. We recommend 3.12. Set it in the build settings, or let us read it from .python-version, the requires-python field in pyproject.toml, or runtime.txt.

What web server runs my app?

Django and Flask are served with Gunicorn; FastAPI is served with Uvicorn for async workloads. These are configured automatically based on the framework we detect, and you can adjust the command if you need specific worker counts or timeouts.

How are dependencies installed?

From your requirements.txt (or Pipfile). Builds run on a slim Python base image with glibc, so packages that ship compiled wheels - think numpy, Pillow, or database drivers - install cleanly without extra work.

Does collectstatic and migrate run for Django?

Yes. The default Django build installs requirements, runs collectstatic, and applies database migrations before the app starts. You can change the install command if your project needs a different order.

What port does my app need to bind to?

Bind to 0.0.0.0 on the port provided in the PORT environment variable (8000 by default for Python). Gunicorn and Uvicorn both take the bind address on the command line, which we set for you. Binding to localhost is the most common reason an app builds but won’t start.

Can my app talk to a MySQL database?

Yes. Your database host is injected into the container as an environment variable, and you connect over TCP with the credentials you manage in the panel. Add your own DATABASE_URL or individual settings as environment variables too.

Is Python hosting included in my plan?

Yes. Git deployment, container hosting, rollback, live logs, and environment management are part of every plan. A Python app runs in a container that counts against your plan’s app allowance.