# Frontend

## Was es ist

Ein Frontend ist der Teil eines Softwaresystems, den Menschen ansehen und
bedienen: Seiten, Bildschirme, Formulare und Bedienelemente samt dem Code, der
sie zeichnet und auf Eingaben reagiert. Im Englischen gibt es auch die
Schreibweisen front end und front-end. Im Web wird derselbe Bereich oft
Clientseite genannt.

Im Web entsteht ein Frontend aus drei Sprachen, die ein Browser versteht.
HTML gibt einer Seite Struktur und Bedeutung, CSS bestimmt ihr Aussehen, und
JavaScript ergänzt Verhalten. Der Browser ist das, was die W3C-Schrift
Architecture of the World Wide Web einen User Agent nennt: Software, die im
Auftrag einer Person Daten von Servern abruft und darstellt. Alles, was ein
Frontend an ihn sendet, landet auf einem fremden Gerät.

Sein Gegenstück ist das Backend. Es speichert Daten, wendet Geschäftsregeln an
und beantwortet Anfragen. Beide sprechen über HTTP, meist über eine API.
Die Grenze entlang des Netzwerks zu ziehen liegt nahe, doch heutige Frameworks
verwischen sie. In Next.js sind Seiten und Layouts standardmäßig
[Server Components](https://react.dev/reference/rsc/server-components):
Sie erzeugen das Sichtbare, laufen aber auf einem Server. Die Direktive
`"use client"` am Dateianfang markiert die Grenze. Diese Datei, ihre Imports
und die von ihr gerenderten Komponenten werden Teil des an den Browser
gesendeten Bundles. Code gehört wegen seiner Aufgabe zum Frontend: Darstellung
und Interaktion. Sein Ausführungsort ist eine eigene Entscheidung.

## Warum es wichtig ist

Die erste Entscheidung ist, wo die Arbeit stattfindet. Das W3C-Architekturdokument
beschreibt ein Spektrum: An einem Ende erledigt der Client alles, am anderen
der Server. Die meisten Entwürfe verbinden laut Dokument beides. Wo eine
Anwendung einzuordnen ist, hängt in dessen Worten von der Leistungsfähigkeit
des Clients, der Leistung und Last des Servers sowie der Bandbreite dazwischen
ab. Es benennt den Zielkonflikt von beiden Seiten: Serverseitig angepasste
Inhalte senken die Cache-Effizienz. Ist die mögliche Clientzahl unbegrenzt,
skaliert die Verlagerung der Berechnung auf die Clients besser. Üblich sind
einmal gebaute Seiten, pro Anfrage auf dem Server gerenderte Seiten, im Browser
zusammengesetzte Seiten und Mischformen. Eine für alle gleiche Seite wird am
günstigsten einmal gebaut und gecacht. Eine Seite mit den Daten eines einzelnen
Kunden wird irgendwo pro Anfrage gerendert. Fällt die Wahl auf den Browser,
lädt jeder Leser den dafür nötigen Code herunter.

Die zweite Entscheidung ist, wie weit ihm vertraut wird. Die praktische Antwort
lautet: Der Server vertraut ihm überhaupt nicht. Alles vom Frontend Ausgelieferte
kann die Person am Browser lesen, bearbeiten und erneut abspielen. Ein
versteckter Button oder ein Formular, das sich nicht absenden lässt, hilft
ehrlichen Nutzern und bedeutet für andere nur einen kleinen Umweg. Jede wichtige
Berechtigungs- und Validierungsprüfung wird deshalb auf dem Server wiederholt.
Für Geheimnisse gilt dasselbe: Ein API-Schlüssel im Bundle ist öffentlich,
unabhängig vom Variablennamen. Content Security Policy begrenzt, was ein
eingeschleustes Skript tun kann. Ihre Spezifikation beschreibt sie als zusätzliche
Verteidigungsschicht, nie als Ersatz für sorgfältige Eingabeprüfung und
Ausgabekodierung.

Im Frontend entscheidet sich auch die Barrierefreiheit. WCAG 2.2, die im
Dezember 2024 veröffentlichte W3C-Empfehlung, legt prüfbare Erfolgskriterien
fest. Viele hängen von Frontend-Entscheidungen ab: Ist ein Bedienelement per
Tastatur erreichbar und bedienbar, und stellt es assistiven Technologien einen
Namen und eine Rolle bereit? Native HTML-Elemente erfüllen mehrere davon von
Haus aus. Ein eigenes Widget muss jedes von Hand nachbauen.

Schließlich muss sich ein Frontend, das die Speicherstruktur der Datenbank
kennt, bei jeder Datenbankänderung mitändern. Beschränkt es sich auf Darstellung,
können beide Seiten sich dagegen im eigenen Tempo weiterentwickeln.

## Wie es in der Praxis aussieht

Auf einer Plattform wird Teil für Teil entschieden, wo das Frontend rendert.
Ihr Frontend mit Next.js 16
[wählt für jeden Anwendungsteil einen Rendering-Modus](/de/portfolio/built-the-next-js-16-frontend-ssr-ssg-and-csr/).
Marketing- und öffentliche Seiten werden statisch erzeugt, interaktive Teile
im Browser gerendert. Im Dashboard für angemeldete Nutzer und in großen
Verzeichnislisten machte das N+1-Muster aus einer Seite eine Kaskade von
Netzwerkumläufen. Dort lädt eine Factory namens `createPrefetchedServerPage`
die Seitendaten auf dem Server vor und übergibt sie anschließend dem Client.
Für jede Datenanfrage ist eine Strategie zur Cache-Invalidierung dokumentiert.
Eine auf die Factory umgestellte Seite lädt in einem Netzwerkumlauf; die
nächste umgestellte Seite erbt dieses Verhalten. Die Migration läuft noch.
Der übrige nur nach Anmeldung zugängliche Anwendungsteil wird auf dem Client
gerendert und wartet auf die Umstellung.

Der Architekturbeitrag der Gründerin zu NextMariner, einer maritimen Plattform,
[gibt ihrem Frontend genau eine Aufgabe](/de/portfolio/a-maritime-platform-built-in-clean-layers/).
Das Frontend in Next.js übernimmt Darstellung und Interaktivität. Eine bewusst
dünne Go-API mit Huma auf Fiber routet und validiert Anfragen, wendet
Sicherheitsfilter an und koordiniert die Abläufe. Die Geschäftslogik liegt
dagegen in PostgreSQL-Funktionen. Eine Geschäftsregel wird in diesem Entwurf in einer
Schicht geändert, in SQL, statt dieselbe Regel in allen drei Schichten
vorhalten zu müssen. Die Grenzen wurden aufgeschrieben und anschließend in
Code-Reviews durchgesetzt. Das dokumentierte Ergebnis sind getrennte
Verantwortlichkeiten für Darstellung, Anfragebearbeitung und Geschäftsregeln.

Die Arbeit an der Anwendungshärtung
[geht von einem feindlichen Client aus](/de/portfolio/hardened-the-application-with-nonce-based-csp/).
Auf Frontend-Seite setzt die Proxy-Middleware von Next.js in `proxy.ts` eine
Content Security Policy mit einem pro Anfrage erzeugten Nonce und
`strict-dynamic`, zusammen mit HSTS und SameSite-Cookies. Die eigentliche
Grenze liegt auf dem Server. Berechtigungen für Tarifstufe, Rolle sowie die
Abgrenzung nach Organisation und Schiff werden für jede Anfrage erneut auf
dem Server geprüft. Die Zugangsschranken des Frontends dienen allein der
Nutzerführung: Sie formen das Sichtbare, der Server entscheidet über das Erlaubte.

## Wo es schiefgeht

Frontend-Fehler haben oft dieselbe Ursache: Im Browser wurde etwas entschieden,
das auf den Server gehörte, oder umgekehrt.

**Ein API-Schlüssel steht im JavaScript, das jeder Besucher herunterladen kann.**
In Next.js gelangt eine Umgebungsvariable nur dann ins Browser-Bundle, wenn ihr
Name mit `NEXT_PUBLIC_` beginnt. Jede andere aus Clientcode gelesene Variable
wird durch eine leere Zeichenfolge ersetzt. Kommt eine Anfrage als nicht
autorisiert zurück und wird die Variable rasch umbenannt, damit es funktioniert,
landet das Geheimnis direkt in einer öffentlichen Datei. Halten Sie Code mit
benötigten Geheimnissen auf dem Server und markieren Sie sein Modul mit dem
Paket `server-only`. Ein Import aus einer Client Component lässt dann den
Build scheitern. Rotieren Sie jeden bereits ausgelieferten Schlüssel.

```ts
import "server-only";
export async function getInvoices(customerId: string) {
    const url = `${process.env.BILLING_URL}/customers/${customerId}/invoices`;
    const headers = { Authorization: `Bearer ${process.env.BILLING_KEY}` };
    const res = await fetch(url, { headers });
    return res.json();
}
```

**Ein Nutzer erreicht Datensätze, die ihm die Oberfläche verborgen hatte.**
Die Berechtigungsprüfung lag im Frontend, als Routenschutz, versteckter
Menüeintrag oder deaktivierter Button. Wer den Netzwerkverkehr liest, kann
die API direkt mit anderen Parametern aufrufen. Prüfen Sie jede Berechtigung
auf dem Server bei jeder Anfrage anhand des angemeldeten Nutzers und des
konkreten Datensatzes. Behandeln Sie die Frontend-Prüfungen als Komfort für
ehrliche Nutzer.

**Die Seite füllt sich Ladeanzeige für Ladeanzeige.** Jede Komponente fragt ihre
Daten erst nach dem Rendern ab. Eine Anfrage des Kindelements wartet deshalb
auf die des Elternelements. Die Seite kommt als Wasserfall von Netzwerkumläufen
an. Laden Sie die Daten einer Seite gemeinsam und nahe ihrer Quelle, auf dem
Server, wo das Framework es zulässt, und reichen Sie sie nach unten weiter.

**Tastatur- und Screenreader-Nutzer bleiben an einem eigenen Bedienelement hängen.**
Ein anklickbares `div` bekommt das Mausverhalten eines Buttons, aber sonst
nichts: keinen Fokus, keine Reaktion auf Enter und Leertaste, keine Auskunft
über seine Art an assistive Technologien. WCAG 2.2 verlangt auf Stufe A, dass
alle Funktionen per Tastatur bedienbar sind, Erfolgskriterium 2.1.1, und jede
Komponente ihren Namen und ihre Rolle offenlegt, 4.1.2. Verwenden Sie `button`,
`a`, `input` und `label` ihrer Bedeutung entsprechend. Probieren Sie jeden
neuen Bildschirm vor der Auslieferung allein mit der Tastatur aus.

## Weiterführende Lektüre

- [Architektur des World Wide Web, Band Eins](https://www.w3.org/TR/webarch/) —
  die W3C-Empfehlung zu User Agents und zur Arbeitsteilung zwischen Client
  und Server.
- [HTML-Standard](https://html.spec.whatwg.org/multipage/) — der fortlaufend
  gepflegte WHATWG-Standard für Elemente und Browser-APIs eines Web-Frontends.
- [Richtlinien für barrierefreie Webinhalte (WCAG) 2.2](https://www.w3.org/TR/WCAG22/)
  — die W3C-Empfehlung mit den prüfbaren Erfolgskriterien einer barrierefreien
  Oberfläche.
- [Content Security Policy Level 3](https://www.w3.org/TR/CSP3/) — der
  W3C-Arbeitsentwurf, der Nonces und `strict-dynamic` definiert.
- [Next.js: Server- und Client-Komponenten](https://nextjs.org/docs/app/getting-started/server-and-client-components)
  — wie ein Framework den Frontend-Code zwischen Server und Browser aufteilt.

<https://engineer.company/de/glossary/frontend/>
