Webapp-Entwicklung: Agentur oder Freelancer?

“Sollen wir eine Agentur beauftragen oder einen Freelancer?” Diese Frage höre ich bei jedem zweiten Erstgespräch. Die ehrliche Antwort: Es kommt darauf an. Nach 15+ Jahren auf beiden Seiten (als Freelancerin und als Teil von Agentur-Teams) zeige ich Ihnen, wann welches Modell Sinn macht, und wo die versteckten Fallstricke liegen.

Executive Summary

Freelancer wählen bei:

• Budget unter 50k (93% effektive Entwicklungszeit vs. 70% bei Agentur)
• Scope klar definiert (20 bis 40% günstiger als Agentur)
• Technisch versiertem Ansprechpartner intern
• Spezialwissen gefragt (50x gemacht vs. “nebenbei mitmachen”)

Agentur wählen bei:

• Budget über 100k (Redundanz und Full-Service nötig)
• Unklarem oder wachsendem Scope (Discovery-Phase erforderlich)
• Keinem technischen Know-how intern
• Bedarf an Design, UX, SEO zusätzlich zur Entwicklung

TL;DR: Die Vergleichstabelle

Kriterium	Freelancer	Agentur
Stundensatz	80 bis 150 Euro	120 bis 200 Euro
Tagessatz	640 bis 1.200 Euro	960 bis 1.600 Euro
Verfügbarkeit	Einzelperson, Urlaub/Krankheit kritisch	Team, Vertretung möglich
Kommunikation	Direkt mit Entwickler	Über Projektmanager
Flexibilität	Hoch, schnelle Entscheidungen	Prozesse, längere Abstimmung
Spezialisierung	Oft tief in 1 bis 2 Bereichen	Breit aufgestellt
Skalierung	Begrenzt, max. 1 FTE	Mehrere Entwickler möglich
Risiko	Höher (Bus-Faktor 1)	Niedriger (Team)
Overhead	Minimal	PM, QA, Meetings

Der finanzielle Impact: Rechenbeispiel

Bei 30.000 Euro Budget:

Modell	Stundensatz	Stunden gesamt	Effektive Dev-Stunden
Freelancer	100 Euro	300h	280h (93%)
Agentur	150 Euro	200h	140h (70%)

Ergebnis: Doppelt so viel Entwicklungszeit beim Freelancer. Der Unterschied: Agenturen rechnen PM, Meetings, QA, Reporting mit ab. Beim Freelancer zahlen Sie primär Code.

Wann ein Freelancer die bessere Wahl ist

1. Spezialisierte Aufgaben

Sie brauchen jemanden, der PostgreSQL-Queries von 2.800ms auf 8ms optimiert? Oder eine Legacy-PHP-4-Anwendung auf PHP 8.3 migriert? Für solche Spezialaufgaben ist ein Freelancer mit genau dieser Expertise Gold wert.

Agenturen haben oft Generalisten. Wenn Sie “PostgreSQL Performance Tuning” anfragen, bekommen Sie vielleicht einen Entwickler, der das “nebenbei mitmacht”. Ein spezialisierter Freelancer hat das schon 50x gemacht.

Real Case: Ein Kunde kam mit einem Performance-Problem. Die Agentur hatte 3 Monate “optimiert”, ohne Erfolg. Der Freelancer (ich) fand in 2 Tagen das Problem: fehlende Indizes und ein N+1-Query-Desaster. Kosten Agentur: 45.000 Euro. Kosten Freelancer: 1.600 Euro.

2. Klare, abgegrenzte Projekte

Wenn der Scope klar definiert ist, etwa “REST-API für Lagerverwaltung mit 12 Endpoints”, dann brauchen Sie keine Agentur mit Discovery-Phase, Wireframes und wöchentlichen Steering-Committee-Meetings.

// Beispiel: Klarer Scope, perfekt für Freelancer
// 12 Endpoints, CRUD für Lagerbestände, JWT-Auth

class LagerbestandController {
    public function __construct(
        private PDO $db,
        private AuthService $auth
    ) {}

    public function getBestand(int $artikelId): array {
        $stmt = $this->db->prepare("
            SELECT artikel_id, menge, lagerort, letzte_inventur
            FROM lagerbestand
            WHERE artikel_id = :id
        ");
        $stmt->execute(['id' => $artikelId]);
        return $stmt->fetch(PDO::FETCH_ASSOC) ?: [];
    }

    public function updateBestand(int $artikelId, int $menge): bool {
        $stmt = $this->db->prepare("
            UPDATE lagerbestand
            SET menge = :menge, updated_at = NOW()
            WHERE artikel_id = :id
        ");
        return $stmt->execute(['id' => $artikelId, 'menge' => $menge]);
    }
}

3. Budget-Optimierung

Bei gleichem Budget bekommen Sie vom Freelancer mehr Entwicklungsstunden. Der Grund: Agenturen haben Overhead (Projektmanagement, Account Management, Büro, Vertrieb). Das Rechenbeispiel oben zeigt: Bei 30k Budget sind das 280h vs. 140h effektive Entwicklungszeit.

4. Direkter Draht zum Entwickler

“Können Sie kurz schauen, warum der Export nicht funktioniert?” Beim Freelancer: Anruf, 10 Minuten später gelöst. Bei der Agentur: Ticket erstellen, Priorisierung abwarten, nächster Sprint, 2 Wochen später bearbeitet.

Für kleine Anpassungen und schnelle Bugfixes ist die direkte Kommunikation mit dem Entwickler unbezahlbar.

Wann eine Agentur die bessere Wahl ist

1. Komplexe Projekte mit unklarem Scope

“Wir brauchen irgendwie ein Kundenportal, aber wissen noch nicht genau was.” Hier brauchen Sie Discovery, UX-Research, Prototyping. Das kann ein einzelner Freelancer nicht leisten, zumindest nicht in der Breite.

Agenturen bringen:

• UX-Designer für Nutzerforschung und Wireframes
• Business-Analysten für Anforderungen
• Projektmanager für Koordination
• Mehrere Entwickler für Frontend und Backend

2. Langfristige Wartung und Support

Ein Freelancer kann krank werden, in Urlaub fahren, oder ein besseres Angebot annehmen. Wenn Ihre Webapp geschäftskritisch ist, brauchen Sie Redundanz.

Der Bus-Faktor: Wie viele Personen müssten vom Bus überfahren werden, damit das Projekt stirbt? Bei einem Freelancer: 1. Bei einer Agentur: mehrere.

// Dokumentation allein reicht nicht
// Wissen muss im Team verteilt sein

class WartungsVertrag {
    // Agentur-Modell
    private array $teamMitglieder = [
        'entwickler_1' => 'Backend, PHP, PostgreSQL',
        'entwickler_2' => 'Backend, PHP, MySQL',
        'entwickler_3' => 'Frontend, JavaScript',
        'devops' => 'Server, Deployment',
    ];

    // Freelancer-Modell
    private array $einzelkaempfer = [
        'freelancer' => 'Alles', // Risiko!
    ];

    public function getVertretung(string $modell): ?string {
        if ($modell === 'agentur') {
            return 'Vertretung vorhanden';
        }
        return null; // Freelancer: Keine Vertretung
    }
}

3. Full-Service-Anforderungen

Sie brauchen nicht nur Entwicklung, sondern auch:

• Corporate Design und Branding
• SEO und Content-Strategie
• Hosting und DevOps
• Schulungen und Change Management

Ein Freelancer kann das nicht alles abdecken. Zumindest nicht in der Tiefe, die Enterprise-Projekte brauchen.

4. Compliance und Zertifizierungen

Für manche Branchen (Banken, Versicherungen, Gesundheitswesen) brauchen Sie Dienstleister mit:

• ISO 27001 Zertifizierung
• Nachweisbaren Prozessen
• Audit-Fähigkeit
• Versicherungen

Freelancer haben das selten. Agenturen schon eher.

Die versteckten Kosten

Bei Freelancern

1. Einarbeitung bei Wechsel: Wenn der Freelancer aufhört, muss der Nachfolger sich einarbeiten. Das kostet 20 bis 40 Stunden, selbst bei guter Dokumentation.

2. Keine zweite Meinung: Code-Reviews? Architektur-Diskussionen? Gibt es nicht. Der Freelancer reviewed sich selbst, und das ist selten kritisch genug.

3. Verfügbarkeits-Lücken: Urlaub, Krankheit, parallele Projekte: Ein Freelancer kann nicht 365 Tage im Jahr verfügbar sein. Planen Sie Puffer ein.

Bei Agenturen

1. Overhead-Kosten: 30 bis 40% Ihrer Zahlung gehen in Projektmanagement, Account Management, Reporting. Das ist nicht verschwendet, aber es ist keine Entwicklungszeit.

2. Junior-Entwickler: Die Seniors machen den Pitch, die Juniors die Arbeit. Fragen Sie explizit: “Wer entwickelt tatsächlich?” Bestehen Sie auf Vorstellung des Teams.

3. Vendor Lock-In: Manche Agenturen bauen absichtlich proprietäre Lösungen, damit Sie nicht wechseln können. Bestehen Sie auf:

• Dokumentation
• Standard-Technologien (PHP, PostgreSQL, MySQL, nicht “AgencyFramework 3.0”)
• Code-Übergabe bei Vertragsende

// Red Flag: Proprietäres Framework
use AgencyMagicFramework\SuperController; // Warnung!

// Green Flag: Standard-PHP
class BestellungController {
    public function __construct(
        private PDO $db, // Standard
        private Twig\Environment $twig // Open Source
    ) {}
}

Hybrid-Modelle: Das Beste aus beiden Welten

Modell 1: Agentur für Konzept, Freelancer für Umsetzung

Die Agentur macht Discovery, UX, Projektplanung. Dann übernimmt ein spezialisierter Freelancer die Entwicklung. Funktioniert gut, wenn:

• Der Freelancer die Agentur-Specs versteht
• Klare Übergabe-Punkte definiert sind
• Die Agentur nicht beleidigt ist, dass sie nicht auch entwickeln darf

Modell 2: Freelancer-Netzwerk

Statt einer Agentur: 2 bis 3 Freelancer, die sich kennen und ergänzen. Einer macht Backend (PHP, PostgreSQL), einer Frontend (JavaScript, Vue), einer DevOps (Linux, Docker).

Vorteile:

• Spezialisierung wie bei Freelancern
• Redundanz wie bei Agenturen
• Oft günstiger als Agentur

Nachteile:

• Koordination liegt bei Ihnen
• Kein einheitlicher Ansprechpartner
• Verantwortlichkeiten können unklar sein

Modell 3: Freelancer mit Backup

Der Freelancer hat einen “Buddy”, der im Notfall übernehmen kann. Beide kennen die Codebasis, beide sind eingearbeitet. Sie zahlen minimal mehr, haben aber Ausfallsicherheit.

// Vertragliche Absicherung
class FreelancerVertrag {
    public string $hauptEntwickler = 'Freelancer A';
    public string $backupEntwickler = 'Freelancer B';
    public int $backupEinarbeitungStunden = 16;
    public string $dokumentationsPflicht = 'Ja, wöchentlich';

    public function getVertretungsRegelung(): string {
        return "Bei Ausfall übernimmt {$this->backupEntwickler} " .
               "innerhalb von 48 Stunden.";
    }
}

Entscheidungs-Checkliste

Beantworten Sie diese Fragen ehrlich:

Für Freelancer entscheiden, wenn:

• Budget unter 50.000 Euro
• Scope ist klar definiert und abgegrenzt
• Sie haben einen technischen Ansprechpartner intern
• Das Projekt hat eine klare Deadline (nicht “irgendwann”)
• Sie brauchen Spezialwissen in einem Bereich
• Schnelle, direkte Kommunikation ist wichtig
• Sie können 2 bis 4 Wochen Ausfall überbrücken

Für Agentur entscheiden, wenn:

• Budget über 100.000 Euro
• Scope ist noch unklar, Discovery nötig
• Sie haben keinen technischen Ansprechpartner intern
• Das Projekt läuft langfristig (Jahre)
• Sie brauchen Full-Service (Design, SEO, Hosting)
• Ausfallsicherheit ist geschäftskritisch
• Compliance-Anforderungen (ISO, Audit)

Praxis-Tipps für beide Modelle

Bei der Auswahl

1. Referenzen prüfen: Nicht nur Portfolio anschauen. Anrufen. Fragen: “Wie war die Zusammenarbeit? Würden Sie wieder beauftragen?”

2. Technisches Interview: Lassen Sie Ihren IT-Leiter (oder einen externen Berater) ein technisches Gespräch führen. Wie tief ist das Wissen wirklich?

3. Probe-Projekt: Starten Sie mit einem kleinen Projekt (5.000 bis 10.000 Euro), bevor Sie 100.000 Euro committen.

Im Vertrag

1. Eigentumsrechte klären: Der Code gehört Ihnen. Vollständig. Ohne Wenn und Aber. Schriftlich festhalten.

2. Dokumentationspflicht: Mindestens: README, Architektur-Übersicht, Deployment-Anleitung. Besser: Inline-Kommentare, API-Dokumentation.

3. Kündigungsklauseln: Was passiert bei Kündigung? Code-Übergabe, Einarbeitung des Nachfolgers, Übergangszeit?

Vertragsklauseln zum Kopieren

Diese Formulierungen können Sie direkt in Ihren Vertrag übernehmen:

1. Code-Ownership (vollständige Rechteübertragung):

“Der Auftragnehmer überträgt dem Auftraggeber alle ausschließlichen, zeitlich und örtlich unbeschränkten Nutzungs- und Verwertungsrechte an sämtlichen im Rahmen dieses Vertrags erstellten Arbeitsergebnissen. Dies umfasst insbesondere: Quellcode, Dokumentation, Konfigurationsdateien, Build-Pipelines, Deployment-Skripte sowie alle zugehörigen Credentials, API-Keys und Zugangsdaten.”

2. Übergabe bei Vertragsende:

“Bei Beendigung des Vertragsverhältnisses (gleich aus welchem Grund) verpflichtet sich der Auftragnehmer zu: (a) Übergabe aller Repositories inkl. vollständiger Git-Historie, (b) Dokumentation gemäß Anlage A, (c) mindestens 8 Stunden Einarbeitung/Handover für den Nachfolger, (d) Bereitstellung lauffähiger Build- und Deployment-Prozesse, (e) Übergabe aller Zugangsdaten und Secrets.”

3. Vendor-Lock-in vermeiden:

“Die Entwicklung erfolgt ausschließlich mit Standard-Technologien und Open-Source-Frameworks (PHP, PostgreSQL, MySQL, Vue.js, etc.). Proprietäre Frameworks, eigene Libraries oder nicht dokumentierte Abhängigkeiten sind unzulässig. Der Code muss von einem durchschnittlich qualifizierten Entwickler ohne Spezialwissen des Auftragnehmers wartbar sein.”

4. SLA-Light für Freelancer:

“Reaktionszeiten: Kritische Bugs (System nicht nutzbar): Reaktion innerhalb von 24 Stunden, Fix innerhalb von 72 Stunden. Normale Bugs: Reaktion innerhalb von 48 Stunden, Fix im nächsten geplanten Release. Feature-Requests: Bearbeitung nach Absprache und Kapazität.”

// Technische Umsetzung der Vertragsanforderungen
class VertragsPruefung {
    public array $pflichtDokumente = [
        'README.md' => 'Setup, Konfiguration, Deployment',
        'ARCHITECTURE.md' => 'Systemübersicht, Komponenten',
        'API.md' => 'Endpoints, Request/Response-Formate',
        'DATABASE.md' => 'Schema, Relationen, Indizes',
        'CHANGELOG.md' => 'Versionshistorie',
    ];

    public array $erlaubteTechnologien = [
        'backend' => ['PHP 8.x', 'Python', 'Node.js'],
        'database' => ['PostgreSQL', 'MySQL', 'MariaDB'],
        'frontend' => ['Vue.js', 'React', 'Vanilla JS'],
        'verboten' => ['AgencyFramework', 'ProprietärCMS', 'CustomORM'],
    ];

    public array $slaZeiten = [
        'kritisch' => ['reaktion' => '24h', 'fix' => '72h'],
        'normal' => ['reaktion' => '48h', 'fix' => 'nächstes Release'],
    ];

    public function pruefeCompliance(string $projektPfad): array {
        $fehler = [];

        foreach ($this->pflichtDokumente as $datei => $beschreibung) {
            if (!file_exists($projektPfad . '/' . $datei)) {
                $fehler[] = "Fehlend: {$datei} ({$beschreibung})";
            }
        }

        return $fehler;
    }
}

Real Cases aus meiner Praxis

Case 1: Freelancer-Erfolg

Ausgangslage: Mittelständler mit Legacy-PHP-System (PHP 5.6, MySQL, 200.000 Zeilen Code). Agentur hatte Angebot gemacht.

Vergleich	Agentur-Angebot	Freelancer-Lösung
Kosten	180.000 Euro	48.000 Euro
Dauer	12 Monate Neuentwicklung	6 Monate Modernisierung
Ansatz	Kompletter Rewrite	Schrittweise Migration
Risiko	Hoch (Big Bang)	Niedrig (iterativ)

Was ich gemacht habe:

• PHP 5.6 auf PHP 8.2 migriert (ohne Rewrite)
• MySQL-Queries optimiert (Index-Analyse, N+1 eliminiert)
• Security-Lücken geschlossen (Prepared Statements, CSRF-Schutz)
• Kritische Module refactored, Rest beibehalten

Ergebnis:

• Gespart: 132.000 Euro (73%)
• Zeit: 6 statt 12 Monate
• System läuft seit 3 Jahren stabil
• Jährliche Wartung: 8.000 Euro

Case 2: Agentur war richtig

Ausgangslage: Startup mit Idee, aber ohne Konzept. “Wir brauchen eine Plattform für XY.”

Warum Freelancer nicht gepasst hätte:

• Keine klaren Anforderungen
• UX-Research nötig
• MVP plus iOS-App plus Web-App plus Backend
• Investor-Pitch mit Design-Mockups

Lösung: Agentur mit Discovery-Phase (4 Wochen), dann iterative Entwicklung. Budget: 280.000 Euro über 18 Monate.

Case 3: Hybrid war optimal

Ausgangslage: Konzern will internes Tool für 2.000 Mitarbeiter. Budget: 150.000 Euro.

Lösung:

• Agentur für UX und Design (30.000 Euro)
• Ich für Backend-Entwicklung (80.000 Euro)
• Internes IT-Team für Deployment und Betrieb
• Agentur für Schulungen (20.000 Euro)

Ergebnis: Spezialisierung an den richtigen Stellen, Kosten im Budget.

Fazit: Es gibt keine pauschale Antwort

Die Frage “Agentur oder Freelancer?” ist wie “Auto oder Fahrrad?”. Es kommt darauf an, wohin Sie wollen.

Meine Empfehlung für die meisten mittelständischen Projekte:

1. Starten Sie mit einem Freelancer für klar umrissene Aufgaben
2. Holen Sie eine Agentur, wenn Scope unklar ist oder Full-Service nötig
3. Denken Sie an Hybrid-Modelle, um das Beste aus beiden Welten zu kombinieren
4. Planen Sie Redundanz ein, egal welches Modell

Und das Wichtigste: Sprechen Sie mit beiden. Ein guter Freelancer wird Ihnen ehrlich sagen, wenn das Projekt zu groß für eine Person ist. Eine gute Agentur wird zugeben, wenn ein Freelancer für Ihre Anforderungen ausreicht.

---

Sie sind unsicher, welches Modell für Ihr Projekt passt? In einem kostenlosen 30-Minuten-Gespräch analysiere ich Ihre Anforderungen und gebe eine ehrliche Einschätzung, auch wenn die Antwort “Agentur” lautet.