How to Switch to DevOps From Support, Testing, or SysAdmin (Complete Career Guide)

Last Updated: January 2026

So you’re thinking about moving into DevOps. Maybe you’re tired of the support ticket grind. Or testing feels like a dead-end. Or you’re a sysadmin watching everything move to the cloud while your company still treats servers like pets instead of cattle.

I made this exact transition four years ago. Went from being a support engineer answering the same password reset tickets every day to actually building the systems. And honestly? I should have done it sooner.

But here’s what nobody tells you when you’re researching “how to switch to DevOps”—there’s no single path. The route from support looks different than from testing, which looks different than from sysadmin. Your starting point matters because you’ve already got skills that transfer, you just don’t know which ones yet.

This guide is everything I wish someone had told me before I started. The real talk about timelines, the skills that actually matter, the mistakes that’ll waste your time, and the specific steps for your current role.

Why DevOps? (And Why Now?)

Let’s start with the obvious question—why bother switching?

Money. Yeah, I’m going there first because everyone thinks it but pretends they don’t care. DevOps engineers make significantly more than support, testing, or even many sysadmin roles. We’re talking $30-50k salary jumps in most markets. That’s real money that changes your life.

Career growth. Support roles often plateau. Testing can too. DevOps has a clear progression—junior to mid to senior to staff to principal. I’ve watched support engineers stuck at the same level for 5+ years. In DevOps, if you’re good, you move up.

Market demand. Every company needs DevOps now. Not just tech companies—retail, healthcare, finance, manufacturing. Cloud adoption forced the issue. If you know Kubernetes, Terraform, and AWS, recruiters won’t leave you alone.

The work is different. Instead of reacting to problems all day, you’re building systems that prevent problems. Instead of following runbooks, you’re writing automation. Instead of being at the mercy of developers or operations, you’re the bridge between them.

Also, less pager duty than traditional sysadmin work, though on-call still exists. But modern observability and automation means 3 AM pages are usually quick fixes or auto-resolved before you even login.

Understanding What DevOps Actually Is

Here’s where people get confused. “DevOps” means different things at different companies.

At some places, DevOps engineers are basically cloud sysadmins. They manage AWS infrastructure, handle deployments, maintain servers (virtual ones, but still).

Other companies want software engineers who understand operations. You’re writing code daily—building internal tools, creating automation, developing deployment systems.

Then there’s the “true DevOps” philosophy where it’s not even a separate role but a practice embedded across engineering teams.

For this guide, I’m focusing on DevOps as a distinct engineering role because that’s what most companies hire for. The job usually involves:

• Building and maintaining CI/CD pipelines
• Managing cloud infrastructure (AWS, Azure, GCP)
• Writing infrastructure as code (Terraform, CloudFormation, Pulumi)
• Container orchestration (Docker, Kubernetes)
• Monitoring, logging, observability setup
• Automating operations tasks
• Collaborating with development and operations teams

You’re not purely coding and you’re not purely operating systems. You’re somewhere in the middle, which is actually pretty cool when you find the right balance.

Your Starting Point Matters: Honest Assessment

Before diving into specific paths, be honest about where you’re starting from. I’ve mentored people from all three backgrounds and the timeline varies significantly.

From Support:

• Advantages: You know common problems users face, you understand customer impact, you’ve probably touched multiple systems
• Gaps: Usually limited scripting experience, may not understand infrastructure deeply, coding skills often weak
• Realistic timeline: 8-12 months of focused learning to become job-ready

From Testing:

• Advantages: Already familiar with automation tools, understand software development lifecycle, usually know some scripting
• Gaps: Infrastructure knowledge is often shallow, networking and systems administration concepts need work
• Realistic timeline: 6-10 months with dedicated effort

From SysAdmin:

• Advantages: Strong infrastructure knowledge, comfortable with Linux, understand networking and security
• Gaps: Coding and software development practices, modern cloud services, container technologies
• Realistic timeline: 4-8 months if you embrace the coding aspect

These timelines assume you’re studying 10-15 hours per week while working full-time. If you can dedicate more time or already have some overlapping skills, you’ll move faster.

Path from Support Engineer to DevOps

I started here, so I’ll be detailed.

Month 1-2: Linux Fundamentals

You need to get comfortable in the terminal. Not just basic commands—actually comfortable.

Install Ubuntu or any Linux distro. Use it as your primary OS if possible. Force yourself to do everything via command line initially.

What to learn:

• File system navigation (cd, ls, pwd, find, locate)
• File operations (cp, mv, rm, touch, cat, grep, sed, awk)
• Permissions (chmod, chown, understanding user/group/other)
• Process management (ps, top, htop, kill, systemd)
• Package management (apt, yum, depending on distro)
• Basic networking (ping, curl, wget, netstat, ss)
• SSH and remote access

Don’t just watch tutorials. Do these things:

1. Setup a local web server (Apache or Nginx)
2. Configure it to serve a simple HTML page
3. Break the configuration on purpose
4. Fix it using logs and documentation
5. Automate the setup with a bash script

Month 3-4: Scripting and Basic Programming

Support people often avoid coding. Big mistake. You don’t need to be a software engineer, but you need to write scripts.

Start with Bash, then add Python.

Bash:

• Variables and data types
• Loops (for, while)
• Conditionals (if/else, case statements)
• Functions
• Error handling
• Working with files and text

Python basics:

• Variables, data structures (lists, dicts, sets)
• Control flow (if/else, loops)
• Functions and modules
• File operations
• API calls with requests library
• Working with JSON and YAML

Write real scripts, not tutorials exercises:

1. Log analyzer that counts error types
2. User provisioning script (creates users, sets permissions)
3. Backup automation script
4. Health check script for services
5. API integration script (pull data from some API, process it)

Put everything on GitHub. Even if it’s basic, you’re building a portfolio.

Month 5-6: Cloud Platform Basics

Pick AWS. I don’t care if the company you want to work for uses Azure or GCP, start with AWS. It has the most jobs and once you know one cloud, others are easier.

Get the AWS free tier account. Don’t just watch courses—launch actual resources.

Core services to learn:

• EC2 (instances, security groups, key pairs)
• S3 (buckets, versioning, policies)
• VPC (subnets, route tables, internet gateways)
• IAM (users, roles, policies)
• Load Balancers (ALB basics)
• RDS (basic database setup)

Projects to do:

1. Launch a web application on EC2 with proper security groups
2. Setup a static website on S3 with CloudFront
3. Create a VPC with public and private subnets
4. Setup IAM roles for services instead of using access keys
5. Deploy a load-balanced application across multiple instances

Track your costs. Set billing alarms. Nothing teaches cloud economics like accidentally leaving a large EC2 instance running for a week.

Month 7-8: Containers and Docker

Docker is non-negotiable in 2024/2025. Every DevOps job expects it.

What to learn:

• Docker concepts (images, containers, registries)
• Writing Dockerfiles
• Docker commands (run, build, exec, logs, ps)
• Docker networking
• Volumes and data persistence
• Docker Compose for multi-container apps

Projects:

1. Dockerize a simple web app (Node, Python, whatever)
2. Multi-stage builds to optimize image size
3. Docker Compose setup with app + database + redis
4. Custom networking between containers
5. Push images to Docker Hub

Month 9-10: CI/CD Pipelines

This is where you start actually doing DevOps work.

Pick one CI/CD tool. Jenkins is everywhere in enterprises but clunky. GitHub Actions is modern and easier. GitLab CI is solid too. I’d go with GitHub Actions for learning.

Learn:

• Git branching strategies (feature branches, gitflow)
• Pipeline concepts (stages, jobs, steps)
• Running tests automatically
• Building Docker images in CI
• Deploying to environments
• Secrets management

Build a real pipeline:

1. Code repository on GitHub
2. Automated tests run on every PR
3. Build Docker image on merge to main
4. Push image to registry
5. Deploy to staging environment automatically
6. Manual approval step for production
7. Deploy to production

This project alone will teach you more than 10 courses.

Month 11-12: Infrastructure as Code and Kubernetes Basics

Terraform:

• Learn HCL syntax
• Understand state management
• Write modules for reusability
• Deploy actual infrastructure

Kubernetes: You don’t need to be a K8s expert from support, but understand the basics:

• What problems Kubernetes solves
• Pods, Deployments, Services
• Basic kubectl commands
• Deploy a simple app to minikube

At this point, you’re job-ready for junior DevOps roles. Not senior, not mid-level, but you can interview and get offers.

Path from QA/Testing to DevOps

Testers have an advantage—you already understand automation.

Month 1-2: Deepen Your Linux and Scripting

You probably have some scripting knowledge from test automation. Level it up.

Focus on:

• Advanced bash scripting
• Python for infrastructure (not just testing)
• Working with APIs
• Understanding system architecture

The goal: write scripts that manage infrastructure, not just tests.

Month 3-4: Infrastructure Fundamentals

This is your gap area. Learn:

• How servers actually work
• Networking basics (TCP/IP, DNS, load balancing)
• Databases and data persistence
• Web servers (Nginx, Apache)
• Application deployment process

Setup a homelab or use cloud free tiers. Break things. Fix things. Learn how systems fail.

Month 5-6: Cloud Platforms

Same as support path—pick AWS, learn core services.

Your testing background helps here because you think about failure scenarios and testing edge cases. Apply that mindset to infrastructure.

Month 7-8: CI/CD Deep Dive

You’ve probably used CI/CD for test automation. Now learn the full pipeline:

• Code checkout
• Building applications
• Running all types of tests (unit, integration, e2e)
• Container image creation
• Security scanning
• Deployment strategies (blue-green, canary)
• Rollback procedures

Leverage your testing knowledge. Create comprehensive test stages in pipelines. This is where you add unique value.

Month 9-10: Containers and Orchestration

Docker, then Kubernetes. Same as other paths but you might move faster because container concepts are similar to test environments.

Month 11-12: Infrastructure as Code and Monitoring

Learn Terraform and basic Kubernetes.

Add monitoring and observability—this connects to your testing background. You understand what to test; now learn what to monitor.

Path from SysAdmin to DevOps

Sysadmins have the strongest foundation for DevOps but often resist the cultural shift.

Month 1-2: Embrace Coding

Stop treating code like it’s “not your job.” It is now.

Pick Python. Learn it properly:

• Object-oriented programming basics
• Working with libraries and packages
• Git version control (actually using branches, not just committing to master)
• Writing testable code
• Reading others’ code

The hardest part for sysadmins? Accepting that “write code to automate it” beats “manually do it perfectly” every time. Embrace imperfect automation over perfect manual processes.

Month 3-4: Modern Version Control and Collaboration

You’ve probably used Git minimally. Level up:

• Branching strategies
• Pull requests and code review
• Merge conflict resolution
• Git hooks for automation
• Collaborative workflows

Learn to work like developers work. No more cowboy changes in production.

Month 5-6: Cloud Infrastructure

This is where you’re strongest but need to shift thinking.

You know infrastructure deeply. Now learn cloud infrastructure:

• Treat servers as disposable (cattle, not pets)
• Embrace auto-scaling and elasticity
• Think in terms of managed services vs. self-hosting
• Cost optimization and rightsizing
• Cloud-native architecture patterns

The mental shift: stop trying to SSH into servers to fix things. Automate, redeploy, scale horizontally.

Month 7-8: Infrastructure as Code

This is YOUR superpower area.

Learn Terraform deeply:

• State management and backends
• Module development
• Count and for_each patterns
• Workspaces for environments
• Importing existing infrastructure

Translate your existing infrastructure knowledge into code. Every manual thing you’ve done? Write Terraform for it.

Month 9-10: Containers and Kubernetes

Docker concepts will click quickly because you understand virtualization.

Kubernetes is more complex. Focus on:

• Architecture and components
• Deployments and StatefulSets
• Services and Ingress
• ConfigMaps and Secrets
• Storage and persistence
• RBAC and security

Month 11-12: CI/CD and Modern Practices

This is your weak area—software delivery practices.

Learn:

• Pipeline design and best practices
• Automated testing integration
• Deployment strategies
• GitOps workflows
• Observability and monitoring

Study how modern companies ship code. It’s different from traditional IT operations.

Skills Every Path Needs (The Core)

Regardless of where you’re coming from, these are non-negotiable:

Linux proficiency – You should be faster in terminal than GUI

Scripting – Bash and Python at minimum

Git – Proper workflows, not just basic commits

One cloud platform – AWS preferred, know it well

Docker – Comfortable building images and running containers

CI/CD – Build at least one complete pipeline end-to-end

Basic Kubernetes – Understand concepts, deploy simple apps

Infrastructure as Code – Terraform is most common

Networking – TCP/IP, DNS, HTTP, load balancing basics

Security – IAM, secrets management, basic hardening

You don’t need to be expert-level in everything. But you need working knowledge across the board.

The Learning Strategy That Actually Works

Here’s what doesn’t work: watching tutorial videos for 3 months straight. You’ll forget everything.

What works:

1. Project-based learning Every skill you learn, immediately apply it in a project. Don’t move to the next topic until you’ve built something.

2. Learn in public Document what you’re learning. Write blog posts (even if nobody reads them). Create GitHub repos with README files explaining what you built. This becomes your portfolio.

3. Break things on purpose Don’t just follow tutorials that work. Intentionally break your setups and fix them. This teaches you how to troubleshoot.

4. Time-box your learning Give yourself strict deadlines. “I will deploy a Dockerized app to AWS by end of this week” beats “I’ll learn Docker when I have time.”

5. Join communities Reddit’s r/devops, Discord servers, local meetups. Ask questions. Help others. You learn by teaching.

6. Contribute to open source Even small contributions count. Fix documentation, report bugs, submit small PRs. It shows you can work collaboratively.

Building Your Portfolio (This Actually Matters)

Recruiters look at GitHub. Not your resume first—your GitHub.

What to include:

Infrastructure projects:

• Multi-tier application deployed on AWS with Terraform
• Kubernetes cluster setup with monitoring
• CI/CD pipeline examples

Automation scripts:

• Backup automation
• Log analysis tools
• Deployment scripts

Documentation:

• Every repo needs a detailed README
• Architecture diagrams (use draw.io)
• Setup instructions someone else can follow

Blog (optional but valuable):

• Write about what you’re learning
• Explain complex topics simply
• Share mistakes and how you fixed them

Quality over quantity. Three well-documented, working projects beat 20 half-finished repos.

Getting Your First DevOps Job

You’re ready to apply when you can:

• Comfortably discuss your projects in detail
• Explain DevOps concepts clearly
• Troubleshoot issues in your own setups
• Write Terraform to deploy basic infrastructure
• Build and deploy a containerized application
• Setup a complete CI/CD pipeline

Where to apply:

Start with smaller companies. They’re more willing to take chances on career switchers.

Look for:

• Junior DevOps Engineer
• DevOps Engineer (not requiring 5+ years)
• Cloud Engineer
• Site Reliability Engineer (entry-level)
• Platform Engineer

Avoid “Senior DevOps” or “DevOps Architect” roles. Be realistic about your level.

Resume tips:

• Lead with projects, not job duties
• Quantify everything (“reduced deployment time by 75%”)
• Highlight transferable skills from current role
• Include relevant certifications if you have them
• Keep it to one page

Interview prep:

Technical questions will cover:

• Linux troubleshooting scenarios
• Git workflows
• Docker concepts
• Basic Kubernetes
• Cloud services (especially AWS)
• CI/CD pipeline design
• Scripting challenges

Practice on platforms like:

• KodeKloud for hands-on scenarios
• LeetCode for coding problems
• System design questions (basics)

Behavioral questions matter too:

• Why switch to DevOps?
• Tell me about a time you automated something
• How do you handle production incidents?
• Describe a technical challenge you solved

Be honest. “I’m transitioning from support and here’s what I’ve built to prepare” works better than pretending you’re experienced.

The Money Talk (Because It Matters)

Let’s talk salary expectations realistically.

Junior DevOps Engineer (0-2 years):

• US markets: $70k-95k depending on location
• Indian market: ₹4 LPA – ₹9 LPA
• Major tech hubs: $90k-120k
• Remote positions: $75k-100k

Mid-level (2-5 years):

• US markets: $100k-140k
• Indian markets: ₹7 LPA – ₹15 LPA
• Major tech hubs: $130k-180k
• Remote: $110k-150k

Career switchers usually start at the lower end of junior ranges, even if you have years of experience in support/testing/sysadmin. That’s frustrating but temporary.

After 1-2 years as a DevOps engineer, you can jump significantly. The market rewards DevOps experience heavily.

Common Mistakes Career Switchers Make

I made these mistakes. You don’t have to.

Mistake 1: Tutorial hell Watching courses endlessly without building anything. Stop consuming. Start creating.

Mistake 2: Trying to learn everything You don’t need to know AWS, Azure, GCP, 5 CI/CD tools, 3 orchestration platforms. Pick one, learn it well.

Mistake 3: Ignoring fundamentals Jumping to Kubernetes before understanding containers. Learning Terraform before understanding cloud services. Fundamentals matter.

Mistake 4: Not networking Connections get you interviews. Attend meetups, engage on LinkedIn, join Slack communities. Most jobs aren’t posted publicly.

Mistake 5: Staying too long in learning mode At some point, you need to apply for jobs even if you don’t feel “ready.” You’ll never feel completely ready.

Mistake 6: Lying in interviews Don’t claim experience you don’t have. Interviewers can tell. Be honest about being a career switcher with relevant projects.

Mistake 7: Giving up too soon You’ll get rejected. A lot. That’s normal. I was rejected 15+ times before getting my first DevOps offer. Keep going.

The Reality Check

Let me be straight with you about a few things:

It’s not easy. Career transitions require real effort. 10-15 hours weekly for 6-12 months while working full-time is draining.

Age bias exists. If you’re over 40, switching careers gets harder. Not impossible—I know people who’ve done it—but harder. Ageism in tech is real.

You’ll take a pay cut initially. Maybe. Depends on your current salary and the role you land. Sometimes the junior DevOps salary exceeds support salaries, sometimes not.

Imposter syndrome is real. You’ll feel like you don’t belong. Everyone does. Push through it.

The learning never stops. DevOps changes fast. New tools constantly. Continuous learning is mandatory, not optional.

On-call responsibility. Many DevOps roles have on-call rotations. Get used to the idea of 3 AM pages (though good monitoring minimizes these).

But here’s the thing—it’s still worth it.

Timeline Expectations (Real Talk)

Everyone wants to know “how long will this take?”

Absolute minimum (aggressive):

• 4-6 months if you’re a sysadmin dedicating 20+ hours weekly
• You’ll be bare-bones qualified but employable

Realistic for most people:

• 8-12 months with 10-15 hours weekly study
• You’ll feel somewhat confident in interviews
• Your projects will be solid

Comfortable timeline:

• 12-18 months at a reasonable pace
• You’ll have depth in multiple areas
• Less stress, better retention

Add 2-4 months for job searching, interviews, and offers.

So from “I want to switch to DevOps” to “I start my new DevOps job” is realistically 12-18 months for most people. Faster if you’re already technical, slower if you’re starting from scratch.

Maintaining Sanity During the Transition

This process is mentally exhausting. Some tips:

Take breaks. Burnout helps nobody. Study 5 days, rest 2. Or whatever rhythm works.

Celebrate small wins. Got a script working? Deployed to AWS successfully? Celebrate it.

Find an accountability partner. Someone else making the same transition. Check in weekly.

Don’t quit your job prematurely. Wait until you have an offer. Financial stress makes learning harder.

Exercise and sleep. Seriously. Your brain needs both to retain information.

Accept that some days you’ll learn nothing. That’s okay. Consistency over perfection.

Frequently Asked Questions

Do I need a computer science degree to become a DevOps engineer?

No. I don’t have one, and plenty of successful DevOps engineers don’t either. What matters is practical skills—can you build infrastructure, write automation, and troubleshoot systems? Self-taught people get hired all the time if they can demonstrate competence through projects and portfolios. Focus on building real things rather than worrying about credentials.

Should I get certifications before applying to jobs?

Certifications help but aren’t mandatory. AWS Certified Solutions Architect Associate is the most valuable if you’re getting one. It signals cloud competency to recruiters. That said, I’d prioritize hands-on projects over certifications. If you have time and budget for both, great. If choosing one, build projects first, get certified later. Some people land jobs without any certs based purely on portfolio strength.

How do I explain my career switch in interviews?

Be honest and enthusiastic. Something like: “I’ve been in support for 5 years and realized I want to build the systems rather than just support them. I spent the last 8 months learning DevOps practices, built several projects deploying infrastructure and CI/CD pipelines, and I’m excited to transition into this role.” Frame it as progression, not escape. Emphasize transferable skills from your current role.

Can I make this switch while working full-time?

Yes, and most people do. Allocate 10-15 hours weekly—maybe 1.5 hours on weeknights and 3-4 hours each weekend day. It’s doable but requires discipline. Use lunch breaks for reading, evenings for hands-on practice. The key is consistency. Sporadic intense studying doesn’t work as well as regular moderate effort. It’ll take longer than full-time learning, but it’s the realistic path for people with bills to pay.

What’s the difference between DevOps, SRE, and Platform Engineer?

The lines blur depending on company, but generally: DevOps focuses on automation, CI/CD, and bridging development and operations. SRE (Site Reliability Engineer) emphasizes system reliability, uptime, and incident response—more operational. Platform Engineers build internal platforms and tools for other engineers. In practice, there’s 70% overlap. Don’t get too hung up on titles—look at actual job descriptions to understand what each company wants.

Is DevOps saturated? Are there too many people switching into it?

Market demand still exceeds supply for qualified DevOps engineers. Yes, more people are learning DevOps, but most companies struggle to find good candidates. The key word: qualified. If you actually have hands-on skills and can demonstrate them, you’ll find opportunities. The market is saturated with people who watched a few YouTube videos and called themselves DevOps engineers. If you put in real work building projects and understanding concepts deeply, you’ll stand out.

Should I specialize in AWS, Azure, or GCP?

Start with AWS—it has the largest market share and most job openings. Once you deeply understand one cloud platform, the others are easier to learn because concepts transfer. Multi-cloud knowledge is valuable for senior roles, but when you’re starting, focus beats breadth. Check job postings in your target market if you’re unsure, but AWS is usually the safe bet.

How important is Kubernetes knowledge for getting hired?

Very important for most DevOps roles in 2024-2025. You don’t need to be a Kubernetes expert, but understanding core concepts (pods, deployments, services, basic kubectl) is expected. Many companies run production workloads on Kubernetes, so having zero knowledge limits your opportunities. That said, prioritize it after learning Docker, Linux, and basic cloud infrastructure. Build your foundation first.

Can I switch to DevOps if I’m not good at coding?

You need scripting skills—there’s no way around it. But you don’t need to be a software engineer. Focus on Python and Bash for automation and infrastructure tasks. If you genuinely hate coding, DevOps might not be the right fit. But if you’re just intimidated, start small with simple scripts and build confidence. Most DevOps code is practical automation, not complex algorithms. It’s learnable if you’re willing to practice.

What’s the biggest challenge in switching to DevOps?

For most people, it’s the breadth of knowledge required. You need to understand operating systems, networking, cloud services, containers, orchestration, CI/CD, security, monitoring—the list goes on. It feels overwhelming. The solution: learn sequentially, master fundamentals before advanced topics, and accept you won’t know everything before getting your first job. You’ll learn a ton on the job. Focus on being job-ready, not expert-level, for your first role.

Wrapping This All Up

Switching to DevOps from support, testing, or sysadmin is totally doable. I did it. Hundreds of people I’ve talked to did it. You can too.

But you need to be realistic about the effort required and the timeline involved. This isn’t a 3-month bootcamp situation where you magically become a DevOps engineer. It’s 8-12+ months of focused learning, building projects, making mistakes, and gradually developing real skills.

The path depends on your starting point. Support engineers need to level up their technical depth. Testers need infrastructure knowledge. Sysadmins need to embrace modern practices and coding.

But all paths converge on the same core skills: Linux, scripting, cloud platforms, containers, CI/CD, and infrastructure as code.

Start today. Not tomorrow. Not next month. Pick the first skill on your path and do something—install Linux, write a script, launch an EC2 instance. Small consistent action beats planning perfectly.

The DevOps market rewards people who can actually do the work. Build things. Break things. Fix things. Put it all on GitHub. That’s your resume.

And remember—everyone in DevOps was a beginner once. The senior engineer who seems to know everything? They learned one thing at a time, just like you’re about to do.

Good luck. You got this.

Internal Resources

DevOps Learning Guides

• DevOps Career Roadmap for Engineering Students (2026)
• DevOps Engineer vs Cloud Engineer: 7 Essential Differences (Career Guide 2026)
• Top DevOps Tools Every Engineer Must Learn in 2026

External Resources

Learning Platforms

Linux Academy / A Cloud Guru – Comprehensive courses for AWS, Azure, Linux, and DevOps practices. Hands-on labs included.

KodeKloud – Excellent for Kubernetes, Docker, and DevOps tools. Very practical, scenario-based learning.

Udemy DevOps Courses – Look for highly-rated courses by Mumshad Mannambeth and Stephane Maarek.

freeCodeCamp YouTube – Free full-length courses on AWS, Docker, Kubernetes, and more.

---

Kedar Salunkhe  

Senior DevOps Engineer with seven years of experience building and scaling infrastructure at companies ranging from Indian  startups, MNC’s to Fortune 500 Product Based enterprises.