You write your code, run it on localhost:3000, test everything, and it works.

Then you run:

git add .
git commit
git push

And then what?

Where does your application actually run?

How does a user's browser reach it?

How does your domain connect to your application?

Where does HTTPS come from?

What happens if your Node.js process crashes?

And do you really want to SSH into a server and manually deploy every time you make a change?

These are questions every developer should have some understanding of.

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

If you're a frontend, backend, or full-stack developer, there will often be a separate DevOps or infrastructure team handling a lot of this stuff.

But you should still understand what happens to your application after you write the code.

Otherwise, deployment becomes a black box.

You can build the application, but the moment something breaks in production, you don't know where to start looking.

That's why I put together this project-based roadmap.

The idea is simple:

Don't try to learn everything at once.

Start with a Linux server.

Deploy one application.

Then add Nginx.

Then a domain and HTTPS.

Then process management.

Then Docker.

Then CI/CD.

And only after understanding those fundamentals, move towards AWS, Terraform, and Kubernetes.

Each project builds on the previous one.

The 12-Project Deployment Roadmap

Project 1 — Your First Real Linux Deployment

Stack: Next.js / Node.js → Ubuntu Linux server

Start with a very simple application.

The goal isn't to build another complicated project.

The goal is to understand what actually happens when you take code from your laptop and run it on another machine.

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

What You'll Learn

• Connect to a remote server using SSH
• Navigate the Linux filesystem
• Install Node.js
• Clone a Git repository
• Install dependencies
• Build a Next.js application
• Run the production application
• Understand ports and processes

By the end, you should be able to say:

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

That's the first milestone.

Project 2 — Put Nginx in Front

Now your application is running, but you're accessing it directly through something like:

http://SERVER_IP:3000

Let's change that.

User
  ↓
Nginx :80
  ↓
Next.js :3000

Nginx will receive the incoming request and forward it to your application.

This is where you'll start understanding what a reverse proxy actually does.

What You'll Learn

• Nginx basics
• Reverse proxy
• Server blocks
• proxy_pass
• Ports
• Local vs publicly exposed services

The important part isn't memorizing an Nginx configuration.

It's understanding why Nginx sits between the user and your application.

Project 3 — Connect a Domain + HTTPS

Now let's make the application feel more like a real website.

Instead of:

http://SERVER_IP:3000

you'll have:

https://yourdomain.com

The flow becomes:

Browser
   ↓
Domain
   ↓
DNS
   ↓
Server IP
   ↓
Nginx
   ↓
Next.js

What You'll Learn

• DNS basics
• A records
• CNAME records
• Nameservers
• DNS lookup
• HTTP vs HTTPS
• TLS certificates
• Let's Encrypt and Certbot

This is where you'll understand how a domain actually finds your server.

Project 4 — What Happens When Your Node.js App Stops?

Now let's create a real problem.

Run your application from an SSH session and then disconnect.

Or let the process crash.

What happens?

Your application can stop.

This is where a process manager like PM2 becomes useful.

Linux
  ↓
PM2
  ↓
Node.js
  ↓
Next.js

What You'll Learn

• Background processes
• Process management
• Automatic restarts
• Application logs
• Running applications after logout
• Starting applications after a server reboot

The important thing here is understanding why process managers exist, not just learning a few PM2 commands.

Project 5 — Dockerize the Application

So far, we've installed Node.js directly on the server.

Now let's change the approach.

We'll package the application into a Docker image and run it inside a container.

Dockerfile
    ↓
Docker Image
    ↓
Container
    ↓
Next.js

What You'll Learn

• Dockerfiles
• Images
• Containers
• Port mapping
• Environment variables
• Container lifecycle
• Multi-stage builds

The main idea is simple:

Instead of depending on how the server is configured, we package the application and its runtime environment together.

Project 6 — Full-Stack Application with Docker Compose

A real application usually has more than one service.

For example:

Frontend
   ↓
Backend
   ↓
PostgreSQL

Now we'll run these services using Docker Compose.

             Docker Compose
                  ↓
       +----------+----------+
       ↓          ↓          ↓
   Next.js     Backend    PostgreSQL

What You'll Learn

• Multiple containers
• Docker networks
• Service-to-service communication
• Environment variables
• Database volumes
• Container configuration

This is where Docker starts becoming much more practical.

You're no longer running one container.

You're managing a small application stack.

Project 7 — Stop Deploying Manually

At this point, you might still be doing this:

git push
   ↓
SSH
   ↓
git pull
   ↓
install
   ↓
build
   ↓
restart

Doing this manually every time gets annoying pretty quickly.

So now we'll automate it with GitHub Actions.

git push
   ↓
GitHub Actions
   ↓
Test
   ↓
Build
   ↓
Deploy
   ↓
Server

What You'll Learn

• GitHub Actions workflows
• CI/CD basics
• GitHub Secrets
• SSH-based deployment
• Automated builds
• Deployment triggers

The goal isn't to copy a YAML file from somewhere.

The goal is to understand what actually happens between git push and production deployment.

Project 8 — Put Everything Together

Now we connect the pieces we've learned so far.

User
  ↓
Domain
  ↓
HTTPS
  ↓
Nginx
  ↓
Docker
  ├── Frontend
  ├── Backend
  └── Database
 
GitHub
  ↓
GitHub Actions
  ↓
Deployment
  ↓
Server

This is the point where everything starts connecting.

You'll understand how:

• Users reach your application
• Nginx handles incoming traffic
• Containers run your services
• The backend communicates with the database
• CI/CD deploys new versions
• Logs help you understand what's happening

You aren't learning isolated tools anymore.

You're understanding the complete deployment flow.

Project 9 — Break Your Own Application

This one is probably the most useful project in the whole series.

Don't build another application.

Take the one you already have and break it.

For example:

• Stop the application
• Stop Nginx
• Use the wrong environment variable
• Break the database connection
• Occupy a port
• Deploy a broken build

Then debug it.

Start with:

Problem
   ↓
Logs
   ↓
Process
   ↓
Network
   ↓
Configuration
   ↓
Fix

This teaches you something that tutorials usually don't:

How to find the problem when things stop working.

Because knowing how to deploy an application is useful.

Knowing how to figure out why it's not working is even more useful.

Project 10 — Move the Deployment to AWS

Only after understanding the basic deployment flow should you move to AWS.

Now take what you've already built and deploy it on an EC2 instance.

What You'll Learn

• EC2
• Security Groups
• SSH keys
• Public and private IPs
• Basic VPC concepts
• Storage

The important thing here is that AWS shouldn't feel like a completely different world.

You already understand Linux, networking, ports, Nginx and Docker.

AWS is now giving you infrastructure around those concepts.

That's why I prefer learning the basics first.

Project 11 — Infrastructure as Code with Terraform

Now imagine creating your infrastructure manually every time.

Create a server.

Configure networking.

Create security rules.

Configure resources.

It works, but repeating all of that manually isn't ideal.

With Terraform, you can define your infrastructure as code.

Terraform Code
      ↓
AWS Infrastructure
      ↓
EC2 + Network + Resources

What You'll Learn

• Terraform basics
• Providers
• Resources
• Variables
• terraform plan
• terraform apply
• State
• Reproducible infrastructure

The main idea is:

Your infrastructure can be managed like code.

Project 12 — Finally, Kubernetes

And Kubernetes comes last.

Not first.

By this point, you already understand:

• Containers
• Networking
• Deployment
• Services
• Scaling problems

Now Kubernetes will actually have some context.

You'll start with:

• Pods
• Deployments
• Services
• Ingress
• ConfigMaps
• Secrets
• Basic scaling

The goal isn't to memorize hundreds of Kubernetes commands.

The goal is to understand what problem Kubernetes is solving and where it fits into the deployment stack.

The Connection Between Everything

The roadmap looks like this:

Linux
  ↓
Nginx
  ↓
Domain + HTTPS
  ↓
PM2
  ↓
Docker
  ↓
Docker Compose
  ↓
CI/CD
  ↓
Production Deployment
  ↓
Debugging
  ↓
AWS
  ↓
Terraform
  ↓
Kubernetes

Each project adds one more layer.

You're not trying to become a DevOps engineer overnight.

You're building enough deployment knowledge to understand what happens to your application after you write it.

Because eventually, the important question isn't just:

"Does my application work?"

It's also:

"Where is it running, how is it reaching users, and what do I check when it breaks?"

That's the gap this roadmap is meant to fill.