Serverless ist ein Scam. Nutz doch einfach einen Container.

Jedes Mal, wenn jemand für ein einfaches Backend zu Serverless greift, stirbt ein kleiner Container in mir.

Serverless verspricht dir Einfachheit, endlose Skalierung und null Wartung. In Wirklichkeit bekommst du Zeitlimits, Vendor-Lock-In, überraschende Rechnungen und eine Komplexität, die sich als Bequemlichkeit tarnt. Am Ende bastelst du dir mit endlosen SaaS-Services irgendwas zusammen, was ein Docker-Container von Haus aus kann.

Lass mich das mal aufdröseln – inklusive der typischen Gegenargumente.

Was ist eigentlich Serverless?

Bei Serverless packst du einzelne Funktionen in eine Cloud-Plattform und die übernimmt Provisionierung, Skalierung und das Ausführen. Du kümmerst dich nicht mehr um einen Server — du schmeißt einfach deinen Code dort rein und los geht’s.

Zumindest in der Theorie.

In echt bekommst du:

• Strikte Laufzeit-Limits (z.B. bei AWS Lambda max 15 Minuten)
• Kein State zwischen den Aufrufen
• Cold Starts (außer du zahlst extra und "pre-warst" deine Functions)
• Undurchsichtiges Debugging
• Vendor-spezifische Eigenheiten und Configs
• Eine Menge YAML

Und sobald du irgendwas machen willst, das nicht total banal ist — lange Prozesse, Background-Tasks, dauerhafte Verbindungen, Dateiuploads — bricht das Ganze schnell auseinander.

Container: Einfach, Stark, Unspektakulär (auf die gute Art)

Weißt du, was einfach zuverlässig läuft?

Ein Container.

• Startet schnell
• Läuft überall
• Behält State (einfach ein Docker-Volume dazupacken!)
• Keine willkürlichen Zeitlimits
• Du kannst einen Debugger anhängen, dein Lieblings-Runtime nutzen, und alles lokal oder in der Produktion laufen lassen — kein Zauber, keine komischen Regeln

Zum Beispiel:

docker run -v my-data:/data my-app

Boom — stateful workload auf deinem Laptop, auf deinem VPS oder auf deiner Edge-Box.

Kein Vendor-Lock-In. Keine versteckten Kosten. Keine App-Neuschreibung wegen irgendwelcher Constraints.

Serverless Pricing: Bewusst undurchsichtig

Serverless-Preise sind einfach ein Dark Pattern.

• Du zahlst pro Aufruf
• Pro genutztem Speicher
• Pro Laufzeit
• Pro GB Transfer
• Pro Region
• Pro Secret, das du abfragst (ja, wirklich!)

Die Preisseite ist fünf Ebenen tief und du findest Begriffe wie:

• Provisioned Concurrency Units
• GB-seconds
• Requests Tier 1/2/3

Und das Beste daran? Du weißt erst, was du zahlen musst, wenn die Rechnung kommt.

Bandwidth ist besonders dreist teuer. $0.55/GB Egress im Jahr 2025? Ernsthaft?

Dagegen: $5/Monat für einen VPS mit festen, nachvollziehbaren Preisen und voller Kontrolle. Container gewinnen haushoch.

„Aber Serverless skaliert doch!“

Technisch gesehen schon. Aber für was? Deine App mit 4 Nutzern?

Die meisten Apps brauchen gar keine "unendliche Skalierung". Sie brauchen:

• Vorhersehbarkeit
• Transparenz
• Vernünftige Ressourcen-Limits
• Eine funktionierende Dev/Staging-Umgebung

Und weißt du, was dafür perfekt ist? Ein Container.

Horizontal Scaling geht easy (hier mit Docker Swarm):

replicas: 5

Oder einfach einen Load Balancer davor. Du bekommst Skalierung und Kontrolle — ohne deine App in einen unübersichtlichen Haufen von Einzel-Functions zu zerlegen.

Stateless by Design = künstliche Probleme

Serverless zwingt dich dazu, stateless zu bleiben. Bedeutet:

• Keine In-Memory-Caches
• Keine temporären Files
• Keine Sticky Sessions
• Keine dauerhaften Verbindungen

Das heißt, du brauchst jetzt:

• Eine externe Datenbank
• Einen verteilten Cache
• Einen Storage-Bucket
• Einen Event-Bus
• Einen State-Machine-Service, um deine State-Machines zu managen

Plötzlich hängt deine "simple" Serverless-App an sechs SaaS-Tools (mit jeweils eigenen Preisen, APIs und Ausfallmöglichkeiten).

Während du im Container ganz entspannt:

• Speicher im RAM cachen kannst
• Auf Platte schreibst (Docker Volume)
• Sessions halten kannst
• So lange laufen kannst, wie du willst

Eben wie ein normales Programm.

„Aber ich will keine Server managen!“

Kein Problem. Musst du auch nicht.

Es gibt genug Tools, mit denen du containerbasierte Plattformen nutzen kannst, ohne jemals wieder SSH einzugeben:

• Sliplane (shameless plug)
• Railway
• Coolify
• Selbst Docker + systemd auf einem VPS erfordert kaum noch Aufwand!

Du bekommst trotzdem Git-Deployments, Rollbacks, Logs, Metriken – aber du hast die Kontrolle und verstehst das System wirklich.

„Serverless ist billiger!“

Echt?

Vielleicht, wenn du fünf Aufrufe am Tag hast. Aber sobald du:

• Gleichbleibenden Traffic hast
• Mehr RAM brauchst
• Wirklich was berechnest
• Daten verschiebst

...schießen die Kosten durch die Decke. Optimieren kannst du wenig, weil alles in der Platform versteckt ist.

Mit Containern hingegen:

• Laufen deine Apps dauerhaft auf günstiger Hardware
• Kannst du Storage und Cache direkt daneben packen
• Benchmarken und tunen ist einfach
• Du zahlst nicht pro Millisekunde

Wann Serverless wirklich Sinn macht

Okay, fair: Es gibt schon einen Platz für Serverless:

• Eventgetriebene Functions (z.B. Bilder umwandeln)
• Gelegentliche Tasks oder Webhooks
• Mini-Tools für intern
• Proof-of-Concepts
• Sachen, die extrem schnell hoch- und runterskalieren müssen

Wenn deine Workload wirklich unregelmäßig und stateless ist und du null Bock auf Betrieb hast: Klar, dann kann Serverless passen.

Für echte Apps? Da läufst du schnell gegen die Wand. Und die ist teuer, kostet Nerven und graue Haare.

Containers FTW

Container geben dir:

• Beweglichkeit
• Kontrolle
• Übersichtlichkeit
• Transparenz
• Flexibilität

Ob ein Container oder zehn — du kannst sie deployen, skalieren, überwachen, State halten, Jobs im Hintergrund laufen lassen, eigene Datenbanken verwenden, den Provider wechseln — ohne Code umzuschreiben.

Und du verstehst tatsächlich, wie dein System läuft.

TL;DR

Serverless klingt cool — auf dem Papier.

In der Realität ist es:

• Intransparent
• Überteuert
• Überkompliziert
• Überhyped

Bevor du drauf reinfällst, frag dich einfach:

„Könnte das nicht einfach ein Container sein?“

Die Antwort ist wahrscheinlich Ja. Und wenn ja — spar dir Ärger und fang gleich damit an.

Serverless-Frust erlebt?

Erzähl unten in den Kommentaren deine Horror-Stories! Unerwartete Rechnungen, kaputte Workflows, YAML-Albträume — ich will alles hören.

Lasst uns die einfachen Sachen nicht weiter kompliziert machen.

Cheers,

Jonas, Co-Founder von sliplane.io