Fichaloto

Blog Security

Technical access is almost always all or nothing

7 min read

You want them to fix this and only this. What you end up handing over is the key to everything, and both sides know it.

Why scoping by module does not work

The idea is intuitive: if the brief is the commercial section, give access to the commercial section. In a user permission model this works perfectly. In code access it almost never does, and it is worth understanding why before trying.

Application modules are not separate boxes. They share the data model, the common functions and the side effects. Touching team management affects planning, time recording and permissions, because all four read the same people table. Access «to teams only» that genuinely prevented breaking anything else would have to prevent touching almost everything.

So what actually happens is full access plus trust. Trust is a legitimate strategy, but it is worth knowing you are using it rather than believing you have scoped something.

The three things that do reduce risk

If technical separation is not viable, risk comes down through three other routes, all of them far cheaper than trying to partition the codebase.

  • Keep them off production. A development environment with anonymised data and its own credentials. This protects the most and gets skipped the most when there is a rush. If the contractor can only work against a separate environment, the worst possible accident is reversible.
  • Someone reviews before it reaches production. No formal process needed: just that deployment is done by someone internal after looking at the change. Code access stops being the control point and deployment becomes it, which is far easier to guard.
  • Every change leaves a trace. Knowing who changed what and when prevents nothing, but it changes the incentive and it lets you reconstruct afterwards. With the repository connected to the work being billed, you also get to see that what was done is what was commissioned.

And the part that is not technical

There is a temptation to solve this entirely with tooling, and it cannot be done. Part of the risk is only covered by contract and process.

The minimum: a confidentiality agreement that explicitly names the personal data they will have access to, a written instruction not to take copies of the database, and an end date for the engagement with revocation attached to it. That last point is the most forgotten and the one that turns reasonable access into permanent access.

And if the contractor will handle personal data belonging to your staff or your clients, you are in processor territory with everything that implies on paper. Not a minor formality: it is the difference between having an incident and having an incident with no documentation.

What nobody has solved well yet

Worth saying plainly: this is an open problem in the industry, not a checkbox missing from some product. Large platforms address it with separate environments and deployment process, not with fine-grained permissions over code, precisely because fine-grained code permissions collide with the real dependencies between modules.

If somebody offers to solve it with a toggle, it is worth asking what happens when module A writes to a table module B reads. The answer tends to be revealing.

Frequently asked questions

Is a limited-permission user enough?

It is enough to stop them seeing data they should not see through the interface, which is genuinely useful. It is not a control over code: anyone who can deploy code can bypass any interface permission, because the permissions are enforced by the very code they are editing.

How do you build a development environment with real data?

You do not use real data. You use an anonymised copy: names substituted, email redirected, identity documents and bank details stripped. It costs an afternoon the first time and removes most of the problem outright, because from then on the contractor's access does not reach a single real person.

What if they need to see a bug that only happens in production?

Point access, dated, accompanied, revoked the same day. This is the exception everyone turns into the rule: granted «just this once» and still open two years later. If you are going to grant it, set the expiry in the same minute you grant it.

All of this is built into Fichaloto. See how it works.

Keep reading