Group DevOps Mentorship
A project-based DevOps mentorship for developers and engineers who want to move beyond tutorials and build practical DevOps skills by working through a real software delivery project.
Overview
Learning DevOps becomes much more concrete when there is a system to build, deploy, operate and improve.
The mentorship is organised as an engineering project in GitLab. Instead of preparing every solution in advance, I provide the project structure, engineering tasks, supporting knowledge and an environment in which you can investigate and build solutions yourself.
You work through GitLab Issues, make implementation decisions, change the project, create Merge Requests, run CI/CD pipelines and review the results with me.
The project gives us a practical context for learning Linux, containers, CI/CD, deployment, infrastructure, monitoring and automation while also developing the engineering habits behind them.
Who It's For
This mentorship is designed primarily for software developers and engineers who understand application development and want to build practical DevOps experience.
It is especially suitable if you already know individual DevOps concepts or tools but want to understand how they come together around a real software delivery process.
Professional DevOps experience is not required. Basic Linux command-line and Git familiarity is recommended, and you should already have some software-development experience.
Most importantly, you should be comfortable working independently between sessions, investigating technical problems, asking questions when you are stuck and receiving detailed feedback on your work.
How It Works
The mentorship takes place around a GitLab engineering project.
The project contains several parts, each with a different purpose:
Wiki - Knowledge
The Wiki contains the knowledge and context behind the engineering work. You use it when you need to understand a concept, prepare for a new topic or find references for further investigation.
Milestones - Learning Stages
Milestones organise the project into larger learning stages such as Linux, networking, containers, CI/CD, deployment and operations.
Issues - Engineering Tasks
Issues are the main learning units. They describe a problem, requirement or engineering situation together with the expected outcome and acceptance criteria.
Some tasks are implementation work. Others may require investigation, debugging or making an engineering decision.
Repository - Your Work
You implement your solutions in the project repository. The project develops as your DevOps knowledge develops.
Merge Requests - Review
Your work is submitted through Merge Requests. We review the implementation, discuss your decisions and consider possible alternatives.
The goal is not only to determine whether something works, but also to understand why you chose a particular solution and what its consequences are.
CI/CD - Technical Feedback
Your changes can run through real CI/CD pipelines. A successful pipeline gives you immediate technical feedback, while a failed pipeline becomes an opportunity to investigate logs, understand the failure and improve the solution.
The Learning Cycle
The basic learning cycle is:
Understand → Issue → Investigate → Build → Merge Request → Pipeline → Review → Improve
You are not expected to know every solution before starting an Issue.
You can use the Wiki, documentation, books, external resources and AI while working. What matters is that you develop the ability to understand the problem, evaluate possible solutions and explain the engineering decisions you make.
My role is to guide that process, review your work, challenge decisions where useful and adapt the next steps as the project develops.
Engineering Progress
Your learning progress is connected to the engineering work in your project.
Instead of measuring progress simply by time spent, the mentorship uses the state of your Milestones and learning Issues to show where you currently are.
For example:
DevOps Engineering Progress - 62%
- Git & Workflow - 100%
- Linux Foundations - 100%
- Networking - 75%
- Containers - 40%
- CI/CD - 0%
Progress is calculated using the learning states defined for the mentorship rather than simply relying on GitLab's default completion percentage.
This gives you a clear view of what you have completed, what you are currently working on and what comes next.
Mentoring Sessions
The GitLab project gives us continuity between mentoring sessions.
You work independently on engineering tasks between sessions. During our sessions, we can review your implementation, investigate problems together, discuss architectural or operational decisions and decide what should come next.
The project is allowed to develop naturally. If your implementation raises an unexpected problem or leads to an interesting alternative, that can become part of the learning process rather than something we need to avoid because a predetermined solution says otherwise.
What You Work With
Depending on the stage of the project, you may work with:
- Linux environments
- Git and GitLab
- containers
- CI/CD pipelines and GitLab Runners
- deployment environments
- infrastructure and automation
- application and system logs
- monitoring
- code quality and security tools
- other engineering tools where they are useful for the project
The focus is not on collecting tools. Tools are introduced when the engineering problem gives us a reason to use them.
One Connected Engineering Environment
The project does not live in separate exercises. Source code, Git, CI/CD, infrastructure, deployment, logs and engineering documentation belong to one connected working environment.
This matters increasingly in AI-assisted engineering. An AI agent becomes much more useful when it can work with the same context as the engineer - code, issues, pipelines, logs, documentation and operational data - rather than receiving isolated snippets from disconnected tools.
The mentorship therefore builds the environment as part of the learning process. AI is not treated as a separate tool or course topic. The engineering foundation is designed so that AI capabilities can be integrated naturally as the project evolves.
Outcomes
By the end of the mentorship, you should have worked through a complete DevOps delivery journey around a real software project rather than a collection of isolated exercises.
You should be able to understand and explain how your project is built, tested, packaged, deployed and operated; troubleshoot common problems; work with CI/CD pipelines and engineering environments; and make technical decisions with a more systematic engineering approach.
You will also have practised an engineering workflow using GitLab: working from Issues, managing your work through Milestones and an Issue Board, implementing changes in a repository, creating Merge Requests, responding to review feedback and investigating pipeline results.
Most importantly, the goal is that you become more confident approaching a DevOps problem that you have not seen before. You should be able to investigate it, use the available information and tools, form your own understanding and work towards a solution.
Your GitLab project also documents the engineering journey you completed and can serve as evidence of your practical experience.
FAQ
The programme is particularly suitable for software developers and engineers because we work with a real application and its delivery lifecycle.
You do not need to be an expert developer, but you should be comfortable reading and working with an existing codebase.
It is a project-based mentorship with structured learning content.
The learning environment is built around a GitLab project. The Wiki provides knowledge and context, Milestones structure the learning journey, and Issues give you engineering problems to work on.
You implement your solutions, create Merge Requests, work with CI/CD pipelines and review your engineering decisions with me.
You receive access to a GitLab project that becomes your engineering workspace during the mentorship.
Your learning work is organised through Milestones and Issues. The repository contains the software you work with, the Wiki provides supporting knowledge, and Merge Requests and CI/CD pipelines become part of the implementation and review process.
As the project develops, new engineering problems and topics are introduced.
You progressively build the delivery and operational environment around a software project.
The work can include Linux, networking, containers, CI/CD, deployment, infrastructure, monitoring, automation, troubleshooting and other topics that become relevant as the project develops.
The exact path can adapt to the project, the group and the engineering problems we encounter.
Your progress is connected to the engineering work you complete.
Milestones represent larger stages of the learning journey, while Issues represent individual engineering tasks. Build2Teach's Engineering Progress uses these states to show what you have completed, what you are currently working on and what comes next.
Progress is not based simply on how much time you spend on the course.
Yes.
AI can be one of the tools you use alongside documentation, books, search, experimentation and discussion.
The important part is that you understand the problem and can evaluate, explain and take responsibility for the solution you implement. The goal is not to complete Issues without assistance; it is to develop your ability to work through engineering problems.
A failed pipeline is part of engineering work and can become part of the learning process.
You first investigate the jobs, logs and changes that may have caused the failure. If you get stuck, we can review your findings together and work through the problem.
The goal is not simply to make the pipeline green, but to understand why it failed and how you arrived at the solution.
Getting stuck is expected.
You should first investigate the problem and document what you have tried, what you observed and what you think may be happening. You can then bring your findings and questions to the group or to a review.
I will help you understand the problem and evaluate possible approaches rather than simply completing the task for you.
The focus is on demonstrable engineering work rather than completing lessons for a certificate.
Your project, Issues, Merge Requests and completed engineering work provide a practical record of what you have worked through during the mentorship.
I review each application to understand your background, goals and whether the programme is a good fit.
If it looks suitable, we discuss the next steps and cohort details before your place is confirmed. Once the enrollment process is complete, you receive access to the engineering learning environment and your GitLab project.
Yes. The mentorship is remote.
You need to be able to attend the agreed live sessions and communicate comfortably in one of the supported languages.
The mentorship can be conducted in English, German or Vietnamese, depending on your preference and the composition of the group.
The language for each cohort will be agreed before the programme starts.
No professional DevOps experience is required.
Basic familiarity with Linux, Git and software development will make it easier to get started. The mentorship is designed to help you develop practical DevOps experience through the project itself.