For most of the web's history, application security in the European Union was governed by a single regulation with teeth — the GDPR — and a scattering of sector rules. That is no longer the situation. Between 2024 and 2027 the EU has assembled a layered cybersecurity regime that reaches almost every organisation running a web application for European users: the NIS2 Directive, the Cyber Resilience Act, and, for the financial sector, DORA. Each of them carries administrative fines, and several carry personal liability for management.
The common thread across all of them is a shift in burden. The regulator no longer accepts "we take security seriously" as a statement of intent. It expects security to be demonstrable — built in from the design stage, on by default, evidenced by records, and testable. Architecture is no longer an implementation detail below the compliance line. It is where a growing share of the compliance obligation is actually met, or not.
This post maps the requirements a European web application faces onto the properties of a server-authoritative architecture — being precise about what the architecture gives you for free, and honest about what it does not.
The regulations that touch a web application
- GDPR — Regulation (EU) 2016/679
- In force since 2018. Article 5 sets the processing principles — data minimisation, storage limitation, integrity and confidentiality, and accountability. Article 25 requires data protection by design and by default. Article 32 requires security of processing appropriate to the risk. Article 30 requires records of processing activities. Fines reach €20 million or 4% of global annual turnover.
- NIS2 — Directive (EU) 2022/2555
- National transposition due October 2024. It obliges essential and important entities across many sectors to adopt cybersecurity risk-management measures (Article 21) and to report significant incidents on a strict clock — an early warning within 24 hours, a full notification within 72. Management bodies are accountable and can be held personally liable for non-compliance.
- Cyber Resilience Act — Regulation (EU) 2024/2847
- Entered into force in December 2024, with the main obligations applying from 2027. It imposes essential cybersecurity requirements on products with digital elements: secure by design and by default, delivered without known exploitable vulnerabilities, with an attack surface kept to a minimum and a documented vulnerability-handling process across the product lifecycle.
- DORA — Regulation (EU) 2022/2554
- Applies to financial entities from January 2025. It requires ICT risk management, resilience testing, and detailed incident classification and reporting, with an explicit expectation of traceability across systems — the ability to reconstruct what happened, when, and to which data.
- ePrivacy — Directive 2002/58/EC
- Still the governing rule for cookies and client-side storage. Reading from or writing to a user's device — cookies, localStorage, fingerprinting — requires prior informed consent unless strictly necessary to provide the service the user requested.
None of these regulations names an architecture. All of them describe properties. The question worth asking is which architecture makes those properties the default rather than an ongoing effort.
Data protection by design — GDPR Article 25
Article 25 is the clause that most directly rewards architectural decisions. It requires that data protection is engineered into the system from the outset and that, by default, only the personal data necessary for each specific purpose is processed. It is the one requirement that a diligent policy cannot satisfy on its own — it asks what the system does, not what the organisation promises.
In a client-heavy architecture, personal data is routinely copied into the browser to render a view: profile records in a state store, transaction lists in memory, draft form data in localStorage, cached responses the framework retains for performance. Each copy is personal data processed on a device the operator does not control, persisting for a lifetime the operator did not choose. Every one of those copies is in scope for Article 25, and each is a place minimisation can quietly fail.
Under a server-authoritative model the browser holds no application state. It receives a rendered projection — exactly the fields needed for the view in front of the user, and nothing more — and discards it on navigation. Minimisation is not a discipline applied on top of the data flow; it is the shape of the data flow. The server computes the smallest projection that answers the request, and that projection is all that ever leaves the trust boundary.
Security of processing — GDPR Article 32 and OWASP
Article 32 requires security measures appropriate to the risk, and supervisory authorities routinely read it against recognised technical baselines — the OWASP Top 10 and the OWASP Application Security Verification Standard chief among them. The most consequential category in that list, year after year, is broken access control. It is also the one an architecture can eliminate structurally rather than defend against case by case.
When the client holds state, authorisation becomes a value the client can see and, too often, influence — a role flag in a token payload, a hidden field, an object identifier in a URL that maps straight to a record. Broken access control is the recurring result: the classic client-side privilege escalation, and insecure direct object references. When the server is authoritative, none of that state exists on the client to tamper with. The server computes what an actor is permitted to see and do, on every request, from state the actor never touches.
Mapped against the requirement, the architecture answers several OWASP categories at the structural level rather than the mitigation level:
- A01 Broken Access Control. Authorisation is computed server-side per request; there is no client-held permission to escalate.
- A03 Injection. A single server-side validation path guards every state transition; there is no parallel client validation to drift out of sync. Parameterised queries and auto-escaped templates are the default.
- A04 Insecure Design. State transitions are validated intents applied against current server truth — the trust boundary is drawn where it can be enforced.
- A05 Security Misconfiguration. A minimal dependency surface and no client build pipeline means fewer moving parts to misconfigure or leave exposed.
- A09 Logging and Monitoring Failures. Every state transition passes through one gateway and is logged there once — the audit trail is a by-product, not an add-on.
Accountability and the audit trail — Article 5(2), NIS2, DORA
Three separate obligations converge on the same technical need. GDPR Article 5(2) requires the controller to be able to demonstrate compliance. NIS2 requires incident detection and reporting on a 24-and-72-hour clock. DORA requires the reconstruction of what happened to which data. All three assume the system can produce a truthful, ordered record of what it did.
A server-authoritative system persists state as an append-only event log: every transition is an entry, written once, never mutated. That is not a compliance feature bolted on to satisfy an auditor — it is how the system stores state in the first place. The record required to demonstrate accountability, to file a 72-hour NIS2 notification with substance, and to satisfy DORA traceability is the same log the application already relies on to know what is true.
Erasure, residency, and the cookie question
The right to erasure under Article 17 is bounded by where the data lives. When state exists only server-side, erasure is an operation against known storage the operator controls. When copies of personal data are scattered across browser caches, local storage, and framework state stores, the operator cannot fully honour an erasure request for data sitting on a device it never sees. A single authoritative store is not merely tidier — it is the difference between an erasure guarantee you can make and one you cannot.
Data residency follows the same logic. Keeping personal data on EU-hosted infrastructure is undermined the moment the frontend pulls scripts, fonts, or data from third-party CDNs at runtime — each such request can carry an IP address and referrer to infrastructure outside the operator's control and outside the EU. A server-authoritative site renders on infrastructure the operator chooses and ships no runtime third-party requests, keeping the data path inside the boundary the operator actually declared.
The ePrivacy consent requirement is triggered by non-essential reads from and writes to the user's device. An architecture that keeps no meaningful state on the client has little reason to touch localStorage or set analytics cookies in the first place. A single HttpOnly, Secure, SameSite session cookie is strictly necessary to deliver the service and falls under the consent exemption. Less client-side state means a smaller consent surface — and fewer places a consent failure can occur.
European regulation keeps asking the same underlying question in different registers: where does the data live, who can change it, and can you prove what happened to it? A server-authoritative architecture gives one answer to all three — the server owns the state, mediates every change, and logs it once — which is exactly the shape the regulation was written to require.
What the architecture does not do
Compliance is organisational before it is technical, and no architecture discharges the parts that are genuinely about governance. A server-authoritative system does not establish a lawful basis for processing, does not appoint a data protection officer, and does not carry out the data protection impact assessment that high-risk processing requires. It does not write your records of processing, run your resilience tests, or file your incident notifications. It does not encrypt data at rest or manage keys for you — Article 32 still expects those, and they remain configuration and operational discipline.
What the architecture does is narrower and worth stating precisely: it removes whole classes of requirement from the category of things you must remember to do, and moves them into the category of things the system does by construction. Minimisation becomes the shape of the data flow. Access control becomes a server-side computation with nothing on the client to escalate. The audit trail becomes the storage model. Those are not the whole of compliance — but they are the parts most likely to fail quietly under a client-heavy architecture, and the parts a diligent policy document cannot fix on its own.
The regulatory direction of travel in Europe is settled: security must be demonstrable, built in, and on by default. That is a description of an architectural property, not a policy aspiration. Choosing where state lives is choosing how much of that description your system satisfies before anyone writes a word of documentation.