How I Built My Terraform Portfolio: Projects, Repos, and Lessons Learned

Welcome Devs,

Today, we’re not spinning up infrastructure, writing HCL, or fixing a broken state file (for once 😅).

Instead, we’re looking back at the last 8 months—a journey filled with learning, building, breaking things, fixing them again, and slowly becoming “that Terraform guy” in my circle.

It all started in April 2025, when one of my LinkedIn buddies shared that he got selected as a HashiCorp Ambassador.

That was the first time I genuinely thought:

“Damn, this looks exciting. Why don’t I aim for it too?”

Just a month before that—in March 2025—I had been selected as an AWS Community Builder, and around the same time, I launched my YouTube channel to share DevOps and Infra-as-Code tutorials with the world.

Slowly, people started watching, sharing, and sending messages saying they actually deployed things using my guides.

So officially, in May 2025, I decided:

🔥 I’m going to prepare for HashiCorp Ambassador 2026. Let’s do this seriously.

Fast-forward 8 months—

I’ve built multiple Terraform projects, contributed to open-source repos, and crossed:

• 20,000+ views on my blogs

• 16,000+ views on YouTube

• 400+ awesome subscribers

More importantly, I went from “Terraform looks complicated” to “Terraform is my comfort zone.”

And today, I’m sharing the exact resources, projects, repos, and lessons that helped me go from Zero → Hero in Terraform — and will help you too.

1. Building a Strong Terraform Foundation

Even though I already had some familiarity with Terraform (thanks to scattered YouTube videos and random experiments), I decided to start from absolute zero—because if I’m going to teach something, I need to understand it deeply myself.

So the first thing I created was a “Getting Started with Terraform” guide.

This wasn’t just another intro blog. My goal was to help beginners understand:

• What Terraform really is

• Why DevOps engineers rely on IaC

• How providers work

• Structuring a project with main.tf, variables.tf, outputs.tf

• What “configuration” means in practice

Basically, the fundamentals you must know before touching any cloud resource.

If you are new, you can read the same guide here:

👉 Getting Started with Terraform – A Beginner’s Guide

Once the basics were sorted, I went deeper into the most important part of Terraform—

the thing that causes 90% of people stress when it breaks:

The Terraform State File

Where to store it?

How to keep it safe?

How to ensure teams don’t overwrite each other’s state?

I wrote a complete blog explaining how to use AWS S3 + DynamoDB as a rock-solid remote backend for production-grade Terraform.

I even created a YouTube demo for those who prefer watching over reading.

📘 Blog: Where Should You Store Terraform State Files for Maximum Efficiency?

🎥 Video: Terraform Remote Backend on AWS (S3 + DynamoDB)

These two resources became the backbone of my Terraform foundation—not just for me, but for everyone following along.

Before I moved to advanced projects, pipelines, and multi-environment infra… this foundation is what made everything else 10× easier.

2. Core Concepts & Best Practices (The Part Everyone Skips But Shouldn’t)

Once the foundations were clear, I moved into the phase where most beginners either get overwhelmed… or fall in love with Terraform.

For me, this was the moment things clicked.

Because understanding Terraform is not just learning commands — it’s learning structure, security, and scalability.

a) Terraform Modules – The Secret Sauce

One of the first “Aha!” moments for me was understanding modules.

If there’s one thing that separates beginners from pros, it’s this.

Modules teach you:

• How to avoid repetitive code

• How to scale infra easily

• How to structure projects cleanly

• How teams collaborate efficiently

I wrote an in-depth blog breaking this down and also created a complete YouTube walkthrough.

📘 Blog: Terraform Modules – The Secret Sauce to Scalable Infrastructure

🎥 Video: Terraform Module Explained with Demo

Learning modules improved how I thought about every project afterward.

b) Terraform Security Practices (Because IaC Without Security is Just a Script)

Infrastructure automation is amazing—but it also means if you make a mistake, you can take down everythinginstantly.

So I created a dedicated guide covering the Top 5 DevSecOps-focused Terraform security practices, including:

• Provider credential validation

• Role-based access

• Scanning Terraform code for vulnerabilities

• Remote backend security

• Avoiding manual state file edits (my favourite rule 😅)

📘 Blog: Terraform Meets DevSecOps – 5 Security Practices You Can’t Ignore

🎥 Video: Terraform Security Best Practices

This was the point where both my blog and channel started gaining real traction—people were searching for practical, real-world Terraform security advice.

c) Terraform Workspaces – The Most Underrated Feature Ever

Workspaces are like that quiet student in class who actually knows everything.

Nobody talks about them…

until they see how powerful multi-environment deployment becomes with a single command:

terraform workspace select dev
terraform workspace select prod

Workspaces changed how I approached multi-environment infra forever.

📘 Blog: Terraform Workspaces & Multi-Environment Deployments

🎥 Video: Complete Workspace Tutorial on AWS

d) Terraform Meets Ansible (IaC + Configuration Management = 🔥)

The next logical step was learning how Terraform works with configuration management tools.

Terraform builds the infra.

Ansible configures what lives inside the infra.

I created a hands-on guide where I showed exactly how Terraform provisions servers and Ansible configures them — a production-ready combo.

📘 Blog: Terraform Meets Ansible – Automating Multi-Environment Infra on AWS

🎥 Video: Terraform + Ansible Full Demo

This section was a turning point in my portfolio because it bridged two worlds—Infra-as-Code and Configuration Management.

3. CI/CD, Automation & Modern DevOps (Where Everything Comes Together)

After covering modules, security, workspaces, and multi-environment provisioning, it was time to bring Terraform into the real world —

the world of automation, pipelines, and DevOps workflows.

I had already used Terraform with Jenkins and even GitLab CI/CD in my previous projects (outside this series), so this time I wanted to do something fresh.

And what’s more “modern DevOps” than using GitHub Actions?

So I decided to build a real project that connects:

• Terraform

• GitHub Actions

• AWS

• And a production-style multi-component application (Node.js + Redis + Nginx)

The Project: Request Counter App Deployment on AWS

This wasn’t just a “hello world” project.

It involved:

• A Node.js API handling increment-count logic

• Redis to store the counter

• Nginx as a reverse proxy

• Terraform to provision AWS infra

• GitHub Actions to automatically deploy everything on push

In short, a full Infrastructure + Application + CI/CD pipeline — the kind of thing you actually do in real companies.

I documented the entire workflow so anyone can recreate it step-by-step.

📘 Blog: CI/CD for Terraform with GitHub Actions – Deploying a Node.js + Redis App on AWS

🎥 Video: GitHub Actions + Terraform Full Pipeline Demo

This project helped me understand how Terraform behaves inside a pipeline: the checks, the backend locks, the state consistency, the secret management — all of it.

And more importantly, it leveled up my DevOps portfolio significantly.

Real-world + automated + cloud-native = a perfect trifecta.

4. Cloud-Native & Multi-Tier Application Deployments (Intermediate Projects)

Once I became comfortable with Terraform fundamentals, DevSecOps practices, and CI/CD automation, it was time to step into the cloud-native world — where real production systems live and breathe.

This phase of my journey pushed me out of my comfort zone, because now I wasn’t just creating small demos.

I was building multi-tier, scalable, mission-critical infrastructures — the kind you’d actually find in modern companies.

a) Deploying a Three-Tier Application on AWS EKS (with Best Practices)

Kubernetes + Terraform is a whole universe on its own.

So to challenge myself, I decided to deploy a complete three-tier application on AWS EKS, fully automated using Terraform — following all real-world best practices.

This included:

• VPC with subnets

• Managed node groups

• Ingress controllers

• Load balancers

• Namespace separation

• Secrets + configs

• And a proper service-to-service communication workflow

It was one of the most complex setups I’d built at that point — and the most rewarding.

📘 Blog: Deploy a Three-Tier Application on AWS EKS using Terraform (Best Practices)

🎥 Video: EKS + Terraform Deployment Tutorial

(This video crossed 1,000+ views—first big milestone!)

b) Deploying a Highly Scalable & Available Django Application (AWS + Terraform)

After EKS, I wanted to explore another real-world architecture — something more traditional, but equally production-grade.

So I built a highly scalable Django application hosted on AWS using Terraform.

This project included all the standard AWS building blocks you’d expect in a real enterprise setup:

• RDS for relational database

• Secrets Manager for secure credentials

• Application Load Balancer

• Auto Scaling Group

• EC2 instances for compute

• Private/public subnets

• Proper network isolation and high availability

This architecture reflected how an actual company would deploy a Python backend in production.

📘 Blog: Deploying a Highly Scalable Django Application on AWS with Terraform

🎥 Video: Django + AWS + Terraform Full Architecture Demo

This stage of my Terraform portfolio strengthened my confidence in handling full-stack cloud-native deployments — not just isolated resources.

5. Game Deployments & Creative Infra Projects (The Standout Pieces)

Now, let’s talk about the most fun part of my Terraform journey — the projects that truly made my portfolio stand out.

I’ve been a gamer since childhood, and fun fact:

I actually bought my PS5 using the prize money I won as the Dev.to Runner-H Challenge Winner (Scolded by my Dad for this unjust purchase, but HELL YEAH!!, it was worth it.)

So, naturally, I decided to merge my love for gaming with my DevOps career.

The result?

Some of the most unique, creative, and highly engaging Terraform projects I’ve ever built.

a) Deploying Super Mario Bros on AWS EKS (Award-Winning Project)

This one will always be special.

I deployed the classic Super Mario Bros game on AWS EKS using Terraform — complete with pods, services, ingress, and Kubernetes best practices.

This project wasn’t just a hit among developers —

it actually helped me win the AWS Containers 4x4 Challenge, and I received some amazing premium swags from the community.

📘 Blog: Deploy Super Mario on AWS EKS using Terraform (Step-by-Step)

🎥 Video: Super Mario on Kubernetes Demo

b) Deploying Tetris on AWS ECS with Terraform

After nailing Mario, I didn’t want to stop.

Next, I deployed Tetris — this time using Amazon ECS with Terraform.

This project explores how containerized applications run on ECS Fargate, how services scale, and how ALBs route traffic.

📘 Blog: How to Deploy a Tetris Game on AWS ECS with Terraform

🎥 Video: Tetris on ECS – Full Walkthrough

c) Deploying Cognee AI Starter App on ECS (Collaboration Project)

One of the most exciting collaborations of my journey was with Cognee AI — the memory layer of AI Agents.

I built a Flask-based Cognee Starter Application from scratch, containerized it, and deployed it on AWS ECS using Terraform as the IaC backbone.

This project taught me a lot about real product deployment workflows, container orchestration, and DevOps collaboration.

📘 Blog: Deploying Cognee AI Starter App on ECS with Terraform

🎥 Video: Cognee AI Deployment Demo

d) Deploying an Amazon Clone on AWS (Amazon on AWS — Meta Enough?)

To wrap up this creative phase, I decided to do something hilarious and ambitious:

Deploying an Amazon Clone on… AWS itself.

Yes — Amazon on AWS. A true full-circle moment. 😂

This project used:

• Jenkins for CI/CD

• Terraform for infra

• AWS services like EC2, ALB, ASG, RDS, VPC

• And a full clone app architecture setup

📘 Blog: Deploy an Amazon Clone on AWS (Complete Guide with Jenkins + Terraform)

🎥 Video: Amazon Clone Deployment Tutorial

These projects became the highlights of my Terraform portfolio — the kind that make recruiters pause, smile, and think:

“Okay, this person actually enjoys building stuff.”

6. Reflection & Growth (The End of This Portfolio — But Not the Journey)

And now… here we are.

Eight months later.

Countless blogs, videos, deployments, wins, failures, swags, and late-night debugging sessions later — I finally paused and asked myself a very simple question:

“If a complete beginner asked me for guidance today… what would I say?”

Because when you’re learning something as powerful as Terraform, the hardest part isn’t understanding .tf files —

it’s navigating the early confusion, the overwhelming docs, the trial-and-error, and the mistakes we all make.

So to answer that question, I created a dedicated piece:

the top 5 mistakes beginners make while learning Terraform — and how to avoid them.

📘 Blog: Don’t Touch Terraform Before Avoiding These 5 Rookie Mistakes

🎥 Video: Top 5 Beginner Mistakes in Terraform

This video and blog were my way of giving back to anyone starting the same journey I took in April 2025.

If I could go back in time, this is exactly what I would hand to myself.

The Terraform Guide (Everything in One Place)

To make things easier for learners, I bundled every single blog — foundations, modules, state files, workspaces, EKS, ECS, CI/CD, everything — into a clean, structured series:

📚 Terraform Guide Series: All blogs in one place

This series now stands as a complete Zero-to-Hero path for anyone wanting to master Terraform using real projects.

Terraform Playlist (All Video Demonstrations)

And for visual learners, I created a dedicated playlist on YouTube containing every demo, from foundational projects to Kubernetes deployments and game infra:

🎥 Terraform Project Playlist

Conclusion

As I wrap up this 8-month Terraform journey, one thing is clear: this portfolio isn’t just a collection of .tf files — it’s a reflection of growth, discipline, creativity, and identity.

When I started back in April 2025, I didn’t know Terraform beyond the basics. I simply made a decision in May 2025:

“I will learn this tool properly and build something meaningful.”

Eight months later, here’s what that decision turned into:

• I learned Terraform from scratch

• Built real-world, production-style cloud infrastructures

• Won community challenges, including AWS Containers 4x4

• Collaborated on AI projects, like the Cognee AI deployment

• Published blogs that crossed 20,000+ views

• Grew my YouTube channel to 16,000+ views and 400+ subscribers

• And most importantly, built projects that genuinely reflect who I am as a DevOps engineer

This journey taught me that you don’t need a perfect starting point — you just need a consistent one.

It showed me that sharing your learning publicly builds connection, credibility, and confidence.

And it proved that passion projects (like deploying Super Mario and Tetris using Terraform) can teach you more than any textbook ever will.

If you’re just beginning your Terraform journey, I’ll leave you with this:

Start small. Stay consistent. Build publicly.

Because the internet remembers builders — not perfectionists.

Thank you for reading my story.

I hope this motivates you to start building your own.

📌 Connect With Me

🔗 LinkedIn: https://www.linkedin.com/in/pravesh-sudha/

🐦 Twitter/X: https://x.com/praveshstwt

📺 YouTube: https://www.youtube.com/@pravesh-sudha

🌐 Website/Blogs: https://blog.praveshsudha.com

Let’s keep learning and building — together.