Role Boundaries: Where There's No Job Description, Everyone Does Everything

I once joined a company as a backend developer. The first month, I wrote code. The second month, the words “just take a look at it” handed me responsibility for the server — I was doing the deploys anyway, so it made sense. By the fourth month I was fixing the office internet when it dropped; after all, I was the one who “knew computers.” By the seventh month I was debugging a formula in an Excel export from the accounting team’s software, because I happened to be the only technical person standing there that day.

Not one of those steps was absurd on its own. Each had a reasonable justification, and I found each of them reasonable too. What was absurd was the sum: a year in, my title was still backend developer, but half my time went to work that had nothing to do with my job description. And nobody had acted in bad faith toward me.

In the first post of this series I argued that what separates company types isn’t size, but where decisions get made and how much of the reasoning gets written down. Role boundaries are the point on that “written down” axis where it hurts most. This post is about how far that one sentence — “just take a look at it” — travels, and where you stop it.

The owner-run company: blurry roles

In an owner-run company, the job description is usually an ad; it expires the day you walk in. There’s a good side to that: nobody tells you “that’s not your job,” so the surface you’re allowed to touch is enormous. The fastest learning stretches of my career happened in places like this.

The bad side is that the line between flexibility and exploitation becomes invisible. You can only draw that line if there’s a boundary to draw it against — no boundary, no line. And where there’s no boundary, this mechanism runs:

The capable person gets pulled into every gap, and the reward for closing one is another gap. The punishment for good work is more work.

The insidious part is that nobody is acting in bad faith. The owner isn’t trying to exploit you; he’s handing the problem in front of him to the person who can solve it fastest. Your manager isn’t trying to burn you out; she’s trying to hit the target she was given. And you don’t say no, because you can do it and doing it feels good. Everyone behaves rationally, and the outcome is irrational. That’s how the system works; looking for a villain is a waste of time.

The corporate: sharp roles

In a corporate the opposite holds. There is a job description, it’s written down, and your performance review looks at it. That protects you from arbitrary load, and the protection is real; don’t dismiss it. “That’s not my job” is a legitimate right there.

The same sentence, in the same place, is also a disease. You have to be able to tell them apart:

“That’s not my job”	Legitimate right	Disease
When	The work has an owner, and it belongs to them	The work has no owner, and nobody steps up
Result	The load lands where it belongs	The work dies between two teams
Speaker’s intent	Protecting a boundary	Dodging responsibility

A job description protects you from arbitrary load; that exact same job description also leaves the work sitting between two teams with nobody to claim it. A corporate’s most expensive work dies in those gaps — the integrations nobody owns, the data flows both teams assume belong to “the other one,” the debt nobody touches because it was never written into an OKR.

So in both types the problem comes from the same place: the role gap. In an owner-run company, the gap swallows you. In a corporate, the gap swallows the work.

A role gap is an organisational fault

Let me leave a definition here; I’ll be using it for the rest of the series.

A role gap is work that has to be done but appears in no role’s definition. The moment an individual closes it, it becomes invisible — and an invisible fault never gets fixed.

This is the trap senior engineers fall into most often. You see the gap, it bothers you, and you go close it. You saved the company — and with the same motion, you hid the fault. Your manager no longer knows the work exists, because the work is getting done. In the next budget cycle no headcount is opened for it, because the need isn’t visible. And when you leave, nobody is even aware the work existed.

In the post on seniority I argued that seniority comes from responsibility, not from a title. Here’s the subtlety: taking responsibility doesn’t mean closing things quietly. The right move has two parts:

1. Close the gap. The work needs doing; holding the company hostage helps nobody.
2. Make the closing visible. “I did this, but it isn’t anyone’s job. It needs an owner.”

Without the second sentence, the first one isn’t a sacrifice — it’s a cover-up. And you’re usually the one who pays for it.

None of this means rejecting every form of role expansion. Deliberate expansion — widening your reach on purpose, the way you do in a T-shaped career — is valuable. The difference: you choose the horizontal bar of the T, whereas the gap is something the company hands you. One is an investment, the other is a collection.

Three lines of clarity

So what should you do? Don’t build a RACI matrix and manufacture bureaucracy; in a small team that matrix goes in the bin at the first crisis. Instead, write three lines for every critical piece of work:

• Decider: who says yes or no?
• Doer: whose calendar hours actually go into this?
• Informed: who blows up the work if they’re left out of the loop?

Three lines. A Slack message, a wiki page, a README, even an email will do. The format doesn’t matter; being written matters.

Because a verbal boundary is not a boundary. It gets forgotten, denied, turned into “that’s not what I said.” You don’t need to hit bad faith to experience this — well-meaning people also remember a hallway conversation from six months ago differently. Writing exists not to replace memory, but because you know memory isn’t neutral.

Those three lines have a cost and a limit, and I’ll name both. The cost: the moment you write them down, the argument starts. Verbal ambiguity keeps everyone comfortable; written clarity makes someone uncomfortable, because now it’s black and white that a piece of work has no owner. The limit: three lines don’t conjure a headcount that doesn’t exist. At most, they make its absence visible. Sometimes you do this and nothing changes for six months — but at least, six months on, the argument has moved from “why didn’t you do it?” to “who is going to do this?” Those are not the same argument.

Question: Isn’t drawing a role boundary just a way of ducking work? Answer: No — the opposite. The person who draws a boundary is, in the same motion, committing to what they will do; a boundary is the edge of a promise, not a refusal. The real dodge is leaving the boundary vague and never being clearly accountable for anything. Someone who says “I’ll take a look” to everything never has to answer for anything.

Three desks

From the senior engineer’s desk. Your job is to get the boundary written down. But tone is decisive here: the difference between “I won’t do it” and “I’ll do it — now, who’s going to own this?” changes the trajectory of your career. The first is a wall, the second is a question — and companies punish walls, while questions they usually have to answer. Your constraint stings: you pay the cost of saying no, and the company collects the benefit. Draw a boundary and you may get labelled “not a team player”; fail to draw one and, when you burn out, nobody comes to apologise.

From the manager’s desk. There’s a gap in front of you, and someone at hand who can close it. Giving it to that person is the easiest, most efficient, and most corrosive option. In the short term every metric proves you right: the work ships, the quality is good, nobody complains. Then one day that person appears at your door with a resignation letter, and in that moment — only in that moment — you realise how many months you’ve been burning them. Your constraint is real: you have nobody else. But you set the rate at which you burn that person, and the warning signs arrive long before the resignation; you don’t see them because you aren’t looking.

From the owner’s desk. You can’t see that by handing every gap to the same person, you’ve turned them into a single point of failure. What you see is an employee; but when that person leaves, what you lose isn’t an employee, it’s a department — and the department you lost doesn’t even have a name, because it was never founded. Your constraint is real too: headcount cost isn’t an abstract debate. “Let’s hire one more person” isn’t a sentence for you, it’s a year-long commitment, and you’re the only one watching the cash flow. But factor this in as well: the cost of a single point of failure isn’t cheaper than the cost of that headcount. It’s just deferred.

Closing

A role boundary isn’t an instrument for ducking work. It’s an instrument for making the owner of the work obvious.

You don’t have to do every piece of work you’re capable of doing. But don’t accept that the work you don’t do simply sits there abandoned either: close it, then say so out loud, so that you don’t have to be the one closing it next time.

A verbal boundary is not a boundary. Write it down.