Job architecture example for IT: weighing roles without a collective agreement (2026)

In most sectors a job architecture starts with a collective agreement as a safety net. In IT services that net does not exist. There is no mandatory collective agreement, so the market sets what a developer earns, and that makes pay transparency harder here, not easier. You cannot point to a table. You have to be able to explain yourself why one role sits higher than another.

This article shows what that looks like. We take a fictional but realistic IT services firm with five roles and build a job architecture around it step by step. For the general explanation of the method you can read the base example using an installation company. Here the focus is the IT-specific question: how do you weigh roles fairly when no collective agreement does it for you?

Why "no collective agreement" makes it harder, not easier

Without an agreement there seems to be more freedom, but that freedom is exactly the problem. The EU pay transparency directive asks you to base pay on objective, gender-neutral factors, and to determine "work of equal value" on four criteria:

• Knowledge and skills (education, experience, technical depth)
• Effort (mental load, focus, complexity)
• Responsibility (for code, systems, clients, people)
• Working conditions (workload, availability, on-call duty)

In a sector where salaries often come out of individual negotiation, pay gaps between people doing comparable work are easy to create. A job architecture is precisely the instrument that makes that gap visible and explainable.

The example: an IT services firm with five roles

Picture a firm of about 60 people: software development, systems management and consulting. Five core roles:

• Service Desk Agent resolves first-line questions and escalates on complexity.
• Software Developer builds and tests features within a team.
• System Administrator safeguards the infrastructure, availability and security.
• Product Owner manages the backlog and steers on the value of the product.
• Engineering Manager holds end responsibility for engineering, budget and people.

Everyone intuitively senses the Engineering Manager sits higher than the service desk. The question is where the developer, the administrator and the product owner sit relative to each other, and whether you can substantiate it when someone asks.

Step 1: weighing the four factors

We give each role a score from 1 (low) to 5 (high) on the four factors.

Role	Knowledge and skills	Effort	Responsibility	Working conditions
Service Desk Agent	2	3	2	2
Software Developer	4	3	3	2
System Administrator	3	3	3	3
Product Owner	4	4	5	2
Engineering Manager	5	4	5	2

Note the system administrator. On knowledge they score lower than the developer, but on working conditions a point higher, because on-call duty and availability outside office hours are part of the job. This is exactly the kind of difference the directive wants you to make explicit, instead of letting it disappear behind "it is all just tech".

Step 2: from weighting to job groups

Add up the scores and you get a ranking. Roles with a comparable total go into the same group, even when the work differs.

Role	Total weight	Job group
Service Desk Agent	9	Group A
System Administrator	12	Group B
Software Developer	12	Group B
Product Owner	15	Group C
Engineering Manager	16	Group D

The developer and the system administrator land on the same total and end up in the same group, while their work differs. That is not a mistake, it is the core of equal value: different work, comparable weight, so comparable pay. Without this step you are left with two separate negotiation outcomes you cannot account for.

Step 3: the salary bands around it

Only now do the amounts come in. Each job group gets a band with a floor and a ceiling. The bands overlap on purpose, so an experienced product owner can earn more than a starting engineering manager without breaking the logic.

Job group	Roles	Salary band (gross per month)
Group A	Service Desk Agent	2,600 to 3,400 euro
Group B	Software Developer, system administrator	3,400 to 4,700 euro
Group C	Product Owner	5,300 to 7,100 euro
Group D	Engineering Manager	6,500 to 8,500 euro

These amounts are an illustrative example, not advice for your firm. Because there is no collective agreement, you substantiate the band level with market sources such as the CBS wage structure survey, WageIndicator and IT salary benchmarks. What matters is the structure: everyone in group B falls within the same band, whether they build or maintain.

What this example shows

1. No collective agreement means more burden of proof, not less. Precisely because the market sets the amounts, you have to be able to explain the relationship between roles.
2. Different work can be of equal value. The developer and the administrator do different work but sit in the same band.
3. The band is your answer to information requests. When a developer asks what comparable colleagues earn, you have a band with a method underneath instead of a loose number.

See this IT example interactively

This whole job architecture is online as a clickable example: the roles, the weighting per role and the salary bands, exactly as above. Take a look, or have your own first role weighed for free with no obligation.

See the IT job architecture  or  weigh your first role for free

Frequently asked questions

Does pay transparency apply without a collective agreement?
Yes. The obligation to substantiate pay on objective, gender-neutral factors applies to every employer, agreement or not. Without one, the burden of proof rests entirely with you.

Where do I get the amounts if there is no table?
From traceable market sources: the CBS wage structure survey, WageIndicator and recognised salary benchmarks. You name them per role so the band is verifiable.

Can I copy the amounts from this example?
No. The amounts above are illustrative and apply to a fictional firm. You take over the method, not the numbers. What a job architecture costs is covered in the general example.