← Back to Blog
Nov 27, 2025 12 min read

My Four-Year DevOps Plan at UMN

This is a living plan. I'll adapt it as I meet new mentors, join clubs, or uncover better learning paths. Future Minh, keep iterating!

When I first arrived at the University of Minnesota, I knew I wanted to work in tech, but I wasn't sure exactly where. After exploring different areas and building projects, I discovered DevOps and Site Reliability Engineering — the perfect intersection of systems thinking, automation, and problem-solving. This plan maps out how I'm using my CS and Math double major to build the foundation for a career in infrastructure engineering.

Year 1 — Foundations & Habits ✅

Status: Completed | Credits: 34 | GPA: 4.000

My freshman year was about building strong fundamentals. I focused on getting comfortable with the basics — calculus, discrete math, and introductory programming — while starting to explore what happens behind the scenes when code runs in production.

Academic Foundation

  • Mathematics: Math 1271 (Calculus I), Math 1372 (Calculus II)
    • Why it matters: Strong mathematical thinking is crucial for understanding algorithms, performance optimization, and capacity planning in distributed systems.
  • Computer Science:
    • CSE 1001 (First Year Experience) — Introduction to CS community and resources
    • CSCI 1133 (Intro to Computing and Programming Concepts) — Python fundamentals and problem-solving
      • Why it matters: Python is widely used in DevOps for automation, infrastructure tooling, and data analysis. This course gave me the programming foundation to write scripts, work with APIs, and build automation tools.
    • CSCI 2011 (Discrete Structures) — Logic, proofs, and algorithmic thinking
      • Why it matters: Discrete structures taught me formal logic and proof techniques, which are essential for reasoning about system correctness, understanding distributed algorithms, and debugging complex infrastructure issues systematically.
  • Physics: PHYS 1301W (Physics I with Writing)
    • Why it matters: Understanding systems, forces, and interactions at a fundamental level helps me think about how components interact in distributed systems.
  • General Education: GEOG 1372, GEOG 1502, HIST 1811, WRIT 1301 (Libed Requiremnet)
    • Writing skills are crucial for documentation, incident reports, and communicating technical concepts clearly.

Technical Skills I Built

Beyond coursework, I focused on practical DevOps fundamentals:

  • Git & GitHub fluency — Version control is the foundation of collaboration
  • Linux fundamentals + shell scripting — Most infrastructure runs on Linux; automation starts with scripts
  • Intro to networking — Understanding OSI layers, TCP/IP, DNS helps debug connectivity issues

Projects & Experiments

  • Automated my dotfile setup with shell scripts (my first taste of infrastructure automation)
  • Built this personal site and deployed it with GitHub Actions (learning CI/CD early)
  • Containerized a simple Go app with Docker (understanding isolation and portability)

Lessons Learned

The biggest lesson from Year 1: consistency beats intensity. I learned to study regularly rather than cramming, which helped me maintain a 4.0 GPA while still having time for side projects. I also discovered that I learn best by building things — reading about Docker is one thing, but actually containerizing an app makes concepts stick.

Year 2 — Tooling & Automation 🚧

Status: In Progress | Planned Credits: 34

Sophomore year is where theory meets practice. I'm taking courses that directly relate to understanding how computers work at a low level, which is essential for optimizing systems and debugging production issues.

Current Coursework (Spring 2025)

  • CSCI 1933 (Intro to Algorithms and Data Structures) — A- | 3.667 GPA
    • DevOps connection: Understanding algorithms and data structures is fundamental for optimizing infrastructure code, processing logs/metrics efficiently, and designing scalable systems. This course teaches me how to think about performance and complexity in automation scripts and monitoring pipelines.
  • MATH 2374 (Multivariable Calculus) — A | 4.000 GPA
    • DevOps connection: Optimization problems in calculus mirror capacity planning and resource allocation challenges in infrastructure.
  • PHYS 1302W (Physics II with Writing) — A- | 3.667 GPA
    • DevOps connection: Understanding waves, fields, and systems thinking applies to network protocols and distributed system behavior.
  • STAT 3021 (Intro to Probability and Statistics) — A | 4.000 GPA
    • DevOps connection: This is directly relevant! Monitoring, metrics, and observability all rely on statistical analysis. Understanding probability distributions, confidence intervals, and statistical inference is crucial for making data-driven decisions about reliability, alerting thresholds, and capacity planning in SRE work.

Planned Courses (Fall 2025 & Beyond)

  • CSCI 2021 (Machine Architecture & Organization)
    • Why I'm excited: Understanding CPU architecture, memory hierarchy, and instruction sets will help me optimize performance and understand bottlenecks in production systems.
  • CSCI 2041 (Advanced Programming Principles)
    • Why it matters: Learning design patterns, concurrency models, and software architecture principles will make me a better infrastructure engineer who can design reliable systems.
  • STAT 3301 (Regression and Statistical Computing)
    • Why it matters: Regression analysis is essential for understanding trends in system metrics, predicting capacity needs, and identifying correlations between different system components. Statistical computing skills will help me build better monitoring dashboards and analyze performance data effectively.
  • MATH 2142 (Elementary Linear Algebra)
    • Why it matters: Linear algebra is fundamental to machine learning applications in monitoring (anomaly detection, predictive scaling) and understanding how to model and optimize complex systems. These mathematical foundations help me think about system state, transformations, and optimization problems in infrastructure.
  • MATH 3283W (Sequences, Series, & Foundations)
    • Why it matters: Strengthening mathematical foundations for advanced topics in distributed systems and algorithms.

Technical Goals

This year, I'm moving from learning concepts to building real infrastructure:

  • Infrastructure as Code (IaC) — Write Terraform or Pulumi to manage cloud resources
  • CI/CD pipelines — Build sophisticated GitHub Actions workflows (beyond simple deploys)
  • Container orchestration — Learn Kubernetes fundamentals or explore Nomad for simpler use cases

Projects I'm Building

  • "Infrastructure as Code" repo — Version-controlled infrastructure for deploying this site (Terraform + GitHub Actions)
  • Monitoring stack demo — Prometheus + Grafana + alerting to understand observability in practice
  • Automated testing pipeline — Apply CI/CD principles to my coursework projects

Career Development

  • Exploring DevOps/SRE internships for Summer 2026
  • Joining tech clubs and attending local DevOps meetups
  • Building a portfolio that demonstrates infrastructure thinking

Reflection Questions

  • How comfortable am I debugging infrastructure issues independently?
  • Can I explain CI/CD pipelines to non-engineers clearly?
  • What's the most complex system I've designed and deployed?

Year 3 — Scaling & Reliability 📈

Status: Planned | Planned Credits: 36

Junior year is about depth. I'll be taking upper-level courses that directly prepare me for working with large-scale distributed systems, understanding how operating systems manage resources, and designing reliable architectures.

Core Computer Science Courses

  • CSCI 4061 (Intro to Operating Systems)
    • Why this is critical: Understanding process management, memory, file systems, and concurrency is fundamental to DevOps. When something breaks in production, I need to know what's happening at the OS level.
  • CSCI 3923 (Ethics in Computing)
    • Why this matters: As a DevOps engineer, I'll be responsible for systems that handle user data, security, and privacy. Understanding ethical considerations in computing — from data handling to algorithmic bias to system accessibility — is crucial for building responsible infrastructure that serves users well.
  • CSCI 4041 (Algorithms & Data Structures)
    • Why it's important: Efficient algorithms matter when processing logs, metrics, and traces at scale. This course will help me optimize monitoring pipelines and data processing.
  • CSCI 3081W (Program Design & Development)
    • Why it matters: Learning to design large software systems translates directly to designing infrastructure architectures. The writing component will improve my technical documentation skills.

Advanced Mathematics

  • MATH 5165 (Mathematical Logic I)
    • DevOps connection: Mathematical logic helps me reason about system correctness, understand formal verification methods, and think rigorously about distributed system properties like consistency and fault tolerance. This foundation is valuable for understanding proofs of correctness in system design and debugging complex issues.
  • MATH 5485 (Introduction to Numerical Methods I)
    • Why it matters: Numerical methods are essential for solving optimization problems in capacity planning, performance tuning, and resource allocation. These computational techniques help me understand how to efficiently solve problems that arise in infrastructure management, from load balancing algorithms to cost optimization.
  • MATH 5651 (Basic Theory of Probability & Statistics)
    • Critical for SRE: Understanding probability distributions, confidence intervals, and statistical inference is essential for making data-driven decisions about reliability, capacity, and alerting thresholds.
  • MATH 4242 (Applied Linear Algebra)
    • Why it matters: Applied linear algebra provides practical tools for solving real-world optimization problems in infrastructure. Understanding matrix operations, eigenvalues, and linear transformations helps me model system behavior, optimize resource allocation, and understand machine learning algorithms used in intelligent monitoring systems.

General Education

  • JOUR 1501 (Mass Media & Society) — Completing liberal education requirements
  • ESCI 1003 (Earth & Its Environments) — Completing liberal education requirements

Deep-Dive Technical Areas

By junior year, I want to have deep expertise in:

  • Observability: Logs, metrics, traces (OpenTelemetry) — the three pillars of understanding system behavior
  • Security: Secrets management, IAM, shift-left security testing — security is everyone's responsibility in DevOps
  • Cost optimization & capacity planning: Making data-driven decisions about resource allocation

Capstone-Worthy Projects

  • Multi-environment pipeline: Design and implement dev/stage/prod environments for a microservice with proper secrets management, monitoring, and rollback capabilities
  • Chaos engineering experiment: Run controlled experiments on a lab cluster to test system resilience
  • Technical writing: Publish blog posts or give talks about lessons learned from building infrastructure

Industry Experience Goals

  • Secure a DevOps/SRE internship at a company where I can work on real production systems
  • Contribute to open-source infrastructure projects
  • Build relationships with engineers in the field

Reflection Questions

  • Can I design an end-to-end architecture for a distributed system?
  • What leadership roles am I ready for (TA, mentor, project lead)?
  • How do I handle incidents and post-mortems?

Year 4 — Specialize & Elevate 🎓

Status: Planned | Planned Credits: 35

Senior year is about specialization and transition. I'll take graduate-level courses that push my understanding of distributed systems, databases, and optimization — all critical for senior DevOps/SRE roles.

Advanced Computer Science Courses

  • CSCI 5105 (Intro to Distributed Systems)
    • Why this is the capstone: This is the course that ties everything together. Understanding consensus algorithms, fault tolerance, and distributed coordination is essential for designing reliable infrastructure at scale.
  • CSCI 5103 (Operating Systems)
    • Why it matters: Graduate-level OS course will deepen my understanding of kernel internals, which helps when debugging performance issues and optimizing system calls.
  • CSCI 4707 (Practice of Database Systems)
    • Why it's important: Databases are at the heart of most applications. Understanding query optimization, replication, and backup strategies is crucial for database reliability engineering.
  • CSCI 4211 (Introduction to Computer Networks)
    • Why it matters: Advanced networking concepts for understanding complex network architectures, load balancing, and network security.
  • CSCI 5751 (Big Data Engineering and Architecture) — Currently unavailable
    • Why I want this: Big data engineering is directly relevant to DevOps at scale. Understanding how to process, store, and analyze massive volumes of logs, metrics, and traces is essential for modern SRE work. This course would teach me distributed data processing, storage systems, and architectures that power observability platforms.

Advanced Mathematics & Statistics

  • MATH 5711 (Linear Programming & Combinatorial Optimization)
    • DevOps connection: Resource allocation, scheduling, and capacity planning are optimization problems. This course will give me the mathematical tools to make better infrastructure decisions.
  • MATH 5486 (Introduction To Numerical Methods II)
    • Why it matters: Advanced numerical methods build on the foundation from Numerical Methods I, giving me more sophisticated tools for solving optimization problems in infrastructure. These techniques are directly applicable to performance tuning, cost optimization, and solving complex resource allocation challenges in distributed systems.
  • MATH 5707 (Graph Theory and Non-enumerative Combinatorics)
    • Why it's critical: Graph theory is fundamental to understanding network topologies, dependency graphs, and system architectures. Combinatorics helps me reason about system configurations, optimization problems, and the complexity of infrastructure design. These mathematical tools are essential for modeling and analyzing distributed systems.
  • STAT 5102 (Theory of Statistics II)
    • Why it matters: Advanced statistical methods for analyzing monitoring data and making data-driven reliability decisions.
  • MATH 4281 (Introduction to Modern Algebra)
    • Why it matters: Completing my math major while strengthening abstract thinking skills.

General Education

  • Literature libed requirement — Finishing liberal education requirements

Leadership & Mentorship

  • Teaching Assistant for DevOps-related courses (if available) or CS courses
  • Mentor underclassmen in VSA and tech clubs, sharing what I've learned
  • Lead infrastructure projects in student organizations

Career Preparation

  • Portfolio with case studies: Document real infrastructure projects with before/after metrics, challenges faced, and lessons learned
  • Mock interviews: Practice system design interviews and incident response scenarios
  • Job search strategy: Evaluate offers from cloud companies, startups, and consider grad school for research paths

Long-Term Vision

I'm keeping my options open, but I'm particularly interested in:

  • SRE at a cloud company (AWS, GCP, Azure) — Working on infrastructure at massive scale
  • Platform engineer at a startup — Building infrastructure from the ground up, wearing many hats
  • Specialization areas: Kubernetes, edge computing, or platform security

The beauty of DevOps is that it's a mindset and skill set that applies everywhere. I want to find a role where I can have real impact while continuing to learn.

Reflection Questions

  • What impact do I want to have in my first 2–3 years after graduation?
  • What lifelong learning habits will I maintain?
  • How will I give back to the community that helped me learn?

Academic Progress Summary

Year Status Credits GPA Key Focus
Freshman ✅ Completed 34 4.000 Foundations & fundamentals
Sophomore 🚧 In Progress 34 — Tooling & automation
Junior 📅 Planned 36 — Scaling & reliability
Senior 📅 Planned 35 — Specialization & transition
Total — 139 — —

Why This Path?

Some people ask why I'm pursuing a double major in CS and Math when I could focus solely on practical DevOps skills. Here's my thinking:

  1. Deep understanding beats surface knowledge: When a production system fails at 3 AM, I want to understand what's happening at every layer — from the application code to the network stack to the operating system.
  2. Mathematics is the language of systems: Probability and statistics help me make data-driven decisions about reliability. Optimization theory helps me allocate resources efficiently. Linear algebra underlies machine learning applications in monitoring.
  3. Long-term career flexibility: A strong theoretical foundation means I can adapt as technology evolves. The tools change (Terraform today, something new tomorrow), but the principles remain.
  4. I genuinely enjoy it: I find beauty in elegant algorithms, clean proofs, and well-designed systems. This isn't just a career path — it's what I'm passionate about.

Resources & Learning

Beyond coursework, I'm continuously learning through:

  • Books: The Site Reliability Engineering Book, The Phoenix Project, Designing Data-Intensive Applications
  • Podcasts: Software Engineering Daily, The Changelog, Kubernetes Podcast
  • Communities: Local DevOps meetups, online forums, open-source contributions
  • Practice: Building projects, contributing to open source, writing about what I learn

Final Thoughts

This plan is a living document. As I progress, I'll update it with:

  • Actual course experiences and what I learned
  • Projects I've completed
  • Internships and industry experiences
  • Adjustments based on new interests or opportunities

The goal isn't to follow this plan perfectly — it's to have a clear direction while remaining flexible enough to adapt when I discover better paths or new interests.

If you're a fellow student or early-career engineer on a similar journey, I'd love to connect and learn together. Building infrastructure is a team sport, and the best learning happens in community.

Last updated: November 2025 | This plan is continuously updated as I progress through my degree. Course selections may change based on availability, prerequisites, and evolving interests in DevOps/SRE.

← Back to Blog All Posts