All articles

KajoData / Career & business

What you need in IT: working through a blocker

I show how to move from frustration to a small, clearly described problem and a practical next step.

Kajo RudzińskiPublished Updated 13 min read

An interrupted mechanical data pipeline with one component examined under a magnifying lens.

You finish a lesson, everything works, and the instructor moves on. Then you open your own file and half the process behaves differently. A column disappears, a total grows after a join, or the program displays an unfamiliar message. This is where learning stops resembling watching somebody else ride a bicycle. You need to find your own balance and work out which small action will help you move again.

When I discuss frustration tolerance in IT, I mean continuing to investigate a problem when the answer is not immediately available. I do not assume that people should absorb unlimited pressure or hide a blocker for hours. I want to turn “nothing works” into a small question that can be addressed. Here is the approach I would use for a report whose result changes unexpectedly.

Give the blocker a description

First, what should have happened, and what happened instead? “The report is broken” identifies neither the location nor the expected outcome. “The sales total increased after I added categories, although I added no orders” gives me something to investigate. I can compare the state before and after that operation instead of searching every setting in the application. Describing the difference is already a useful part of diagnosis.

Separate an observation from an explanation. The increased total is an observation. “The software calculates incorrectly” is a very broad hypothesis. Another hypothesis is that one order found several matching rows in the category lookup. A third is that the two views have different filters. I write these as possibilities to examine. I do not want the first guessed explanation to control an entire afternoon of unrelated changes.

It also helps to establish the boundary. Does the issue affect every month or only one? Is the difference present in the source or only in the chart? Does it happen every time or after a particular update? Each answer reduces the search area. If I do not know something yet, I record that gap. An explicit unknown is more useful than an explanation invented simply to make the situation feel less uncertain.

Reduce the task to one case

Consider synthetic data with two orders: A worth 10 and B worth 20. After matching categories, A appears twice and B once. I can follow every record without scrolling through a large dataset. This lets me ask why A has two matches. I do not yet need to rebuild the entire report or replace the data model. I need to understand the operation that changed the result.

The Stack Overflow guidance on a minimal reproducible example calls for a small, complete case that still reproduces the issue. I apply a similar principle to data: retain the necessary columns, a few records and the operation after which the result changes. Remove unrelated elements. If the issue disappears during this reduction, inspect the last part you removed rather than assuming the problem has somehow solved itself.

The reduced case must preserve the important conditions. If repeated keys cause the issue, removing every repetition also removes the cause. If missing values matter, an example containing only complete records cannot settle the question. Reduce the dataset deliberately. The goal is a readable mechanism, not the smallest possible number of rows regardless of whether they still represent the original situation. A slightly larger useful example beats a tiny irrelevant one.

Match one hypothesis to one useful check

For the multiple-match hypothesis, I ask whether the category code occurs once in the lookup. For the filter hypothesis, I compare the same period and store. Each check should distinguish one possibility from another. Changing several settings at once may accidentally improve the result, but it makes the cause harder to identify. That leaves the next person with a repair they cannot confidently explain or maintain when the input changes.

Before making changes, preserve a way to compare with the earlier state. Depending on the tool, that could mean a versioned file, a separate working copy or a saved query. Do not overwrite the only source dataset just to examine an idea quickly. Experiments should be reversible and stay within your permissions. The presence of a button is not sufficient justification for pressing it in a production environment.

After the check, record the conclusion in one sentence: “Code X appears twice in the lookup, so each matching order row appears twice after the join.” That remains useful even if I cannot decide which lookup entry should be removed. I have a technical explanation and a separate question about the data. There is real progress, although the report still needs a decision from the source owner before the repair can be completed.

Read the message before searching for a fix

If the tool reports an error, capture the full message, operation and location. The Python errors and exceptions tutorial distinguishes syntax errors from exceptions during execution; the final part of an exception message gives its type and details. That offers a starting point for further reading. The fact that an editor has turned something red does not itself explain what needs to change.

Check the software or library version as well. Advice from several years ago may describe a different behaviour, parameter name or feature that your environment does not have. Add the tool and version to the relevant part of the message when searching. Do not publish passwords, tokens or customer data. The essential context can usually be demonstrated with a small synthetic example without exposing the actual records you work with.

Compare any suggested solution with your own case. Does the author have the same input type? Does the failure occur at the same stage? Does the proposed change address the cause or merely suppress the warning? I would not change missing-value handling solely to make a process stop complaining. A quiet report with the wrong answer can be harder to detect than a visible failure, especially when somebody trusts the refreshed output automatically.

Asking for help is a task of its own

A useful request lets the other person begin with the substance. I might write: “The total grows after I add categories. With two orders, I can see A getting two matches. I checked the period and filters. I need to know whether the lookup should contain both entries or whether one is historical.” The reader can see what is established and which decision is missing without reconstructing my entire day.

I would not wait until the blocker threatens delivery before mentioning it. Agree a consultation point with the team according to urgency and risk. A learning exercise leaves more room for independent exploration. A report needed in an hour calls for earlier communication. There is no universal magic number of minutes after which everybody should always request help. The consequences of delay matter as much as the time already spent investigating.

Choose help appropriate to the obstacle. Consult documentation for a function’s behaviour. Ask a technical colleague about the mechanism. Ask the data owner what a record means and the report user which definition they need. Trying to answer all these questions through code can become frustrating very quickly. A business rule that has never been agreed will not necessarily emerge from another hour of editing an otherwise valid query.

A complex circuit and a small isolated section on an inspection bench

A deadline changes the communication

If I do not know how long a fix will take, I do not pretend to know to the nearest quarter-hour. I state what is known, what remains unknown and when I will provide another update. “I have narrowed this to the lookup and am waiting for the rule to be confirmed; by the end of the day I will share the findings and options” is a commitment I can control. The final resolution may depend on somebody else.

For an urgent request, ask which reduced scope would still help. Perhaps the recipient can use the previous correct period with a visible date. Perhaps they need only one confirmed figure. Any limitation must be visible and the choice agreed. Sending an uncertain report without explanation does not remove the blocker. It transfers it to someone less able to recognise the problem and potentially more likely to make a decision from it.

Describe delay without turning it into a verdict on yourself. “I have not identified the source of the difference yet” communicates a task state. “I am not suited to analysis” does not help settle the report. You do not have to enjoy every error. It is enough to separate the condition of one problem from an assessment of your entire ability and then arrange the next useful conversation or investigation.

Decide what counts as a sufficient solution

Repairing the small case starts the verification process. Return to the complete dataset and check expected totals, missing values and scope. If a change removes multiplication by discarding records, understand which records were discarded and why. A chart rendering successfully does not establish that the analysis still means the same thing. The completion condition should cover the result and the explanation that makes that result trustworthy to another person.

Separate the repair needed now from later improvements. A clearer field name can wait when an incorrect total is about to be published. However, an important limitation should not remain solely in your memory. Record it beside the report or in the team’s documentation. The next person needs to know the rule behind the current solution, particularly if refreshing the data can introduce the same kind of exception again.

Not every investigation ends with immediate implementation. Sometimes the finding is that the data cannot answer the question or that a required permission is missing. Name the dependency: what is needed, who can resolve it and which limited scope remains possible. That is a valid outcome. Hours spent trying to code around an unresolved definition may contribute less than a clear explanation of why a decision is required before work can continue.

Practise differently after a course

Courses provide an ordered route; your own project adds uncertainty. Practise small departures from the lesson: a renamed column, missing value, repeated identifier or extra input file. Predict what should change, then examine the result in your own environment. The purpose is to understand the solution’s conditions rather than collect increasingly unusual errors. One thoughtful variation can reveal more than another hour spent passively watching familiar steps performed correctly.

After a consultation, reconstruct the investigation yourself. Why did we inspect that key? What ruled out the filter hypothesis? Where does the documentation settle the behaviour? If you save only the final fragment of the solution, the next similar failure may leave you equally dependent on help. A short explanation of the mechanism and the conditions for using it is more transferable than a collection of isolated tricks.

Choose tasks suitable for your current stage. A complete company reporting system may make a poor first project. One table, one join and one reconciliation let you see the whole process. Add difficulty afterwards. For broader direction, see my data analyst learning plan. A useful plan makes space for problems the instructor did not anticipate, rather than treating every departure from the lesson as evidence that learning has gone wrong.

Separate technical difficulty from overload

I would not interpret every obstacle as a need for greater persistence. Missing access, conflicting priorities, impossible deadlines and constant interruptions can require organisational changes. The HSE standard on work demands includes workload and matching demands to agreed hours and people’s capabilities. I refer to it as an organisational guide, not as a diagnosis of a particular person’s condition or a substitute for understanding their actual circumstances.

If problems recur, discuss the conditions for resolving them: documentation, access to a mentor, time to learn the system and the queue of urgent requests. Independence is easier to develop when you know when and whom to ask. Expecting a beginner to guess every unwritten rule does not create a useful process. I discuss workload conversations further in the article about having too much work.

You can also plan a deliberate stopping point. Record the current state, next hypothesis and first action for your return. That prevents having to reconstruct every dead end. I am not promising that a walk will fix any error. I simply prefer returning to a clearly described task over continuing a sequence of random changes because I have already spent a long time at the keyboard and feel obliged to keep going.

Exercise: write a blocker message

Take a recent learning or project problem. Record the expected result, actual result and smallest case showing the difference. Add one hypothesis you checked and a question for someone who could help. Avoid “I tried everything”. Name a particular attempt and its outcome. If you cannot describe the issue yet, compare one record before and after the change. Start with something observable that another person could understand without access to your thoughts.

Read the message from the recipient’s position. Is the tool clear? Do they need a version and data type? Are you asking for a technical explanation, a definition decision or access? Remove irrelevant details and retain important limits. A good question need not be long, but it should suggest the next sensible move. Making the request understandable is part of the work, especially when the recipient is unfamiliar with the report.

Finally, write the completion condition. In our example, it is an unambiguous category matching rule and a report whose total reconciles with a correctly defined source. That gives the next stage a concrete goal. I understand frustration tolerance as the ability to return to such a goal with help, documentation and reasonable boundaries. You do not need to like blockers in order to learn how to work through them constructively.

When the small case works but the full report does not

This is useful information, however irritating it feels. Record the differences in conditions. The small example might contain one month while the report spans years. It might omit missing keys or use a different lookup file. Before adding another repair, find a difference capable of explaining the behaviour. A precise description of both cases leaves less room for random changes and gives the next investigation a clearer purpose.

Reduce the full report from the other direction. Limit it to one period and then one category while preserving the operation that changes the result. If the issue affects only one group, inspect that group separately. If it depends on combining groups, that is informative too. One correct case does not establish correctness for every possible input, just as one failing case does not establish that the entire application behaves incorrectly.

For intermittent differences, record the time and input state. Had the source refreshed? Were the compared files created on the same day? Did someone update the lookup between attempts? A report drawing on several sources may appear contradictory because it combines different snapshots. Those questions belong to the data supply process. Changing a formula that correctly processes inconsistent inputs may hide the real cause while making later reconciliation more difficult.

Know when to pass the issue onward. If it requires administrator access, a source change or knowledge of an undocumented integration, provide the evidence and name the dependency. Include conditions in which the failure occurs and those in which it does not. That allows the next person to continue. Independent work does not mean performing every step alone when responsibilities and permissions are deliberately divided across a team.

Key takeaways

What should I do when I get stuck on an IT task?

Describe the expected and actual results, reduce the issue to a small case and choose one hypothesis to check. Communicate a blocker when it affects delivery.

When should I ask for help?

Agree a consultation point with your team based on urgency and risk. Explain the issue, what you checked and which information or decision is missing.

Does frustration tolerance mean accepting overload?

Separate technical difficulty from missing access, conflicting priorities and excessive workload. Those conditions may require changes to how work is organised.

AI was used in an automated way while working on this article. If you want to learn how to do it too, check out this project.

Kajo Rudziński

Newsletter KajoData

Let’s keep in touch.

I write about data analysis, learning and changing careers. My newsletter and the sign-up form are in Polish. If that works for you, I’d be glad to see you there.