Deploy Your First Python App to Cloud

Build a Flask web app and deploy it live on the internet using Git and Render.

Introduction

30 Second Summary

Every app you use daily runs on a server somewhere in the cloud. Learning to deploy your own app to the internet is the first real step toward a career in DevOps and cloud engineering.

In this project, you will build a personal status page with Python and Flask, push your code to GitHub with Git, and deploy it live on the internet using Render.

What You'll Build

A personal status page web app that displays your name, what you're learning, and your career goal. The app will be live on the internet with a real URL you can share.

By the end of this project, you'll have:

A working Python Flask web application with multiple routes running locally on your machine.
A GitHub repository with your source code, managed with proper version control.
A live deployment on Render accessible from anywhere in the world with a shareable URL.
Secret Mission: Add a dynamic route that shows different content based on the URL.

Are there any prerequisites?

None. This project includes full setup instructions for every tool you need. You just need a Windows laptop and an internet connection.

Install Python, VS Code, and Git

Before you can build and deploy a web app, you need three core tools on your machine.

In this step, you will install Visual Studio Code (your code editor), Python (the programming language), and Git (version control). These are the same tools professional DevOps engineers use every day.

In this step, get ready to:

Install VS Code as your code editor.
Install Python 3.14 using the Python Install Manager.
Install Git for version control.

Download and install VS Code

VS Code is a free, lightweight code editor that you will use to write all of your Python code.

Open your web browser and go to https://code.visualstudio.com/download.
Under the Windows section, click the x64 button next to User Installer.
Once the download finishes, double-click the downloaded file to run the installer.
Accept the license agreement and click Next through each screen, keeping the defaults.
On the final screen, click Finish to complete the installation.

Why the User Installer?

The User Installer does not require admin permissions and installs VS Code just for your account. It also supports automatic background updates.

Now open VS Code on your machine.

Press the Windows key to open your search bar.
Type Visual Studio Code and press Enter to open it.

You should see the VS Code welcome screen. Leave it open for now.

Don't see VS Code in search?

The installer may not have finished registering VS Code with Windows. Try restarting your computer, then search again.

help me find VS Code after installing it on Windows

Install Python with the Python Install Manager

Python is the programming language you will use to build your web app. You will install it using the Python Install Manager, which is Python's official tool for managing Python on Windows.

First, open PowerShell so you can run commands.

Press the Windows key to open your search bar.
Type PowerShell and press Enter to open it.

You should see a dark terminal window with a blinking cursor. This is where you will type commands.

Install the Python Install Manager by running this command:

winget install 9NQ7512CXL7T

What does this command do?

winget is Windows' built-in package manager. The code 9NQ7512CXL7T is the official ID for the Python Install Manager in the Microsoft Store. This installs the manager, which then provides the python command on your system.

Accept any prompts that appear

WinGet may ask you to accept license agreements or source terms. Type Y and press Enter if prompted.

After the installation finishes, close the PowerShell window completely.
Open a new PowerShell window by pressing the Windows key, typing PowerShell, and pressing Enter.

Why close and reopen PowerShell?

Installing a new tool updates your system's PATH (the list of folders Windows searches for commands). A fresh PowerShell window picks up the new PATH so it can find the python command.

Verify Python is installed by running this command:

python --version

✔️ I see Python 3.14 or higher

Nice, Python is ready. You should see something like Python 3.14.5. Move on to the next substep.

ⓧ I see an older version

If you see a version lower than 3.14 (like 3.12 or 3.13), you may have a previous Python installation taking priority. The Python Install Manager should have installed 3.14 alongside it.

Try running this command to check available versions:

py list

If you see 3.14 in the list, set it as your default by running:

py install --configure -y

Close and reopen PowerShell, then run python --version again.

help me get Python 3.14 working on my Windows machine

ⓧ Command not found

If PowerShell says it cannot find python, the install may not have completed.

Make sure you closed and reopened PowerShell after installing.
Try running the install command again:

winget install 9NQ7512CXL7T

Close and reopen PowerShell, then run python --version again.

If it still does not work, visit python.org/downloads and download the Windows installer (64-bit) for Python 3.14 directly.

help me install Python on Windows when winget doesn't work

Install Git

Git tracks changes to your code and lets you push your project to GitHub. You will use it to deploy your app later.

In your PowerShell window, install Git by running this command:

winget install --id Git.Git -e --source winget

What does this command do?

This tells WinGet to install Git from its official source. The --id Git.Git flag specifies the exact package. The -e flag means "exact match" so WinGet does not install a similarly-named package by mistake.

Accept any prompts that appear

WinGet may ask you to accept license agreements. Type Y and press Enter if prompted.

After the installation finishes, close your PowerShell window completely.
Open a new PowerShell window by pressing the Windows key, typing PowerShell, and pressing Enter.
Verify Git is installed by running this command:

git --version

✔️ I see a version number

You should see something like git version 2.54.0.windows.1. Git is ready to go.

ⓧ Command not found

If PowerShell cannot find git, the install may not have completed or PATH was not updated.

Make sure you closed and reopened PowerShell after installing.
Try running the install command again:

winget install --id Git.Git -e --source winget

Close and reopen PowerShell, then run git --version again.

If it still does not work, download Git directly from git-scm.com and run the installer manually.

help me install Git on Windows

Your development environment is ready. Next up, you will create a GitHub account and connect Git to it so you can push your code online.

Create GitHub Account and Configure Git

Your development tools are all set up and verified. Now your code needs a home on the internet where it can be stored and accessed by deployment services.

GitHub is where developers store and share their code. By connecting Git to your GitHub account, every change you make locally can be pushed to the cloud and picked up by deployment services automatically.

In this step, get ready to:

Create a GitHub account.
Configure Git with your name and email.
Create a repository for your status page app.

Create a GitHub account

GitHub is a free platform that stores your code online. You need an account so your project has a URL that deployment services can pull from.

Open your browser and go to https://github.com.
Click Sign up in the top-right corner.
Follow the prompts to enter your email, create a password, and choose a username.
Verify your email address when GitHub sends you a confirmation email.
Once signed in, keep the browser tab open. You will need your username and email in the next substep.

Already have a GitHub account?

If you already have an account, just sign in at github.com. Make sure you remember the email address associated with your account. You will use it to configure Git next.

Configure Git with your identity

Every time you save a change with Git, it stamps the change with your name and email. This is how teams know who made which change.

In your PowerShell window, tell Git your name by running this command:

git config --global user.name "[[YOUR_NAME="Your Name"]]"

Tell Git your email by running this command (use the same email you used for GitHub):

git config --global user.email "[[YOUR_EMAIL="your-email@example.com"]]"

What do these commands do?

The --global flag saves these settings for every project on your computer. You only need to run these once.

Git attaches your name and email to every commit (saved change). This is how GitHub knows which changes belong to your account.

Verify your configuration was saved by running:

git config user.name
git config user.email

You should see your name printed on the first line and your email on the second line.

Create a new repository on GitHub

A repository is a folder for your project that lives on GitHub. It tracks every change you make and keeps a full history of your code.

In your browser, go back to your GitHub tab.
In the upper-right corner of the page, click the + icon.
Click New repository.
In the Repository name field, type my-status-page.
Select Public for the repository visibility.
Leave all checkboxes unchecked. Do NOT add a README, .gitignore, or license.
Click Create repository.

Why leave the repository empty?

You will push your local code up to this repository in a later step. If you initialize it with a README now, your local code and the remote code will conflict with each other.

GitHub now shows a "Quick setup" page with a URL for your repository. You will need this URL later.

Copy the HTTPS URL shown on the page. It looks like https://github.com/YOUR-USERNAME/my-status-page.git.
Save this URL somewhere you can find it easily (a sticky note, a text file, or just keep this browser tab open).

Don't see the Quick setup page?

If you accidentally checked "Add a README file" during creation, you will see a file list instead of setup instructions. Delete the repository (Settings tab at the top, scroll to Danger Zone, click Delete this repository) and create it again with all checkboxes unchecked.

Need more help? Ask: Why am I not seeing the Quick setup page on my new GitHub repository?

Your GitHub account and repository are ready. Next up, you will build the Flask web app that will live in this repository.

Build Your Flask Web App

Your development environment is ready and your GitHub repository is waiting for code. Now it's time to build something.

In this step, you'll create a Python web app using Flask. Flask turns a simple Python script into a web server that responds to browser requests. By the end of this step, you'll have a working website running on your own machine.

In this step, get ready to:

Create your project folder and set up a Python virtual environment.
Build a Flask web app with two pages.
Run your app locally and see it in the browser.

Create your project folder and virtual environment

Every Python project needs its own folder and its own isolated set of packages. A virtual environment gives your project a private copy of Python where you can install packages without affecting anything else on your computer.

Switch back to your PowerShell window and navigate to your Desktop by running this command:

cd ~/Desktop

Create your project folder and move into it by running these commands:

mkdir my-status-page
cd my-status-page

Open this folder in VS Code by running:

code .

VS Code opens with the my-status-page folder loaded in the sidebar. Keep your PowerShell window open for the next commands.

Create a virtual environment by running:

python -m venv venv

Activate the virtual environment by running:

venv\Scripts\activate

You should see (venv) appear at the beginning of your PowerShell prompt. This confirms you're now working inside the virtual environment.

What is a virtual environment?

Think of a virtual environment as a private workspace for your project. Any packages you install while the virtual environment is active only exist inside this project's folder.

This prevents conflicts between different projects that might need different versions of the same package. Professional developers always use one.

Script running is disabled?

Windows may block the activation script by default. If you see an error about running scripts being disabled, run this command to allow local scripts:

Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser

After running this, try venv\Scripts\activate again.

Help me fix the execution policy error when activating my virtual environment.

Install Flask and create your app files

With your virtual environment active, you can now install Flask and create the files that make up your web app.

Install Flask by running:

pip install flask==3.1.3

You should see output ending with a success message confirming Flask was installed.

Pip install failed?

Make sure you see (venv) in your prompt before running pip install. If it's missing, run venv\Scripts\activate first to activate your virtual environment.

Help me fix the pip install error.

Now you'll create two files in VS Code. The first tells deployment servers which packages your app needs.

In VS Code, click the new file icon at the top of the Explorer sidebar (or press Ctrl+N).
Name the file requirements.txt and paste the following content:

flask==3.1.3
gunicorn==26.0.0

What is requirements.txt?

This file lists the exact packages your app depends on. When you deploy to the cloud later, the server reads this file and installs everything your app needs to run.

Gunicorn is a production web server that the cloud platform uses to serve your app. You won't use it locally, but the deployment server needs it.

Save requirements.txt by pressing Ctrl+S.

Now for the main event. You'll create your Flask application file with a home page route.

Create another new file in VS Code and name it app.py.
Paste the following code into app.py:

from flask import Flask

app = Flask(__name__)


@app.route("/")
def home():
    return """
    <html>
    <head><title>My Status Page</title></head>
    <body style="font-family: Arial, sans-serif; max-width: 600px; margin: 50px auto; padding: 20px;">
        <h1>Hi! I'm [Your Name]</h1>
        <h2>What I'm Learning</h2>
        <ul>
            <li>Python</li>
            <li>Cloud Computing</li>
            <li>DevOps</li>
        </ul>
        <h2>My Goal</h2>
        <p>CS -> Cloud -> DevOps -> SRE -> Platform Engineer</p>
        <h2>About This App</h2>
        <p>This app is built with Flask and deployed on Render.</p>
        <p><a href="/about">About Me</a></p>
    </body>
    </html>
    """

What does this code do?

The first two lines import Flask and create your app. Flask(__name__) tells Flask where to find your project files.

The @app.route("/") decorator tells Flask: when someone visits the home page, run the home() function and send back the HTML inside it. This HTML is what the visitor sees in their browser.

Now add the about page route below the home() function by pasting the following code at the bottom of app.py:



@app.route("/about")
def about():
    return """
    <html>
    <head><title>About Me</title></head>
    <body style="font-family: Arial, sans-serif; max-width: 600px; margin: 50px auto; padding: 20px;">
        <h1>About Me</h1>
        <p>I'm a student preparing for RMIT Foundation, learning Computer Science.</p>
        <p>I'm building projects to prepare for a career in DevOps and SRE.</p>
        <p><a href="/">Back to Home</a></p>
    </body>
    </html>
    """

What does the about route do?

The @app.route("/about") decorator creates a second page at the /about URL path. When someone clicks the "About Me" link on the home page, Flask runs the about() function and shows this page.

The link at the bottom <a href="/"> takes the visitor back to the home page. This is how you connect pages together in a web app.

Save app.py by pressing Ctrl+S.

✔️ Awesome, I've got everything!

Great. Make sure you've saved both requirements.txt and app.py.

ⓧ I'd like to double check the full code

Here's the complete app.py file:

from flask import Flask

app = Flask(__name__)


@app.route("/")
def home():
    return """
    <html>
    <head><title>My Status Page</title></head>
    <body style="font-family: Arial, sans-serif; max-width: 600px; margin: 50px auto; padding: 20px;">
        <h1>Hi! I'm [Your Name]</h1>
        <h2>What I'm Learning</h2>
        <ul>
            <li>Python</li>
            <li>Cloud Computing</li>
            <li>DevOps</li>
        </ul>
        <h2>My Goal</h2>
        <p>CS -> Cloud -> DevOps -> SRE -> Platform Engineer</p>
        <h2>About This App</h2>
        <p>This app is built with Flask and deployed on Render.</p>
        <p><a href="/about">About Me</a></p>
    </body>
    </html>
    """


@app.route("/about")
def about():
    return """
    <html>
    <head><title>About Me</title></head>
    <body style="font-family: Arial, sans-serif; max-width: 600px; margin: 50px auto; padding: 20px;">
        <h1>About Me</h1>
        <p>I'm a student preparing for RMIT Foundation, learning Computer Science.</p>
        <p>I'm building projects to prepare for a career in DevOps and SRE.</p>
        <p><a href="/">Back to Home</a></p>
    </body>
    </html>
    """

And here's requirements.txt:

flask==3.1.3
gunicorn==26.0.0

Run your app locally

Your code is ready. Time to start the Flask development server and see your app in the browser.

In your PowerShell window (make sure you still see (venv) in the prompt), start the Flask dev server by running:

flask --app app run --debug

What does this command do?

The --app app flag tells Flask to look for your application in app.py. The --debug flag enables auto-reload, so Flask restarts the server every time you save changes to your code.

You should see output showing the server is running, with a URL like http://127.0.0.1:5000.

Open your web browser and go to http://127.0.0.1:5000.

You should see your status page with your name, learning goals, and the "About Me" link. Click the About Me link to visit your second page, then click Back to Home to return.

Don't see your page?

Check that the Flask server is still running in PowerShell. You should see a message with the URL in the terminal output. If the server crashed, look for a Python error in the terminal and make sure your app.py code matches the example above.

Help me troubleshoot my Flask app not loading in the browser.

Your web app is alive and running on your own machine. Next up, you'll push this code to GitHub so it's saved in the cloud and ready for deployment.

Push Your Code to GitHub

Your Flask app works perfectly on your computer. But right now, it only exists on your machine.

Git tracks every change you make to your code, and GitHub stores it in the cloud. This combination means your code is backed up, versioned, and accessible to deployment platforms like Render.

In this step, get ready to:

Create a .gitignore file to protect sensitive and unnecessary files.
Initialize a Git repository and commit your code.
Push your code to GitHub so it's accessible from anywhere.

Create a .gitignore file and initialize Git

Before Git starts tracking your project, you need to tell it which files to ignore. Your venv/ folder contains thousands of dependency files that can be recreated from requirements.txt. There's no reason to upload all of that to GitHub.

In VS Code's Explorer sidebar, click the New File icon (the page icon with a plus sign) at the top of the file list.
Type .gitignore as the filename and press Enter.
Paste the following content into the new file:

venv/
__pycache__/
*.pyc
.env

What does each line do?

venv/ ignores your entire virtual environment folder (thousands of files that pip can recreate).
__pycache__/ and *.pyc ignore Python's auto-generated bytecode files.
.env keeps any future secret keys or passwords out of GitHub.

Save the file with Ctrl+S.

✔️ Awesome, I've got everything!

Great. Make sure you've saved the file before continuing.

ⓧ I'd like to double check the full code

venv/
__pycache__/
*.pyc
.env

Now you can initialize a Git repository in your project folder.

Initialize a Git repository by running this command in your PowerShell terminal in VS Code:

git init

You should see a message that says Initialized empty Git repository in followed by your project path.

Seeing 'git' is not recognized?

Close your current PowerShell terminal and open a new one in VS Code by pressing Ctrl+`. Git needs a fresh terminal session after installation to be recognized.

If your virtual environment is no longer active (you don't see (venv) in your prompt), reactivate it by running venv\Scripts\activate.

Help me fix my Git setup.

Stage and commit your files

Git uses a two-step process to save your work. First you stage the files (choose what to include), then you commit them (save a snapshot with a message describing what changed).

Stage all your project files and create your first commit by running these commands:

git add .
git commit -m "first commit: my status page app"

What do these commands do?

git add . stages all files in the current folder (except those listed in .gitignore).
git commit -m "..." saves a snapshot of your staged files with a descriptive message.

You should see output listing the files that were committed: app.py, requirements.txt, and .gitignore.

Seeing 'nothing to commit'?

This means you may have already committed these files. Run git log --oneline to check. If you see your commit message listed, you're good to move on.

Help me troubleshoot my Git commit.

Connect to GitHub and push your code

Your commit is saved locally. Now you need to connect your local repository to the empty GitHub repository you created earlier, then push your code up.

Connect your local repository to GitHub and push your code by running these commands:

git remote add origin https://github.com/[[GITHUB_USERNAME="YOUR-USERNAME"]]/my-status-page.git
git branch -M main
git push -u origin main

What do these commands do?

git remote add origin tells Git where your GitHub repository lives.
git branch -M main renames your default branch to main (GitHub's standard).
git push -u origin main uploads your committed code to GitHub.

A sign-in window will appear

When you run the push command, Git Credential Manager will open a browser window asking you to sign in to GitHub. Sign in with the GitHub account you created earlier and authorize access. This only happens once.

After signing in, your terminal should show output indicating the push was successful.
Open your browser and go to your GitHub repository page at https://github.com/YOUR-USERNAME/my-status-page (replace with your actual username).
You should see three files listed: app.py, requirements.txt, and .gitignore.

Push failed or permission denied?

Make sure the repository URL matches your GitHub username exactly. You can check your current remote by running git remote -v.

If the browser sign-in window didn't appear, close PowerShell, reopen it, and try git push -u origin main again.

Help me fix my GitHub push.

Your code is now safely stored on GitHub. Next up, you'll connect this repository to Render and deploy your app live on the internet.

Deploy to Render

Your code is safely stored on GitHub and ready to go. But right now, only you can see the app by running it on your own computer.

To make your app available to anyone in the world, you need to deploy it to a cloud server. Render is a cloud platform that pulls your code from GitHub, installs the dependencies, and runs your app on their servers. No credit card required.

In this step, get ready to:

Sign up for Render and connect your GitHub repository.
Configure the deployment settings for your Flask app.
Deploy your app and verify it's live on the internet.

Sign up for Render and connect your repository

Render connects directly to your GitHub account. It watches your repository and automatically redeploys your app every time you push new code.

Open your browser and go to https://render.com.
Click the sign-up button on the homepage.
Select GitHub as your sign-up method.
Since you're already signed into GitHub in your browser, Render will redirect you to GitHub to authorize access. Click Authorize to allow Render to read your repositories.
You'll be redirected back to the Render Dashboard.

What is Render?

Render is a cloud hosting platform that runs your web apps on their servers. You connect a GitHub repository, tell Render how to build and start your app, and it handles the rest.

The free tier gives you 750 instance hours per month. Your app spins down after 15 minutes of no traffic and takes about a minute to wake up on the next visit.

In the top-right corner of the Dashboard, click the + New dropdown.
Select Web Service.
You'll see a list of your GitHub repositories. Find my-status-page and click Connect.

Don't see your repository?

If my-status-page doesn't appear in the list, Render may not have permission to see it. Look for a link that says Configure account and click it to grant Render access to your repositories on GitHub.

help me connect my GitHub repository to Render

Configure your web service settings

The service creation form asks how Render should build and run your app. You need to fill in three settings and pick the free plan.

Set Language to Python 3.
Set Build Command to pip install -r requirements.txt.
Set Start Command to gunicorn app:app.
Scroll down to the Instance Type section and select Free.

What is Gunicorn?

When you developed locally, you used Flask's built-in development server (flask run). That server is great for testing but can't handle real internet traffic safely.

Gunicorn is a production-grade server that runs your Flask app on Render's Linux servers. It can handle multiple visitors at once and is the standard choice for deploying Python web apps.

Why did we put gunicorn in requirements.txt earlier?

Render's build step runs pip install -r requirements.txt to install your app's dependencies on their server. Without gunicorn listed there, the Start Command would fail because the package wouldn't be installed.

Deploy and verify your app is live

With the settings filled in, you're ready to kick off your first deployment.

Click the Deploy Web Service button at the bottom of the form.
Render will show a log explorer with the build progress. Wait for the build to finish.

What happens during the build?

Render clones your GitHub repository, runs the Build Command (pip install -r requirements.txt) to install Flask and Gunicorn, then runs the Start Command (gunicorn app:app) to start your app. This takes 1-3 minutes on the free tier.

Once the deploy finishes, find your app's URL near the top of the service page. It will look something like your-app-name.onrender.com.
Click the URL to open your app in a new browser tab.
You should see your status page displayed, the same one you saw on localhost earlier. This time it's live on the internet.

App not loading or showing an error?

Check the deploy logs in the Render Dashboard. Common causes:

If you see a message about gunicorn not being found, make sure your requirements.txt includes gunicorn==26.0.0 and push the fix to GitHub. Render will automatically redeploy.
If the build succeeded but the page won't load, wait about a minute. Free-tier apps take time to start up on first visit.
If you see a typo-related import error, double check that your app.py file on GitHub matches what you had working locally.

help me fix my Render deployment

Your app is now live on the internet. Anyone with the URL can see your status page.

Secret mission

Dynamic Routes

Your app currently has fixed routes. What if you could make a single route that shows different content depending on what the visitor types in the URL? Add a /skills route that dynamically responds to any skill name in the path.

Clean Up Your Resources

Decide whether to keep your resources running, pause them to come back later, or delete them entirely. This project uses Render's free tier and GitHub's free plan, so there are no ongoing costs.

Resources you used:

Local my-status-page project folder (includes virtual environment venv/).
GitHub repository my-status-page.
Render Web Service (free tier, connected to your GitHub repository).

Keep everything running

No action needed. Choose this if you want your app to stay live on the internet and you plan to keep building on it.

Your app stays live at its Render URL. Render's free tier spins down after 15 minutes of no traffic, then restarts automatically when someone visits.
Your code stays on GitHub for future reference or collaboration.
Your local project folder remains on your Desktop with the virtual environment intact.
VS Code, Python, and Git remain installed on your machine. You will need all three for future projects.

Pause - I'll come back to this later

Shut down running processes to free up memory. Your files and deployed app stay intact.

If your Flask development server is still running in PowerShell, press Ctrl+C to stop it.
If your virtual environment is still active (you see (venv) in your terminal prompt), deactivate it by running:

deactivate

Your Render service will spin down automatically after 15 minutes of no traffic. No action needed.
Your GitHub repository and local files stay exactly as they are.

Delete - I don't want to use this again

Remove all project resources and start fresh. Follow these steps to delete everything.

Delete your Render Web Service

Go to render.com and log in.
Click on your my-status-page Web Service.
Click Settings in the left sidebar.
Scroll to the bottom of the page and delete the service.

Delete your GitHub repository

Go to github.com and open your my-status-page repository.
Click the Settings tab at the top of the repository page.
Scroll to the bottom of the page and delete the repository. GitHub will ask you to confirm by typing the repository name.

Delete your local project folder

If your virtual environment is still active, deactivate it first by running:

deactivate

Delete the entire project folder by running these commands in PowerShell:

cd ~/Desktop
Remove-Item -Recurse -Force my-status-page

Confirm the folder is gone by running:

ls

You should no longer see my-status-page in the output.

That's a Wrap!

Nice work! You just built a Python web app from scratch and deployed it live on the internet.

You've learned how to:

Built a Flask web application with multiple routes using Python.
Managed your code with Git version control and pushed it to GitHub.
Deployed your app to the cloud using Render's free tier, making it accessible from anywhere with a real URL.
Secret Mission: Added dynamic routes that respond to different URLs, returning unique content based on the path parameter.

Ready to quiz yourself?