Production-ready template
The FastAPI template brings structure, conventions and a working setup. A whitelabel variant exists for products shipping under several brands.
Technology
FastAPI deployment for async APIs without the setup detour
FastAPI is quick to write. Getting to production needs a database, container image, server with reverse proxy and certificate, and a home for credentials. The platform sets that up.
- Production-ready FastAPI template with repository and project structure
- Database, Docker, reverse proxy, SSL, firewall and backups configured automatically
- Python packages built and published by the pipeline
Start for free. No credit card required.
In short
FastAPI takes care of the API work. What remains is the environment around it, and that is what the platform provides.
- The template produces a repository, a project structure and a pipeline covering test through release.
- The server side arrives with Docker, a database, reverse proxy, SSL, firewall and backups.
Setting up FastAPI yourself versus running it on the platform
A look at the work a hand-built Python environment involves and how much of it the platform takes over.
| Task |
With the Application Platform
|
Set up yourself |
|---|---|---|
| Project structure and repository | Fully covered: Generated from a production-ready FastAPI template with settled conventions | Not offered: Create the repository and agree structure and conventions in the team |
| Python environment and dependencies | Fully covered: Run inside a container, identical in CI and on the server | Not offered: Keep interpreter version and dependencies aligned on every machine |
| Build and deployment pipeline | Fully covered: GitLab CI pipeline for test, build, publish and release comes with the project | Not offered: Write the pipeline, provision runners, work out caching and artefacts |
| Database | Fully covered: MySQL is provisioned during server setup, backups included | Not offered: Install and harden the database, create users, plan the backups |
| Exposing the API publicly | Fully covered: Reverse proxy, domain and SSL are part of the setup | Not offered: Configure the application server and proxy, keep certificates renewed |
| Credentials and API keys | Fully covered: Central to the project, separated per environment, handed to pipeline and runtime | Partly covered: Spread across files on servers, CI variables and local copies |
| Publishing Python packages | Fully covered: Built in CI and published in the project, with access rights per artefact | Partly covered: Run your own registry or copy code between repositories |
| Web and mobile clients | Fully covered: A Next.js frontend and a Flutter app can live in the same project | Partly covered: Separate setups with their own pipelines, servers and secrets |
| Errors in production | Fully covered: Sentry once you connect your account under Connections – stack trace, release and context | Partly covered: Search logs or integrate error tracking yourself |
| Traceability of environments | Fully covered: Environments and deployments live as configuration in the Git history | Not offered: Server state accumulates over time and is rarely documented |
Green means fully covered, amber partly, grey still on you. Doing it yourself is workable, it just consumes time that never reaches your domain logic.
As of 10 August 2026. This comparison describes typical workflows and can differ from project to project. Logos are trademarks of their owners and are used only to identify the product.
What you get for FastAPI specifically
The pieces a Python backend needs once something depends on it.
Database and server baseline
Docker, MySQL, reverse proxy, SSL, firewall and backups are configured automatically, on your own machines as well as managed ones.
Pipeline in the repository
Test, build, publish and release run through GitLab CI configuration that sits readable in your repository and can be edited.
Python packages from CI
Reusable code is built and published as a Python package by the pipeline, with access rights set per project.
Keys for external services
Keys for external services live centrally in the project, separated per environment, instead of in files on individual machines.
Error tracking with Sentry
Sentry runs once you connect your account under Connections. Exceptions then arrive with a stack trace, the affected release and context instead of a single log line.
configurations/prod/versions.yaml
application:
backend_configuration:
image_tag: 0.26.8-98
frontend_configurations:
customer-frontend:
image_tag: 0.15.6-80
admin-app:
image_tag: 0.12.1-42-
Customer app — -
Admin app — -
Backend —
Getting your FastAPI backend live
Four steps from creating the project to a reachable API.
-
Connect a server
Attach your own machine over SSH or use a managed server. Docker, database, reverse proxy, SSL, firewall and backups get configured.
-
Create the project from the template
Pick FastAPI in the wizard. Repository, project structure and CI/CD pipeline are created alongside the project.
-
Move code and keys in
Bring your existing endpoints into the repository and store credentials and API keys centrally in the project.
-
Deploy and connect the clients
A push starts the pipeline. Once the API answers on its domain, you point a frontend, an app or other services at it.
Frequently asked questions
How does the Python environment stay reproducible?
The application runs in a container built by the pipeline, so interpreter version and dependencies are identical in CI and production instead of maintained per machine. The image is published and rolled out to the connected server.
Is this a good fit for data services and AI integrations?
Yes, those are typical uses for a Python backend. FastAPI suits asynchronous endpoints that wait on external services and tasks that transform data. Keys for external providers live centrally in the project, separated per environment.
Can I publish my own Python packages?
Yes, for Python. The pipeline publishes Python packages, Docker images and NPM and Dart packages. Composer and Maven packages come next. Access rights are set per artefact.
Which database is used?
The backend templates work with MySQL, provisioned as part of the server setup. Credentials live centrally in the project and are handed to the application at runtime. Backups belong to the server baseline.
Where does the API run?
It runs on a server you attached over SSH or on a managed server from the platform, and access stays with you. Repositories, pipeline configuration and Docker images are yours too, with no proprietary runtime layer.
Create a FastAPI project and deploy it
Register for free, pick FastAPI as your stack and see how quickly a Python API with a database becomes reachable.
Start for free. No credit card required.