We all have goals. Some are small and easy to achieve, but many are large and complex. A big goal can be intimidating enough, but trying to visualize all the different steps is its own challenge. Our phones' GPS shows us one solution to this problem. It lists each of the individual steps to get from A to B while also showing your total progress (i.e. time and distance remaining).

Like how our GPS lists each step in the process, having a game plan is key. For example, I want to be a web developer, but trying to track everything needed to qualify for a development role is intimidating. It’s hard to know where to start when you're looking at a long list of qualifications and skills.

Fortunately, I found a boot camp that broke down the web technology stack (front-end, back-end, full-stack) in a roadmap for the course. The instructors provided a plan for each piece and how that piece related to the larger whole.

Download Now: Free HTML & CSS Hacks

The field of web development is not nearly as expansive as the background knowledge that’s needed to work across the DevOps lifecycle. This makes the DevOps roadmap even more critical to ensure you understand the job requirements and stay on track to landing a DevOps engineer role.

So, how do you become a DevOps engineer? Let's start by looking at the DevOps career roadmap.

The DevOps Roadmap

Before we continue, let's take a moment to examine the DevOps roadmap below. Shout out to Kamran Ahmed for creating this excellent resource and making it available through his GitHub repository.

DevOps roadmap breakdown

You'll notice that the DevOps roadmap covers a lot of concepts within software development. That's because DevOps covers the entire software creation and maintenance process from development to operations, which span the entire technology stack. This roadmap contains lots of great details, but as we plot our course together, we'll focus on the main pathway and discuss each step.

Let's break down each of the main steps in this roadmap.

1. Learn programming languages.

Though a DevOps engineer is not typically writing source code, they will be integrating databases, debugging code from the development team, and automating processes. Automation is a critical part of what gives the DevOps lifecycle its speed, and a DevOps engineer will play a primary role in implementing a DevOps automation strategy.

Additionally, a DevOps engineer should have a working knowledge of the languages their team is using to help them understand existing code, review new code, and assist with debugging.

Programming languages to learn include:

  • Go (recommended)
  • Ruby
  • Python
  • Node.js

2. Study operating systems.

Operating systems (OSs) are a crucial piece of the technology stack that a DevOps team needs to function. OSs not only power the local machines that the team uses to communicate and complete their tasks, but OSs also run the servers that host the team's deployed applications.

As such, you need to learn the command line terminal so that you are not reliant on the graphic user interface (GUI) to configure your servers. Command line simplifies tasks that would require multiple clicks in a GUI, and some commands are only executable through the terminal. Every OS is different, so learning more than one is advisable.

OSs to learn include:

  • Linux (recommended)
  • Unix
  • Windows

You'll also want to learn the larger strategies and rules that govern how OSs are built and run. As a DevOps engineer, technical knowledge and conceptual knowledge are equally important.

OS concepts to learn include:

  • Process Management
  • Sockets
  • Threads and Concurrency

3. Review networking security and protocols.

Any web-based application will use protocols to transfer and receive information from the user. This means that it is also necessary to understand how protocols support different request types.

Just as important, you need to know the risks of these transfer methods and how to secure them to prevent bad actors from intercepting your data or infiltrating your application. Cybersecurity is a critical skill no matter your role within the DevOps lifecycle.

Networking protocols to learn include:

  • HTTP
  • SSL
  • SSH

4. Understand Infrastructure as Code.

Infrastructure as Code (IaC) is a practice for streamlining the provisioning of infrastructure to support your application deployment. Networks, servers, and other infrastructure are configured and managed using template files to create an environment with your application's exact requirements. IaC allows you to automate this process for faster deployments and updates.

IaC strategies to learn include:

  • Containers
  • Configuration Management
  • Container Orchestration
  • Infrastructure Provisioning

5. Adopt Continuous Integration/Continuous Deployment tools.

Continuous Integration and Continuous Deployment (CI/CD) is a central principle that DevOps is founded on: the integration of development and operations as well as constant iterations. To achieve this philosophy, most DevOps teams turn to tools built to support the DevOps lifecycle. CI/CD tools support multiple phases of the pipeline and automate processes and handoffs to free up team members.

CI/CD tools to learn include:

  • GitHub
  • GitLab
  • Bamboo
  • Jenkins

6. Invest in application and infrastructure monitoring.

Monitoring is the practice of watching for signs of trouble in your application and its underlying infrastructure so that your operations team can fix issues before they become outages. Naturally, this practice breaks down into two parts.

Application Monitoring

Internal issues with your application can manifest in multiple ways, so it's best to monitor multiple metrics.

For example, a lower than normal conversion rate on a form may be a sign that the form itself is malfunctioning when users try to sign up. Ideally, your monitoring tools would flag errors generated within the code when the signup request is sent as well as the conversion rate so you have multiple ways to identify issues.

Application monitoring tools to learn include:

  • Prometheus (recommended)
  • Nagios
  • Datadog

Infrastructure Monitoring

It's natural to assume that the issue must be stemming from the application itself, but often problems within your application's supporting infrastructure can have an equal impact — if not greater.

For example, issues with your web application's cloud hosting can result in outages for your users when they attempt to access it. Monitoring tools analyze errors generated within your application's stack as well as performance metrics to flag errors early. The sooner your team can respond, the less impact these issues will have on your user experience.

Infrastructure monitoring tools to learn include:

  • New Relic (recommended)
  • Jaeger
  • AppDynamics

7. Study cloud providers.

Most — if not all — modern applications are hosted in the cloud. Cloud services provide many benefits, including the cost savings and scalability that result when you no longer need to host your own servers for your application. Naturally, it's important to understand the different cloud services available and their unique costs and benefits so you can select the best hosting for your finished applications.

Cloud providers to learn include:

  • AWS (recommended)
  • Azure
  • Google Cloud
  • Heroku

8. Learn cloud design patterns.

Cloud design patterns are the philosophies that produce the scalability, reliability, and security of cloud applications. Just as important as understanding cloud providers, you should also understand these patterns.

There are many lessons to learn from cloud best practices (e.g. high latency) that you can apply to your applications hosted in the cloud and to your development approach before deployment. For example, backing up your source code in a cloud-enabled repository so you don't lose access if your local storage is unavailable.

Cloud design patterns to learn include:

  • Availability
  • Data Management
  • Design and Implementation

Everything we have covered does not represent the full knowledge you will need to be an effective DevOps engineer, but the core knowledge you should have before focusing on the finer details. You will find learning is much easier once you have this background to inform your understanding.

To close this post out, let's run through some key takeaways based on the different steps of the DevOps roadmap.

Takeaways From the DevOps Roadmap

1. Leverage any prior technical experience that you have.

Returning to the web development boot camp example, I was lucky enough to have already learned HTML, CSS, and JavaScript. This background helped me appreciate the other technologies covered. I also had worked on a corporate website where mobile responsiveness was a challenge, so that encouraged me to pay greater attention to that aspect of our boot camp.

A DevOps engineer will cover the full software development lifecycle, so any experience they have in this field will enable them to better coordinate the different DevOps phases and collaborate with their teammates. It will also help them feel more confident in their recommendations as they work to optimize the pipeline.

2. Prioritize concepts, not just tools.

Having learned JavaScript, I had the advantage of understanding not only the syntax, but some of the principles behind programming, which served me well in the boot camp versus those who had never coded before.

Similarly, technical knowledge is important, but if you don't understand the reasons why you are using a particular approach, then you won't be able to vocalize them to the rest of the team. A DevOps engineer is an advocate for the DevOps method on top of everything else they do within the team, so understanding the concepts behind the technology is key.

3. Be a generalist, not a specialist.

Since DevOps engineers touch the whole DevOps lifecycle, it's better to know a little of everything than be strong in only a few areas. The individual contributors on your team are meant to specialize in their specific areas (development, networking, monitoring, etc.). You are responsible for moving the product between each contributor.

If you do have a good understanding of the full process and want to learn more, then don't limit yourself, either. Those with a passion for learning will excel as a DevOps engineer. Just make sure you're focusing on the larger picture as well.

4. Always look for new learning opportunities.

Technology is always changing. Your organization should also adapt to the latest best practices and advancements to ensure you stay ahead of the curve in the software you deliver. As part of this, a DevOps engineer should always look for the next trend so they can better advise their team on how to incorporate these into their process.

As you have seen, the DevOps roadmap is full of different technologies and concepts for you to explore. If you have the drive and passion for learning, then this roadmap should serve as a valuable guide as you start to build your expertise. Focus on the individual steps and soon you will have the skills you need to start your career as a DevOps engineer.

New Call-to-action

 css introduction

Originally published Nov 22, 2021 7:00:00 AM, updated November 22 2021


Developer Operations