DEV Community

Cover image for I Deployed My DevOps Project for FREE — Here's Exactly How (+ $200 Credit for You)
Yash Sonawane
Yash Sonawane

Posted on

I Deployed My DevOps Project for FREE — Here's Exactly How (+ $200 Credit for You)

#devops #kubernetes #docker #cloud

As a student, paying for cloud servers was slowly killing me. 💸

Every tutorial said "just spin up an EC2 instance" or "deploy to GKE." Cool. And then what — watch my AWS bill quietly climb to $40 a month just to run a tiny FastAPI app and a couple of Docker containers? No thanks.

I'm a B.Tech student actively building out my DevOps portfolio — Kubernetes clusters, CI/CD pipelines, containerized apps, the works. But here's the dirty secret nobody tells you: all of that practice costs money unless you're smart about it.

After bouncing between AWS Free Tier (confusing), GCP trials (expired too fast), and random VPS providers, I finally found something that actually worked for a broke student trying to build real projects: DigitalOcean.

Here's the full story of how I deployed my project for free, and exactly how you can do the same.

🧩 What I Actually Needed

I wasn't just looking for a place to run Hello World. I needed a real environment where I could practice:

  • Kubernetes — Deploying apps, writing manifests, rolling updates
  • Docker — Building and running containerized services
  • CI/CD — GitHub Actions pipelines that actually push to a real server
  • Monitoring — Prometheus and Grafana scraping real metrics

AWS and GCP are powerful, but for a student just getting started, they're genuinely overwhelming. The dashboards are dense, the IAM permissions feel like a maze, and the billing alerts give me anxiety.

I needed something with a clear monthly price, a clean interface, and documentation that doesn't assume I already work at Google.

☁️ Why I Chose DigitalOcean Over AWS and GCP

Let me be real — AWS and GCP are industry standards, and you should learn them eventually. But for a student building and breaking things daily, DigitalOcean just made more sense. Here's why:

1. Transparent, predictable pricing. A $6/month Droplet is a $6/month Droplet. No surprise bills from misconfigured S3 lifecycle policies.

2. Droplets are beginner-friendly. A Droplet is just a Linux VPS. You SSH in, run your commands, and it works. No VPC subnets to configure before you can even launch anything.

3. The documentation is genuinely good. Their community tutorials (like the ones on setting up Docker or Nginx) are some of the clearest I've read.

4. Managed Kubernetes (DOKS) is dead simple. Creating a Kubernetes cluster takes about 3 clicks. No eksctl flags to memorize.

5. One-click apps. Need a Postgres database or a Docker-ready Droplet? Done in seconds.

None of this means DigitalOcean is "better" than AWS in a job interview context — but for learning and building a portfolio, it removes friction massively.

🚀 What I Actually Deployed

The project I deployed was PostmortemAI — an AI-powered incident postmortem writer built with:

  • FastAPI for the backend API
  • Docker Compose for local and server orchestration
  • Prometheus + Alertmanager for monitoring hooks
  • GitHub Actions for CI/CD

Here's a simplified version of how the app runs inside a container:

# Dockerfile
FROM python:3.11-slim

WORKDIR /app
COPY requirements.txt .
RUN pip install -r requirements.txt

COPY . .

CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]
Enter fullscreen mode Exit fullscreen mode

And the Docker Compose setup:

# docker-compose.yml
version: "3.9"
services:
  api:
    build: .
    ports:
      - "8000:8000"
    environment:
      - ANTHROPIC_API_KEY=${ANTHROPIC_API_KEY}

  prometheus:
    image: prom/prometheus
    volumes:
      - ./prometheus.yml:/etc/prometheus/prometheus.yml
    ports:
      - "9090:9090"
Enter fullscreen mode Exit fullscreen mode

On DigitalOcean, I SSHed into my Droplet and ran:

git clone https://github.com/yashsonawane25/postmortem-ai
cd postmortem-ai
docker compose up -d
Enter fullscreen mode Exit fullscreen mode

That's it. Live on the internet in under 5 minutes.

🛠️ How to Get Started on DigitalOcean as a Student

Here's the exact flow I followed:

Step 1: Create an account

Go to digitalocean.com and sign up. You'll need a card for verification, but you won't be charged if you stay within your credits.

Step 2: Install doctl (the DigitalOcean CLI)

# macOS
brew install doctl

# Linux
snap install doctl

# Authenticate
doctl auth init
Enter fullscreen mode Exit fullscreen mode

Step 3: Create a Droplet

doctl compute droplet create my-devops-droplet \
  --size s-1vcpu-1gb \
  --image ubuntu-22-04-x64 \
  --region blr1 \
  --ssh-keys <your-key-id>
Enter fullscreen mode Exit fullscreen mode

Or just use the web UI — it's genuinely straightforward.

Step 4: SSH in and set up Docker

ssh root@<your-droplet-ip>

# Install Docker
curl -fsSL https://get.docker.com | sh

# Install Docker Compose
apt install docker-compose-plugin -y
Enter fullscreen mode Exit fullscreen mode

Step 5: Deploy your app

Clone your repo, add your .env file, and run docker compose up -d. Done.

🎁 The $200 Free Credit (Not a Sales Pitch, I Promise)

Okay here's the part I wish someone had told me earlier.

DigitalOcean gives $200 in free credits to new users — valid for 60 days. For a student, that's enough to:

  • Run a 2-node Kubernetes cluster (DOKS) for practice
  • Deploy 3–4 Droplets simultaneously
  • Set up a managed database
  • Run a full CI/CD pipeline end-to-end

That's a lot of learning runway without spending a rupee.

If you want to try it yourself, here's my referral link — you get the $200 credit, and I get a small credit too if you end up using it (full transparency):

👉 https://m.do.co/c/d0ae2c3c4e27

💡 Tips to Use the Free Credit Wisely

$200 sounds like a lot, but 60 days goes fast. Here's how I made mine count:

Destroy resources when not in use. A Droplet costs money even when idle. Use doctl compute droplet delete <id> when you're done for the day. Snapshots are cheap.

Use the smallest Droplet that works. For Docker + a small API, s-1vcpu-1gb ($6/month equivalent) is plenty. Don't spin up a $40 instance just to test a health check endpoint.

Prioritize managed Kubernetes. DOKS is where DigitalOcean really shines for students. Use it to practice deployments, Helm charts, and rolling updates — this is gold for your resume.

Document everything as you build. I turned every project into a DEV.to article or a GitHub README. Your learning compounds way faster when you write it down.

Set a billing alert. Go to Account → Billing → Alerts and set a threshold. Just because you have $200 free doesn't mean you should be careless.

🤝 Let's Build Together

I've been documenting my entire DevOps learning journey publicly — from setting up Kubernetes clusters on DigitalOcean, to building CI/CD pipelines with GitHub Actions, to deploying AI-powered tools with FastAPI.

If this post helped you, drop a comment below. And if you want me to write a full step-by-step tutorial on any of these topics, let me know:

  • 👉 Deploying a FastAPI app on DigitalOcean with Docker
  • 👉 Setting up a Kubernetes cluster (DOKS) from scratch
  • 👉 GitHub Actions CI/CD pipeline that deploys to a Droplet
  • 👉 Prometheus + Grafana monitoring on a $6 Droplet

Drop a comment with which one you want next, and I'll write it.

And if you grab the $200 credit and build something cool — share it. I'd genuinely love to see what you deploy. 🚀

Built this while studying B.Tech EE and learning DevOps in public. All code is on github.com/yashsonawane25.

Top comments (0)