# Deploying FastAPI on Render? You Can Automate It With AI Now
> FastAPI on Render works until it doesn't. Cold starts, sleep issues, scaling costs. Here's the full picture and a faster path to production.
- **Author**: parth-kanpariya
- **Published**: 2026-05-20
- **Modified**: 2026-05-20
- **Category**: Deployment Guides
- **URL**: https://kuberns.com/blogs/deploy-fastapi-on-render/
---
You can deploy a FastAPI app on Render in under ten minutes if your code is on GitHub. Connect your repo, set the build and start commands, add environment variables, and you are live on an onrender.com URL with auto-deploys on every push.
That part is well documented. What is not well documented is what happens after you go live.
Render's free tier sleeps your FastAPI app after 15 minutes of inactivity. Cold starts take 30 to 60 seconds on Python apps. Your free PostgreSQL database gets permanently deleted at day 91. File uploads disappear on every redeploy. And when something breaks in production, debugging is limited without a persistent shell.
This guide covers the complete deployment process for FastAPI on Render, every production limitation you will run into, and how [Kuberns](https://kuberns.com) deploys your FastAPI app to AWS in one click with its AI agent, no cold starts, no manual config, fully automated.
> Already deployed a Python app and wondering why it keeps going offline? See exactly what happens and how to fix it: [How to Deploy a Python App on Render](https://kuberns.com/blogs/deploy-python-app-on-render/)
## What You Need Before Deploying FastAPI on Render
Before you open the Render dashboard, three things need to be in order. Missing any of them is the reason most first deploys fail or produce a 502 immediately after going live.
### A requirements.txt With All Dependencies
Render installs your Python dependencies by running pip install -r requirements.txt during the build step. If this file is missing or incomplete, your app installs but crashes at runtime when it tries to import a package that was never installed.
Your requirements.txt needs at minimum:
```
fastapi
uvicorn[standard]
```
If you use SQLAlchemy, Pydantic settings, or any other package, add them here. The safest approach is to run pip freeze > requirements.txt in your local environment after confirming everything works.
### Your FastAPI App Bound to $PORT
Render assigns a dynamic port to your container and routes external traffic to it. If your uvicorn command hardcodes a port number, Render cannot route traffic to your app and every request returns a 502.
Your start command must read the port from the environment:
```
uvicorn main:app --host 0.0.0.0 --port $PORT
```
Replace main with your filename and app with your FastAPI instance variable name if they differ. The --host 0.0.0.0 flag is required. Without it, Render cannot reach your container even if uvicorn starts successfully.
### Code Pushed to a GitHub Repository
Render deploys directly from GitHub. Your project needs to be in a repository that Render can access. Every push to your connected branch triggers an automatic redeploy.
Make sure your .env file is in .gitignore. Environment variables go in the Render dashboard, not in your code.
## How to Deploy FastAPI on Render (Step by Step)
### Step 1: Create a New Web Service on Render
Log in to your Render dashboard at dashboard.render.com. Click **New** and select **Web Service**. Render will prompt you to connect a repository.
### Step 2: Connect Your GitHub Repo
Select the GitHub account that contains your FastAPI project. Choose the correct repository and the branch you want to deploy from, typically main. If your repo does not appear, click **Configure GitHub App** to grant Render access.
### Step 3: Set Build and Start Commands
This is the most common point of failure. Use these exact values:
| Setting | Value |
|---|---|
| Environment | Python 3 |
| Build Command | `pip install -r requirements.txt` |
| Start Command | `uvicorn main:app --host 0.0.0.0 --port $PORT` |
If your FastAPI instance is in a file called app.py and the variable is named application, the start command becomes uvicorn app:application --host 0.0.0.0 --port $PORT.
### Step 4: Set Environment Variables
Click **Advanced** and add your environment variables before deploying. At minimum add:
- DATABASE_URL if your app connects to a database
- SECRET_KEY if your app uses authentication
- Any third-party API keys your app needs
Variables set here are injected into your container at runtime and accessible via os.environ.get() or pydantic-settings.
### Step 5: Deploy and Go Live
Click **Create Web Service**. Render pulls your code, runs the build command, starts uvicorn, and your FastAPI app is live on a yourapp.onrender.com URL within a few minutes. Auto-deploys trigger on every subsequent push to your connected branch.
> Want to understand exactly what a deployment platform does behind the scenes when you hit deploy? [What Does One-Click Deployment Actually Do?](https://kuberns.com/blogs/what-does-one-click-deployment-do/)
## What Render's FastAPI Deployment Does Not Tell You
The setup works. The problems start when real traffic or real usage hits your app. These are the limitations Render's documentation mentions but does not emphasise.
**Free tier apps sleep after 15 minutes of inactivity**
This is the most impactful limitation for FastAPI specifically. Python apps take 30 to 60 seconds to cold start on Render's free tier. For an API that users or other services call, this means the first request after any idle period fails or times out. Background services, scheduled tasks, and webhooks are all affected.
The only fix within Render is upgrading to a paid plan starting at $7 per month per service. There is no configuration option to keep free tier services awake.
**Free PostgreSQL is deleted at day 91**
If you add a PostgreSQL database on Render's free tier, it is permanently deleted 90 days after creation with no option to extend. Any data in that database is gone. Migrating to a paid database requires manual export and import before the deadline.
**No persistent disk on free tier**
Any files your FastAPI app writes to disk, uploads, generated files, local caches, disappear on every redeploy. If your app handles file uploads or writes anything locally, you need either a paid plan with a persistent disk or an external storage solution like S3.
**render.yaml is required for anything non-trivial**
Environment groups, multi-service deployments, preview environments, and infrastructure-as-code all require a render.yaml file. For a solo FastAPI service this is manageable, but for a production setup with a separate worker, cron job, or database, the configuration overhead grows quickly.
**Scaling costs jump faster than expected**
Render's paid tier starts at $7 per month per service but scales by instance count and size. A FastAPI app under moderate production load running on a standard instance with a PostgreSQL add-on costs significantly more than the entry price suggests.
> Seeing unexpected costs from your cloud deployment? Here is a practical breakdown of what teams actually pay: [Render Pricing Explained](https://kuberns.com/blogs/render-pricing/)
## Deploy FastAPI in One Click With Kuberns
The limitations above are structural to Render's architecture. They are not bugs you can configure away. If you need a FastAPI app that stays live, scales without surprise costs, and does not require manual render.yaml configuration, Kuberns is the direct alternative.
Kuberns connects to your GitHub repo and its AI agent handles the entire deployment to AWS automatically. Here is what gets automated the moment you connect your repo:
- FastAPI stack detected automatically from your requirements.txt
- Correct uvicorn start command set without manual input
- Environment variables configured securely
- PostgreSQL database provisioned if your app needs one
- Auto-scaling set up based on your app type
- SSL certificate issued and attached
- App deployed to AWS and live without any sleep behaviour
No render.yaml. No manual configuration. No cold starts.
### Step 1: Push Your FastAPI Project to GitHub
Your code needs to be in a GitHub repository. If it is already there from the Render setup above, you are ready.
### Step 2: Connect Your Repo to Kuberns
[Click Deploy with AI](https://dashboard.kuberns.com) to open your Kuberns dashboard. Select **Import from GitHub**, choose your FastAPI repository, and select your branch.
### Step 3: The AI Agent Takes Over
Kuberns reads your requirements.txt, detects FastAPI and uvicorn, sets the correct build and start commands, and prompts you for any environment variables it cannot infer. You review and confirm. No config files to write.
### Step 4: Go Live on AWS
Hit **Deploy with AI**. Your FastAPI app builds and deploys to AWS infrastructure in minutes. You get a live URL immediately with no sleep behaviour on any plan.
### FastAPI with PostgreSQL on Kuberns
If your FastAPI app uses a database, Kuberns provisions a managed PostgreSQL instance automatically during deployment. It is production-grade, persistent, and does not get deleted after 90 days. The connection string is injected as an environment variable automatically. No separate database creation step required.
> Comparing your options before choosing a platform for your Python app? Here is a full breakdown: [How to Deploy a Python App on Render](https://kuberns.com/blogs/deploy-python-app-on-render/)
## Render vs Kuberns for FastAPI in Production
| Feature | Render Free | Render Paid | Kuberns |
|---|---|---|---|
| App sleep | Yes (15 min) | No | No |
| Cold start | 30-60 seconds | No | No |
| PostgreSQL | Deleted at day 91 | Persistent (paid) | Persistent (auto-provisioned) |
| Persistent disk | No | Yes (paid) | Yes |
| Custom domain | Yes | Yes | One click |
| SSL | Yes | Yes | Auto (instant) |
| Infrastructure | Render-managed | Render-managed | AWS |
| Auto-scaling | No (free) | Yes (paid) | Yes (automatic) |
| render.yaml required | No (basic) | Yes (advanced) | No |
| AI agent config | No | No | Yes |
| Free credits | 750 hrs/month | N/A | $14 for 30 days |
**The verdict:** Render's free tier is good for testing and side projects where occasional cold starts are acceptable. For a production FastAPI app that serves real users, receives webhooks, or runs background tasks, the sleep behaviour and database deletion policy make it unsuitable without a paid plan. Kuberns deploys to AWS with no sleep, persistent database, and full automation at a comparable cost.
> Solo building a SaaS with FastAPI and need a deployment setup that does not break at scale? [How to Deploy a SaaS App in 2026](https://kuberns.com/blogs/how-to-deploy-a-saas-app/)
## Conclusion
Deploying FastAPI on Render is straightforward. The setup takes ten minutes and the documentation is clear. The production reality, app sleep, database deletion, scaling costs, and manual configuration overhead, is what most guides skip.
If your FastAPI app is a prototype or a low-traffic side project, Render's free tier gets you live quickly. If it is serving real users, receiving API calls from other services, or handling production data, you need a platform built for uptime and persistence.
Kuberns deploys your FastAPI app to AWS in one click. The AI agent handles framework detection, environment configuration, database provisioning, and SSL automatically. No cold starts, no expiring databases, no render.yaml to maintain.
> More developers are moving away from [manual platform configuration to AI-automated deployment](https://kuberns.com/blogs/best-ai-tools-to-deploy-apps-to-cloud/) every month. Here is why.
[Deploy your FastAPI app on Kuberns.](https://dashboard.kuberns.com)
## Frequently Asked Questions
**Can I deploy FastAPI on Render for free?**
Yes. Render's free tier supports FastAPI web services. Connect your GitHub repo, set pip install -r requirements.txt as the build command and uvicorn main:app --host 0.0.0.0 --port $PORT as the start command, and your app goes live on an onrender.com URL. The free tier spins down after 15 minutes of inactivity, causing 30 to 60 second cold starts on the next request.
**Why does my FastAPI app sleep on Render?**
Render's free web services spin down automatically after 15 minutes of no incoming traffic. When a new request arrives, Render restarts the container, which takes 30 to 60 seconds for Python apps. The only way to avoid this on Render is to upgrade to a paid plan. Kuberns has no sleep behaviour on any plan.
**What is the start command for FastAPI on Render?**
The correct start command is uvicorn main:app --host 0.0.0.0 --port $PORT. Replace main with your filename and app with your FastAPI instance name if they differ. The --host 0.0.0.0 flag is required for Render to route traffic to your container.
**How do I add PostgreSQL to FastAPI on Render?**
Create a new PostgreSQL service separately in your Render dashboard. Copy the connection string from the Connect tab and add it as a DATABASE_URL environment variable in your FastAPI web service. Note that free PostgreSQL databases on Render are permanently deleted after 90 days.
**Does Render support async FastAPI routes?**
Yes. Render runs FastAPI with uvicorn which fully supports async/await routes. You can use async def for all your path operations and FastAPI handles concurrency correctly.
**How do I set environment variables for FastAPI on Render?**
In your Render dashboard, open your web service and click the Environment tab. Add key-value pairs for each variable. Your FastAPI app reads these at runtime via os.environ.get() or through a settings model using pydantic-settings. Never commit a .env file to your repository.
**What is the best alternative to Render for FastAPI in production?**
Kuberns is the strongest alternative for FastAPI production deployments. Its AI agent detects your FastAPI stack automatically, sets the correct uvicorn start command, provisions a managed PostgreSQL database, issues SSL, and deploys to AWS in one click. No cold starts, no 90-day database deletion, no manual render.yaml required.
---
- [More Deployment Guides articles](https://kuberns.com/blogs/category/deployment-guides/1/)
- [All articles](https://kuberns.com/blogs/)