10 · From Zero to Deployed

„Architektur“ klingt groß, meint aber nur: wie du Frontend, Backend und Daten anordnest. Wer die üblichen Formen kennt, wählt bewusst die einfachste, die reicht — und baut nicht aus Versehen etwas zu Kompliziertes.

Die Idee

Stell dir Bausteine vor: vorne (was man sieht), hinten (was entscheidet), unten (was sich merkt). Man kann sie auf ein paar Arten stapeln. Für den Anfang nimmt man die einfachste, die funktioniert.

Instagram hat als winzige App genauso angefangen: ein Frontend, ein Backend, eine Datenbank. Erst als es riesig wurde, wurde es intern in viele Dienste zerlegt. Du fängst dort an, wo Instagram angefangen hat — nicht dort, wo es heute steht.

So funktioniert es

Three-Tier: drei Schichten übereinander — Frontend → Backend → Datenbank. Einfach, verständlich, passt für die allermeisten Apps.
Microservices: ein großes Backend wird in viele kleine, eigenständige Dienste zerlegt (einer für Beiträge, einer für Likes, einer für Nachrichten). Mächtig bei großem Maßstab, aber deutlich komplexer.
Serverless: du schreibst nur den Code, die Cloud führt ihn bei Bedarf aus und skaliert automatisch.

flowchart TD
    A[Frontend
Feed] --> B[Backend
API]
    B --> C[(Datenbank
Beiträge)]

So steuerst du es

Three-Tier trennt Darstellung, Logik und Datenhaltung — jede Schicht hat eine klare Aufgabe. Microservices erkaufen Skalierung und Team-Autonomie mit Betriebs- und Debugging-Komplexität: plötzlich reden Dienste übers Netzwerk miteinander, und ein Fehler kann irgendwo in der Kette liegen. Serverless (Cloud Run) nimmt dir den Serverbetrieb ab und skaliert bis null.

Für diesen Kurs: einfaches Three-Tier, ausgeliefert serverless auf Cloud Run.

So sagst du es dem Agenten:

„Baue eine einfache Three-Tier-App für Instagram-Beiträge: Frontend, kleines Backend, eine Datenbank. Keine Microservices.“

„Halte die Architektur so einfach wie möglich; erkläre, falls du etwas Komplexeres vorschlägst, und warum.“

„Liefere serverless auf Cloud Run aus, damit ich mich nicht um Serverbetrieb kümmern muss.“

Typischer Anfängerfehler: zu früh Microservices, „weil es professionell klingt“. Nimm die einfachste Form, bis ein echter, messbarer Grund dagegen spricht.

Kurz-Check

Welche drei Schichten hat eine Three-Tier-App?
Wann sind Microservices sinnvoll — und wann nicht?
Welche Architektur nutzen wir im Kurs?

Antworten anzeigen

Frontend, Backend, Datenbank.
Sinnvoll bei großem Maßstab und großen Teams; unnötig und schädlich für eine kleine App.
Einfaches Three-Tier, serverless auf Cloud Run ausgeliefert.

"Architecture" sounds big, but it just means how you arrange frontend, backend, and data. Knowing the common shapes lets you deliberately pick the simplest one that suffices — and not accidentally build something too complex.

The idea

Picture building blocks: front (what you see), back (what decides), bottom (what remembers). You can stack them a few ways. To start, take the simplest one that works.

Instagram began exactly like this as a tiny app: one frontend, one backend, one database. Only when it grew huge was it split internally into many services. You start where Instagram started — not where it is today.

How it works

Three-tier: three layers stacked — frontend → backend → database. Simple, understandable, fits the vast majority of apps.
Microservices: one large backend split into many small, independent services (one for posts, one for likes, one for messages). Powerful at scale, but noticeably more complex.
Serverless: you write only the code, the cloud runs it on demand and scales automatically.

flowchart TD
    A[Frontend
feed] --> B[Backend
API]
    B --> C[(Database
posts)]

How you steer it

Three-tier separates presentation, logic, and data — each layer has a clear job. Microservices buy scale and team autonomy at the price of operational and debugging complexity: suddenly services talk to each other over the network, and a bug can hide anywhere in the chain. Serverless (Cloud Run) removes server operations and scales to zero.

For this course: simple three-tier, delivered serverless on Cloud Run.

How to tell the agent:

"Build a simple three-tier app for Instagram posts: frontend, small backend, one database. No microservices."

"Keep the architecture as simple as possible; explain if you propose something more complex, and why."

"Deliver serverless on Cloud Run so I do not have to run servers."

Classic beginner mistake: reaching for microservices too early "because it sounds professional." Take the simplest shape until a real, measurable reason argues otherwise.

Quick check

What are the three layers of a three-tier app?
When do microservices make sense — and when not?
Which architecture do we use in the course?

Show answers

Frontend, backend, database.
Useful at large scale and with big teams; unnecessary and harmful for a small app.
Simple three-tier, delivered serverless on Cloud Run.

10 · Moderne Architekturen

10 · Modern architectures