My main project, Kaizen a habit and productivity tracker had its backend running on Render’s free tier.

For a while, it worked fine. But there was one critical issue:

The server went to sleep after 15 minutes of inactivity. Every time a user opened the app after inactivity, they faced a cold start sometimes waiting 30–50 seconds for the backend to wake up. That’s unacceptable for any production app.

For a discipline-focused product, it felt ironic.

A friend suggested AWS EC2 not just to fix the issue, but to gain real-world DevOps exposure. AWS also offers a 12-month free tier.

So I decided to do it properly. No shortcuts. No half-measures.

Part 1: Setting Up the AWS EC2 Instance

I created an Ubuntu 22.04 LTS EC2 instance (t2.micro, free tier eligible).

Key Steps

• Selected Ubuntu 22.04 LTS AMI

• Created a .pem key pair for SSH access

• Configured Security Groups

Security groups act as cloud firewalls.

I configured:

• Port 22 (SSH) → Allowed only from my IP

• Port 80 (HTTP) → Public

• Port 443 (HTTPS) → Public

• Port 3000 → Blocked from public access

This ensures backend services are not directly exposed.

Connecting via SSH

ssh -i "my-key.pem" ubuntu@<ec2-public-ip>

This was my first time managing a production Linux server directly.

Part 2: Deploying the Node.js Backend with systemd

To run the backend persistently, I evaluated two options:

• PM2 (Node.js process manager)

• systemd (Linux native process manager)

I chose systemd because:

• Native to Linux

• No external dependency

• Starts on reboot

• Auto restarts on crash

• Cleaner integration with OS-level logging

Service File

Created at:

/etc/systemd/system/kaizen-backend.service

[Unit]
Description=Kaizen Backend Node.js Service
After=network.target

[Service]
User=ubuntu
WorkingDirectory=/home/ubuntu/kaizen-backend
ExecStart=/usr/bin/node server.js
Restart=always
RestartSec=5
EnvironmentFile=/home/ubuntu/kaizen-backend/.env

[Install]
WantedBy=multi-user.target

Enable and Start

sudo systemctl daemon-reload
sudo systemctl enable kaizen-backend
sudo systemctl start kaizen-backend

Now the backend:

• Runs in the background

• Restarts automatically on crash

• Starts on server reboot

• Loads environment variables securely

This is how real services operate in production.

Part 3: Nginx Reverse Proxy + HTTPS

Exposing port 3000 publicly is a security risk.

So I installed Nginx as a reverse proxy.

All external traffic hits port 80 or 443.

Nginx forwards requests internally to localhost:3000.

Nginx Configuration

server {
    listen 80;
    server_name api.kaizen-tracker.in;

    location / {
        proxy_pass http://localhost:3000;
        proxy_http_version 1.1;
        proxy_set_header Host $host;
        proxy_cache_bypass $http_upgrade;
    }
}

Enabling HTTPS with Certbot

sudo certbot --nginx -d api.kaizen-tracker.in

Certbot:

• Configured SSL automatically

• Set up HTTP → HTTPS redirect

• Issued a valid Let’s Encrypt certificate

Backend is now live at:

https://api.kaizen-tracker.in

Part 4: Monitoring with CloudWatch

Monitoring is part of production not an afterthought.

I configured two AWS CloudWatch alarms:

• CPU Utilization > 15%

• StatusCheckFailed ≥ 1

Now I get notified if:

• The server is overloaded

• The instance health fails

Issues are detected before users complain.

Part 5: CI/CD Pipeline with GitHub Actions

Manual deployment is fragile.

Goal:

Every push to main (backend folder only) should automatically deploy to EC2.

Repository Secrets Added

• EC2_HOST

• EC2_SSH_KEY

• EC2_USERNAME

Pipeline Flow

On every qualifying push:

1. Back up live code

2. Deploy updated backend files

3. Restart systemd service

4. Run health check

5. Auto rollback if failure

Backup Before Deployment

cp -r /home/ubuntu/kaizen-backend \
/home/ubuntu/kaizen-backup-$(date +%Y%m%d%H%M%S)

Deploy and Restart

cd /home/ubuntu/kaizen-backend
git fetch origin main
git checkout origin/main -- backend/
npm install --production
sudo systemctl restart kaizen-backend

Health Check + Auto Rollback

sleep 5
if systemctl is-active --quiet kaizen-backend; then
  echo "Deployment successful."
else
  LATEST_BACKUP=$(ls -td /home/ubuntu/kaizen-backup-* | head -1)
  rm -rf /home/ubuntu/kaizen-backend
  cp -r $LATEST_BACKUP /home/ubuntu/kaizen-backend
  sudo systemctl restart kaizen-backend
  echo "Rollback complete."
  exit 1
fi

If deployment fails, the server restores the previous working state automatically.

That’s production-grade resilience.

The 10-Second Switch

After everything was configured, migrating the frontend was one line:

NEXT_PUBLIC_API_URL=https://api.kaizen-tracker.in

Redeploy frontend.

Done.

From the outside: 10 seconds.

From the inside: a full week of infrastructure engineering.

Key Takeaways

AWS EC2

Hands-on cloud infrastructure teaches more than any theory.

Understanding:

• Security groups

• SSH

• Cloud monitoring

• Server architecture

is essential for backend engineers.

systemd

Real services in Linux don’t rely on ad-hoc scripts.

They run as managed system services.

Nginx

Reverse proxy + SSL termination is a standard production pattern.

CI/CD + Rollback

Automation with health checks separates hobby projects from real systems.

Security Mindset

• Never expose internal ports

• Restrict SSH access

• Always enforce HTTPS

• Store secrets securely

Try Kaizen

The backend is now:

• Always-on

• Monitored

• Auto-deploying

• Self-healing on failure

You can try it here:

👉 https://www.kaizentracker.in

Sources & References

• AWS EC2 Deployment Guide

  https://youtu.be/nQdyiK7-VlQ?si=sR6PuvzS75CJ7nho

• GitHub DevOps Deployment Reference

  https://github.com/TusharVashishth/Devops/blob/main/nodejs-backend/deploy.md

If you have questions about the setup, feel free to connect on LinkedIn or drop a comment.

This sprint pushed me from “writing backend code” to understanding infrastructure ownership.

And that shift changes everything.