When the demand to learn a new tool overlaps with work that must be finished today, it can be difficult to decide which one to handle first. Junior DevOps engineers in particular may have many unfamiliar procedures, which can keep expanding the scope of what they need to learn. However, the more time they spend trying to learn the names of every tool, the harder it becomes to set aside time for actual work.
When work and learning compete for attention, it is better to select the minimum knowledge required for the current assignment and apply it immediately than to plan a large block of separate study time. Having limited experience and many tasks to complete is a natural part of onboarding. It does not mean that every piece of knowledge must be absorbed at once.
Prioritization conflicts cause more problems than a lack of time
A structural cause is that learning the tools used by the company is treated as a second task separate from the assigned work. This creates pressure to find study time after the work is finished, and even when time opens up, engineers must decide again which tools they need.
The solution is to learn the tools required to complete the current assignment. Reading an overview of a tool is not the end of understanding. Engineers need to connect the commands, settings, logs, change procedures, and verification methods they use in the assignment with their actual work so that the knowledge stays with them.
For assignments where operational stability is at risk, a verified procedure comes before incomplete learning. If a deadline is at immediate risk or a task could affect service operations, engineers should follow the existing team procedures and avoid applying newly learned features without approval. If a tool is used for repetitive, routine work, engineers can begin learning it through small changes.
Select tools based on the current assignment
Priority can be determined with a few questions. Can the assignment be completed without using this tool now? Is it difficult to reverse if a change goes wrong? Will the same knowledge be needed for future assignments? If the first two answers are yes, the tool should receive a higher learning priority. If the third answer is also yes, it can become a repeatable shared procedure. Tools that have not entered the work yet can remain on the list for later.
In practice, checking the Git change status can help narrow the scope of the current work.
git status
git diff --stat
git diff
These commands provide a starting point for identifying which files have changed. Trying to review every modification at once, including changes unrelated to the current assignment, will expand the scope again. Reviewing only the files and changes directly connected to the assignment helps protect time for learning.
Close short practice sessions with real verification
When learning a tool, engineers should verify one minimum function in a safe environment. With Kubernetes, for example, they can begin with client-side verification before connecting to a production cluster.
kubectl get pods --dry-run=client -o yaml
This command only teaches how the client interprets a manifest and does not make changes to an actual cluster. Engineers should use a sandbox or personal practice environment approved by their team, and request credentials and change permissions only when necessary. Using the company’s practice environment like a personal experiment consumes the team’s operational capacity.
After practicing, engineers should record where the commands they learned fit into the actual assignment. A useful record states which problem they solved, what they ran, and how the result differed from what they expected. This prevents them from tracing the same error from the beginning the next time it occurs. Records are better kept in the places the team actually uses, such as work tickets, pull request descriptions, or the team wiki, rather than only in personal notes.
Common failures start with expanding the scope
Starting every tool at once only increases the number of things to learn. A feature learned early may differ from the team standard and lead engineers to keep an individual approach. Before applying a new tool or setting, engineers should check the existing runbooks, pipeline configurations, and change history for infrastructure code. If differences appear, they should first follow the team owner’s guidance and verification procedure.
The article started with a question posted on an r/devops post. Its main point is the need for clear selection criteria. Adjusting the intensity of learning according to the tools needed for the current assignment, the cost of recovery after a failure, and how often the work recurs can reduce conflicts between work and learning.
Try these steps now
- List the assigned tasks and their tools together, then mark the tasks that must be completed today.
- Assess each tool in order of current need, risk of changes, and likelihood of repeat use, then choose one learning target.
- Run one minimum function needed for the assignment with the selected tool in a safe environment and record the result.
- Apply the learned command or setting to the actual assignment, then check whether it produces the same result as the existing team procedure.
- Record what you learned today, any remaining questions, and the point for the next iteration in a work ticket or the team wiki.
Source
This article was written after reviewing the following source: r/devops, How to learn while also completing tasks?

Leave a Reply