The Deployment Projects Roadmap: What Happens After git push

If you're a frontend, backend, or full-stack developer with around two or three years of experience, there is one thing you should start learning.

And no, I'm not saying you need to become a DevOps engineer.

You don't.

"You don't need to become a DevOps engineer. But as a developer, you should understand enough DevOps to deploy, debug, and maintain your own applications."

Because writing the code is only one part of the job.

Let's say you build a Next.js application. You write the code, test it locally, and everything works smoothly.

But then what?

• Where does that application actually run?
• How does the server receive requests?
• How does your domain connect to your server?
• Where does HTTPS come from?
• What happens if your Node.js process crashes?
• How do you restart it?
• How do you check the logs?
• And if you push new code to GitHub, do you really want to manually SSH into the server every single time to deploy it?

This is where having practical deployment knowledge becomes essential.

The important part is: you don't need to learn everything at once. You don't need to become an expert in Kubernetes, Terraform, AWS, and complex networking before you can deploy an app. That is overkill for most developers.

Instead, we learn it step by step—where every project adds exactly one architectural layer.

The 12-Project Roadmap

1. Deploy a React/Next.js App on a Linux VPS — SSH, Linux filesystem, Node runtimes, ports, processes
2. Production Deployment with Nginx — Reverse proxy, domains, port isolation
3. Add Domain + HTTPS — DNS records, SSL/TLS, Let's Encrypt certificates
4. Process Management with PM2 — Background daemons, logs, restart on crash
5. Containerize with Docker — Images, containers, Dockerfile
6. Full-Stack with Docker Compose — Frontend + backend + database networking
7. Automate with GitHub Actions CI/CD — Automated test, build, and zero-touch deployment
8. The Complete Production Stack — Real-world deployment flow with Nginx + Docker + CI/CD
9. Monitoring & Debugging — Breaking the server on purpose, inspecting logs, health checks
10. Cloud Migration with AWS — EC2, security groups, networking basics
11. Infrastructure with Terraform — Infrastructure as Code, declarative environments
12. Scale with Kubernetes — Containers at scale, pods, services, ingress

Don't start with Kubernetes. That's exactly what makes developers think DevOps is unnecessarily complicated. Your first 5–6 projects should make the basic architecture feel obvious and intuitive.

Project 1 — Your First Real Deployment

Build: Next.js / React application → Linux VPS

Don't make the application complicated. Use one of your existing projects or a clean, basic Next.js app.

Your Laptop
    ↓
GitHub
    ↓
Linux Server
    ↓
Node.js
    ↓
Next.js
    ↓
Port 3000

The important part isn't the app code. It's understanding:

• SSH keys and remote connection
• Linux filesystem basics
• Installing Node.js / Bun
• Cloning from GitHub
• npm install
• npm run build
• npm start
• Ports and processes
• Server IP access

At the end, you should be able to say:

"I can take my application from my laptop and make it run on a remote Linux server."

Project 2 — Put Nginx in Front of It

Now your architecture becomes:

User
 ↓
Domain
 ↓
Nginx :80
 ↓
Next.js :3000

This is where developers start understanding something critical:

Your application doesn't necessarily need to directly handle raw internet traffic.

Nginx receives the request on port 80 and forwards it internally to your application.

What you learn:

• Nginx basics
• Reverse proxy concepts
• Ports and routing
• Server blocks (/etc/nginx/sites-available/)
• Why port 3000 does not need to be publicly exposed

Project 3 — Add Domain + HTTPS

Now take:

http://SERVER_IP:3000

and turn it into:

https://myapp.com

Your architecture:

Domain
   ↓
DNS (A Record)
   ↓
Server IP
   ↓
Nginx (:443 SSL)
   ↓
Next.js (:3000)

What you learn:

• DNS records (A record, CNAME)
• Domain → IP mapping
• HTTP vs HTTPS
• TLS/SSL certificates
• Automatic certificate renewal with Certbot

This is where the setup starts feeling like an actual production deployment.

Project 4 — What If Node Crashes? (PM2)

Run your app normally:

npm start

Close the SSH session. Your terminal disconnects—and your application immediately stops.

Now introduce PM2.

Linux OS
   ↓
PM2
   ↓
Node.js
   ↓
Next.js

What you learn:

• Process management
• Background daemon processes
• Automatic restarts on error or crash
• Application logs (pm2 logs)
• Startup on server reboot (pm2 startup)

The core question:

"What happens to your Node.js app when your SSH session closes?"

Project 5 — Same Application, But Dockerized

Forget the previous server-level installation for a moment. Take the same application and package it into a container:

Dockerfile
    ↓
Docker Image
    ↓
Container
    ↓
Next.js Application

What you learn:

• Docker images vs containers
• Writing a clean Dockerfile
• Port forwarding
• Environment variables
• Volumes
• Container lifecycle

The key takeaway:

"Instead of installing everything directly on the server host, we package the application and its runtime environment into a container."

Project 6 — Full-Stack App with Docker Compose

Now make it realistic with multiple services:

              Internet
                  ↓
               Nginx
              ↙     ↘
        Frontend     Backend
          ↓             ↓
       Next.js       Node.js
                        ↓
                    PostgreSQL

Use Docker Compose to run everything with a single command.

What you learn:

• Running multiple containers together
• Internal networking between containers
• Shared environment variables
• Database data persistence using volumes
• Service dependencies (depends_on)
• Internal vs external ports

Project 7 — Stop Manually Deploying: CI/CD

Now introduce GitHub Actions.

Before:

Code → Git push → SSH into server → git pull → npm install → build → restart

After:

git push
    ↓
GitHub Actions
    ↓
Build & Test
    ↓
Deploy to Server
    ↓
Restart

Now you understand why CI/CD exists, instead of just copying workflow YAML files without context.

The relatable question:

"Why am I still SSH-ing into my server every single time I deploy?"

Project 8 — The Proper Production Stack

Now combine everything you've learned:

                   User
                     ↓
                  Domain
                     ↓
                  HTTPS
                     ↓
                  Nginx
                     ↓
              Docker Containers
                ↙         ↘
          Frontend       Backend
                            ↓
                        Database
                     ↓
                  Monitoring & Logs

Deployment flow:

Developer → GitHub → GitHub Actions → Build/Test → Docker Image → Server → Container

This is your big milestone.

At this point, you have learned enough deployment concepts to be genuinely independent and reliable in any software engineering team.

Project 9 — Break Your Own Application on Purpose

Don't build another app. Break the production app intentionally.

For example:

• Kill the running application process
• Stop Nginx
• Supply the wrong environment variable
• Break the database connection
• Occupy a required port with another process
• Deploy a broken build

Then debug it systematically:

Problem Identified
        ↓
    Check Logs
        ↓
   Check Process
        ↓
   Check Network
        ↓
Check Configuration
        ↓
    Apply Fix

This teaches more practical operational skill than twenty passive tutorials.

Project 10 — Move the Same Deployment to AWS

Only after understanding the previous steps:

                      AWS Cloud
 ┌───────────────────────────────────────────────────┐
 │ Virtual Private Cloud (VPC)                       │
 │                                                   │
 │   Security Group (Firewall)                       │
 │   - Port 22  (SSH)                                │
 │   - Port 80  (HTTP)                               │
 │   - Port 443 (HTTPS)                              │
 │                                                   │
 │   EC2 Ubuntu Instance                             │
 │   - Static Elastic IP                             │
 │   - Docker Compose Stack                          │
 └───────────────────────────────────────────────────┘

What you learn:

• EC2 instances
• Security groups (inbound & outbound firewalls)
• Public vs private IPs
• SSH key pairs
• Basic VPC networking and storage

AWS isn't magic. It is simply infrastructure wrapped around the exact concepts you already know.

Project 11 — Infrastructure with Terraform

Move from manually clicking buttons in the AWS console to defining infrastructure as code.

What you learn:

• Declarative infrastructure
• Terraform providers and resources
• State files and planning (terraform plan, terraform apply)
• Reproducible cloud environments

Project 12 — Kubernetes Deployment

When you need multi-node scaling, self-healing clusters, and automated rollouts across distributed services:

                  Kubernetes Cluster
 ┌───────────────────────────────────────────────────┐
 │ Ingress (Routing & TLS)                           │
 │                     ↓                             │
 │ Service (Load Balancer)                           │
 │           ↙         ↘                             │
 │      Pod (App)    Pod (App)                       │
 └───────────────────────────────────────────────────┘

What you learn:

• Pods, Services, and Deployments
• Ingress controllers
• Scaling and cluster health management

The Complete Flow

01  Linux VPS
        ↓
02  Nginx
        ↓
03  Domain + HTTPS
        ↓
04  PM2
        ↓
05  Docker
        ↓
06  Docker Compose
        ↓
07  GitHub Actions
        ↓
08  Production Stack
        ↓
09  Monitoring & Debugging
        ↓
10  AWS
        ↓
11  Terraform
        ↓
12  Kubernetes

Final Thoughts

"You don't have to become a DevOps engineer. You just need enough DevOps knowledge to understand your own application."

That is the sweet spot. It is specifically useful for developers who can build great applications but want to feel confident when someone mentions reverse proxy, Docker, CI/CD, EC2, containers, and deployment.

Start with Project 1 on a simple server, and build your deployment skills one layer at a time.