Deployment: Put Your API Online

Your API works locally. You've tested it thoroughly. Now it's time to deploy it to a real server so it's accessible from anywhere on the internet, not just your computer.

This chapter walks you through deploying your API to Railway, a platform that makes deployment ridiculously easy. You'll go from local development to a live, publicly accessible API in about 15 minutes.

Why Deploy?

Right now, your API only runs on http://localhost:8000. That's fine for development, but it's not very useful:

It stops when you close your laptop

Nobody else can access it

You can't show it to potential employers or clients

You can't use it in a real application

Once deployed, you get a URL like https://user-api-production.up.railway.app that works 24/7 from anywhere. Your API becomes real.

Before You Deploy: Prepare Your Code

There are a few changes needed to make your code production-ready.

Switch from SQLite to PostgreSQL

SQLite is great for local development, but production APIs should use a proper database server. Railway provides PostgreSQL for free.

Update database.py:

Open database.py in Cursor and modify it to support both SQLite (for local dev) and PostgreSQL (for production):

This code reads the database URL from an environment variable. If the variable doesn't exist (like when you're developing locally), it falls back to SQLite.

Move secrets to environment variables

Your auth.py file has a hardcoded SECRET_KEY. That needs to come from environment variables instead.

Update auth.py:

Add CORS configuration

Your main.py currently allows CORS from anywhere (allow_origins=["*"]). That's fine for development, but in production you should be more restrictive.

Update main.py:

Now you can set ALLOWED_ORIGINS=https://yourapp.com,https://www.yourapp.com in production to restrict access.

Test locally

Run your API locally to make sure these changes didn't break anything:

Visit http://localhost:8000/docs and verify everything still works.

Deploy to Railway

Railway is a modern deployment platform. It's free to start, handles databases automatically, and deployment is incredibly simple.

Create a Railway account

Go to railway.app

Click Start a New Project

Install Railway CLI

The Railway CLI makes deployment easy. Install it:

On Mac:

On Windows:

On Linux:

Or use the standalone installer from docs.railway.app/develop/cli

This opens a browser window to authenticate. Once done, you're logged in from the CLI.

Initialize your project

In your project directory:

Railway asks: "Create a new project or link to an existing one?"

Choose Create new project

Give it a name like "user-api"

Railway creates a project and links your local directory to it.

Add PostgreSQL database

Choose PostgreSQL from the list. Railway provisions a PostgreSQL database and automatically creates a DATABASE_URL environment variable with the connection string.

Set environment variables

To generate a secure secret key, you can use:

Copy the output and use it as your SECRET_KEY.

If you want to set CORS origins:

For now, you can leave it as * or just not set it.

Create a Procfile

Railway needs to know how to start your app. Create a file named Procfile (no extension) in your project root:

web: uvicorn main:app --host 0.0.0.0 --port $PORT

This tells Railway to run your FastAPI app and bind it to the port Railway provides.

Create requirements.txt (if you modified it)

Make sure your requirements.txt includes all dependencies:

fastapi
uvicorn[standard]
sqlalchemy
psycopg2-binary
python-jose[cryptography]
passlib[bcrypt]
pydantic[email]
python-multipart

Note: psycopg2-binary is needed for PostgreSQL support.

Deploy

Now deploy your code:

Railway:

Uploads your code

Installs dependencies from requirements.txt

Creates database tables automatically (because of Base.metadata.create_all() in main.py)

Starts your API

This takes about 1-2 minutes.

Get your deployment URL

Railway shows your deployment URL, something like:

https://user-api-production.up.railway.app

Visit that URL + /docs to see your API documentation live:

https://user-api-production.up.railway.app/docs

Your API is now online!

Test Your Deployed API

Remember all those test cases you generated with AI in the previous chapter? Now you can use them to test your production API. You don't need to manually test again - just switch environments.

Create a Production environment in Apidog

Open Apidog

Go to Environments

+ New Environment

Name: "Production"

Base URL: https://your-api-url.up.railway.app (your actual Railway URL)

Save

Run your AI-generated tests

Switch to the Production environment (dropdown in top right)

Go to any endpoint's Test Cases tab

You'll see all the test cases you accepted in the previous chapter

Select all test cases

Click Run Selected

Apidog runs all your tests against the production API. You'll see:

✓ Tests that pass (API behaves correctly)

✗ Tests that fail (something needs fixing)

If all tests pass, congratulations! Your production API works exactly like your local version.

If some tests fail, check:

Are environment variables set correctly? (railway variables to view)

Is the database connected? (railway logs to check)

Any errors in the logs? (railway logs to see)

This is the power of automated tests. You generated them once with AI, and now you can run them against any environment (local, staging, production) just by switching the base URL.

Understanding the Deployment

Here's what just happened:

Railway received your code and saw it's a Python project (because of requirements.txt). It automatically:

Created a container to run your app

Installed Python and all dependencies

Set up environment variables (DATABASE_URL, SECRET_KEY, etc.)

Connected your app to the PostgreSQL database

Assigned a public URL with HTTPS

Started your app using the Procfile command

Every time you run railway up, it redeploys with your latest code. The database persists between deployments, so your data isn't lost.

Viewing Logs

To see what's happening on the server:

This shows real-time logs from your deployed app. You'll see:

Startup messages from Uvicorn

Incoming requests

Any errors or exceptions

Database queries (if you enabled logging)

This is invaluable for debugging production issues.

Making Updates

When you change your code locally:

Test the changes locally

Run your test suite in Apidog (Local environment)

Run railway up to redeploy

Run your test suite again (Production environment)

Railway automatically handles zero-downtime deployments. Your old version keeps running until the new version is ready, then traffic switches over.

Free Tier Limits

Railway's free tier includes:

$5 of free credit per month

500 hours of usage (plenty for small projects)

1GB database storage

Automatic HTTPS

Custom domains

For a simple API like this, you'll likely stay within the free tier. If you exceed it, Railway pauses your services until next month or you can add a payment method.

Alternative: Deploy to Render

If you prefer Render (another good platform), the process is similar:

Push your code to GitHub

Go to render.com and sign up

Create a New Web Service

Connect your GitHub repository

Render detects it's Python and auto-configures

Add environment variables in the dashboard

Click Create Web Service

Render also offers a free tier and handles databases similarly. The main difference is Render deploys from GitHub automatically, while Railway can deploy directly from your local machine.

What You've Learned

You now know how to:

Prepare your code for production (environment variables, database URLs)

Deploy to Railway with the CLI

Add a PostgreSQL database

Set environment variables securely

Get a public URL for your API

View logs and debug production issues

Update your deployed app

Test production using your AI-generated test suite

Your API is no longer just a local project. It's a real, deployed service accessible from anywhere.

Congratulations!

You've completed the entire workflow:

Designed your API in Apidog

Generated the code using Cursor's AI

Understood how the code works

Tested it with Apidog's AI-generated test cases

Deployed it to production

You now have a real API running online that you can:

Add to your portfolio

Show to potential employers

Use in actual projects

Continue building on

This is a modern, professional development workflow. You've learned to work with AI tools to be productive, while still understanding what's happening under the hood.

Keep building, keep learning, and most importantly - use these skills to create something you're proud of.

Before you go, check out the Chapter Summary for a quick recap of this journey.

Deployment: Put Your API Online

Why Deploy?#

Before You Deploy: Prepare Your Code#

Switch from SQLite to PostgreSQL#

Move secrets to environment variables#

Add CORS configuration#

Test locally#

Deploy to Railway#

Create a Railway account#

Install Railway CLI#

Login to Railway#

Initialize your project#

Add PostgreSQL database#

Set environment variables#

Create a Procfile#

Create requirements.txt (if you modified it)#

Deploy#

Get your deployment URL#

Test Your Deployed API#

Create a Production environment in Apidog#

Run your AI-generated tests#

Understanding the Deployment#

Viewing Logs#

Making Updates#

Free Tier Limits#

Alternative: Deploy to Render#

What You've Learned#

Congratulations!#