The problem: A server is run by IT. The application on it is run by a project team. A security scan finds a weakness, and it is not clear who should fix it. IT says, “The app depends on it, ask the project.” The project says, “The server is IT’s job.” Nobody patches it.
Words used here: a patch is a small update that closes a known weakness. A stack is the layers a system is built from, from the machine at the bottom to the app on top. A vulnerability is a weakness that an attacker could use.
Think of a leak in the wall between two flats
Water comes through the wall between two flats. The family in Flat A says, “It is the wall, not our flat.” The family in Flat B says the same. Both are right: the wall belongs to the building, and the building has no manager. Each family waits. The stain grows.
What it looks like at work
A scan finds an old piece of software on a shared server. IT says the app needs that old version, and an update might break it, so the project must test and approve. The project says it only builds the app, and the server is IT’s to look after. The ticket goes back and forth for three months. The weakness is public, and attackers know it.
- 11. Scan finds itA weakness on a shared server
- 22. IT says“The app needs it. Ask the team.”
- 33. Project says“The server is IT’s job.”
- 44. WaitingEach waits for the other
- 55. ResultOpen for months, no patch
Both sides are half right. IT is right that it cannot update something that may break a live app without the project’s testing. The project is right that it does not run the server, and cannot patch the base software on its own. What is missing is one name for the gap between them, and an agreed way to test and patch together.
You will notice it when:
- The same finding is reopened scan after scan.
- The ticket moves between teams and nobody keeps it.
- Both teams say “it is their part”.
- Nobody can say who owns the old software the app uses.
- Fixes only happen after an audit or an incident.
What exactly needs fixing
The first fix is not the patch. It is naming who owns each layer, and who owns the space in between. This card shows the whole problem on one page:
A known weakness is not patched, because IT and the project each think it is the other’s.
The shared server and the app that runs on it, between two teams.
An attacker uses a weakness that is already known and already public.
- Break-in
- Long exposure
- Repeat findings
- Blame game
- 11. Name the layers
- 22. One owner each
- 33. Test, then patch
Who fixes it: IT head and project lead
By when: owners named in 1 week
A blank copy of this card is in the Tools section.
Why it happens
- Systems are built in layers. And each layer has its own team.
- Nobody owns the joins. The old software the app needs sits between two teams.
- Patching feels risky. An update can break the app, so everyone waits.
- There is no test environment, or no time to use it. So nobody can prove the patch is safe.
- Tickets go to the team that found the work, not the one that can do it. So they bounce.
- No agreed time limit. A finding can sit for months with nobody late.
What happens if you ignore it
The weakness stays open, and it is a known one.
- An attacker uses a weakness that is already public.
- The same finding appears in every scan and every audit.
- The longer it waits, the more the app depends on the old software, and the harder it is to change.
- IT and the project team lose trust in each other.
At a glance
| Question | Answer |
|---|---|
| How likely is it to hurt us? | Quite likely. Known, public weaknesses are the first thing attackers try. |
| Worst case? | A break-in through a weakness that was known for months. |
| What does it cost? | A clean-up, an audit finding, and lost customer trust. |
| What if we wait? | The app depends on the old part even more, and the fix costs more. |
| What does the fix cost? | One meeting to name owners, plus a test slot. |
How to fix it, step by step
Name the layers, name the owners, and agree how to test and patch together.
- Draw the stack on one page. From the server at the bottom to the app at the top. Four or five layers is enough.
- Put one owner on each layer. One name, not a team. IT usually owns the server and base software. The project owns the code and what it depends on.
- Name an owner for the gap. The old software the app needs: who decides if it can be updated? Usually the project lead, with IT doing the work.
- Open one ticket, not two. One ticket, one owner, one due date. Others can be added as helpers.
- Test in a copy first. Make a copy of the server and the app. Apply the patch there. If it works, apply it to the live one.
- If it cannot be patched, add protection. Limit who can reach it, and watch it. Write it down as a known exception with a review date.
- Agree time limits by risk. For example: critical in days, high in weeks. Set your own.
- Review the stack once a quarter. Look for layers and joins that have no owner.
The picture shows the idea. Every layer has one owner, and the gap between layers gets a name too.
Who to bring in: The head of IT or the server owner, the project or product lead, the lead developer, security, and whoever runs testing.
Tools and templates
Who owns what (example)
| Layer | Examples | Owner |
|---|---|---|
| Hardware and virtual machine | The server itself | IT |
| Operating system | The base system and its updates | IT |
| Base software | Web server, database software | IT, with project approval to change versions |
| Libraries the app needs | Code the app depends on | Project team |
| The app | The code we wrote | Project team |
| The gap | Old software the app needs | One named person, set at the start |
Blank finding card
| Field | Write here |
|---|---|
| What is broken | One line, in plain words |
| Where it is | The system, team, or process |
| What could go wrong | In one sentence |
| What it costs us | Money, time, a leak, lost trust |
| The fix | The exact action |
| Who fixes it | One name or one team |
| By when | A date, not “soon” |
Email to IT and the project lead
Subject: One owner for the old software on the shared server
Hi [name] and [name]. The scan found an old piece of software on [server] that has been open for [time]. It sits between the server and the app, and I think each of you believes the other owns it. Could we meet for 20 minutes to agree one owner, a test slot, and a date? I will bring the one-page layer list.
Field tip
Do not ask, “Whose fault is it?” Ask, “Who owns the old software between the server and the app, and when can we test the patch?”
Words used in this chapter
- Patch: a small update that closes a known weakness.
- Stack: the layers a system is built from, from the machine to the app.
- Vulnerability: a weakness that an attacker could use.
- Test copy: a copy of the system used to try a change safely.
- Known exception: an agreed, written reason why a fix has not been done yet, with a review date.