5 Real Production Projects Every SRE & DevOps Engineer Should Build
5 Real Production Projects Every SRE & DevOps Engineer Should Build
Most DevOps and Site Reliability Engineering tutorials focus on tools.
Real production environments focus on solving business problems.
After working on cloud infrastructure, Kubernetes platforms, CI/CD pipelines, observability platforms, and production migrations, I have found that the projects that impress interviewers the most are not toy projects. They are projects that solve real operational challenges.
If you are preparing for DevOps, SRE, Platform Engineering, Cloud Engineering, or Production Support roles, these are five projects I strongly recommend building.
These projects teach automation, reliability engineering, observability, incident management, cloud architecture, and troubleshooting skills that companies expect from experienced engineers.
1. Automated AWS Resource Tagging Using Shell Scripting and AWS CLI
The Problem
A production data migration platform was deployed using AWS services such as:
- AWS DMS
- Amazon Kinesis
- AWS Lambda
- Amazon RDS
- Amazon S3
During testing, several infrastructure changes were made manually through the AWS Console.
When the infrastructure was later deployed into production under tight deadlines, resources were created manually instead of using Terraform.
Months later, the cloud cost optimization team integrated CloudZero for cost reporting and discovered that resource tagging was inconsistent across the environment.
Without standard tags, accurate cost allocation became impossible.
The Solution
I built a production-grade shell script using:
- Bash
- AWS CLI
- JQ
The script:
- Reads AWS resource ARNs from a file
- Validates existing tags
- Applies missing standard tags
- Supports dry-run mode
- Generates execution logs
- Produces compliance reports
- Prevents overwriting compliant resources
Skills Learned
- Shell Scripting
- AWS CLI
- Cloud Governance
- Cost Optimization
- Production Automation
- Infrastructure Compliance
Why Interviewers Love This Project
It demonstrates:
- Real production ownership
- Automation mindset
- Cost governance
- Cloud operations experience
Most candidates know Bash commands.
Very few candidates can explain how automation solved a real production governance problem.
2. Measuring Service Reliability Using SLI, SLO, SLA, Error Budgets, and MTTR
The Problem
Many engineers know the definitions of:
- SLI
- SLO
- SLA
Very few know how to implement them in a production monitoring platform.
Modern SRE teams require measurable reliability objectives.
Without measurable reliability metrics, teams cannot understand:
- Availability
- Performance
- Error rates
- Reliability trends
The Solution
I built a complete reliability monitoring solution using:
- AWS EKS
- Kubernetes
- Java Spring Boot
- Prometheus
- Grafana
The application exposes metrics through:
- Spring Boot Actuator
- Micrometer
- Prometheus
Prometheus recording rules are used to calculate:
Service Level Indicators (SLIs)
- Request Success Rate
- HTTP Error Rate
- Application Reliability
Service Level Objectives (SLOs)
Example:
- 99.9% success rate over 30 days
Error Budgets
Allowed failures before violating the SLO.
Burn Rate
How quickly the error budget is being consumed.
MTTR
Mean Time To Recovery after incidents.
Skills Learned
- Site Reliability Engineering
- Prometheus
- Grafana
- Kubernetes Monitoring
- Alerting
- Reliability Engineering
Why Interviewers Love This Project
This project demonstrates that you understand:
- Reliability targets
- Production monitoring
- Alerting strategies
- Error budgets
- Operational excellence
These are core SRE concepts used at large technology companies.
3. Distributed Tracing for Microservices Using Prometheus, Grafana Tempo, and OpenTelemetry
The Problem
Traditional monitoring answers:
- Is the application healthy?
- How much CPU is being consumed?
- Are requests failing?
But it does not answer:
- Why is a request slow?
- Which service caused the delay?
- Which database query created the bottleneck?
When applications become distributed microservices, troubleshooting becomes significantly more difficult.
The Solution
I implemented distributed tracing using:
- Java Spring Boot
- OpenTelemetry (OTEL)
- Grafana Tempo
- Prometheus
- Grafana
The architecture works as follows:
Application Request
↓
Get Bhavuk Mudgal’s stories in your inbox
Join Medium for free to get updates from this writer.
OpenTelemetry Instrumentation
↓
Grafana Tempo
↓
Grafana Trace Visualization
↓
Root Cause Analysis
Using traces, engineers can:
- Follow a request across services
- Measure latency per component
- Identify bottlenecks
- Improve MTTR during incidents
Skills Learned
- Distributed Tracing
- OpenTelemetry
- Grafana Tempo
- Observability Engineering
- Microservices Troubleshooting
- Production Debugging
Why Interviewers Love This Project
Most candidates understand monitoring.
Very few understand observability.
This project immediately differentiates you from other candidates.
4. Migrating Millions of Records from MySQL to MongoDB Using AWS DMS
The Problem
Organizations frequently need to migrate data from relational databases into NoSQL platforms.
The challenge becomes significantly harder when:
- Millions of records are involved
- Downtime must be minimized
- Data integrity must be preserved
The Solution
I built a serverless event-driven migration pipeline using:
- Amazon RDS (MySQL)
- AWS DMS
- Amazon Kinesis Data Streams
- AWS Lambda
- MongoDB
Architecture
MySQL Database
↓
AWS DMS
↓
Amazon Kinesis Data Stream
↓
Python Lambda Function
↓
MongoDB
The solution supports:
- Real-time migration
- Event-driven processing
- Scalable architecture
- Near-zero downtime migration
Skills Learned
- Database Migration
- AWS DMS
- Event-Driven Architecture
- Kinesis
- AWS Lambda
- MongoDB
Why Interviewers Love This Project
This project demonstrates:
- Large-scale data engineering
- Cloud architecture
- Serverless design
- Production migration planning
These are highly valuable enterprise skills.
5. Centralized Log Aggregation Using Grafana Loki and Prometheus
The Problem
In Kubernetes environments, application logs are spread across:
- Multiple pods
- Multiple nodes
- Multiple namespaces
Searching logs manually is inefficient and slow during incidents.
The Solution
I implemented centralized logging using:
- Grafana Loki
- Promtail
- Prometheus
- Grafana
- Java Spring Boot
The logging pipeline:
Application Logs
↓
Promtail
↓
Grafana Loki
↓
Grafana Dashboards
↓
Incident Investigation
This allows engineers to:
- Search logs centrally
- Correlate logs with metrics
- Reduce troubleshooting time
- Improve incident response
Skills Learned
- Log Aggregation
- Loki
- Grafana
- Kubernetes Logging
- Production Troubleshooting
- Incident Management
Why Interviewers Love This Project
Logs are one of the primary tools used during production incidents.
This project demonstrates real-world operational experience.
Want Access to These Complete Projects?
All five projects discussed in this article are available inside my YouTube Membership Program, including:
✅ 70+ hours of DevOps & SRE live training recordings
✅ Production-grade Kubernetes projects
✅ Terraform and AWS projects
✅ SRE observability projects
✅ CI/CD implementations
✅ Members-only videos
✅ WhatsApp support community
👉 Join the YouTube Membership Program
Final Thoughts
Most engineers build projects to learn tools.
The best engineers build projects to solve production problems.
If you can confidently explain these five projects end-to-end, including architecture decisions, operational challenges, failure scenarios, monitoring strategy, and business impact, you will be significantly ahead of most DevOps and SRE candidates in interviews.
The goal is simple:
Learn the skills that are actually used in production and become the engineer companies want to hire.
Thousands of developers share what they’re building, learning, and discovering across our publications every month. One account connects you to our entire network of publications and communities. Explore more at plainenglish.io.
