Custom Dashboard mit Retool bauen

Warum Tableau für Ops-Teams teuer wird

Dein Operations-Team braucht Echtzeit-Dashboards für Bestellungen, Inventar und Kundensupport. Tableau ist dafür ein starkes Analyse-Werkzeug, aber es hat einen Preis: In der Standard Edition kostet ein Creator 75 $ pro User und Monat, ein Explorer 42 $ und ein Viewer 15 $, jeweils jährlich abgerechnet. Jede Bereitstellung braucht mindestens einen Creator. Und Tableau bleibt ein Werkzeug zum Anschauen: Formulare, Buttons und Schreibaktionen auf deine Datenbank sind nicht sein Zweck.

Wir bauen für Kunden über unseren Dashboards-Service interne Dashboards, die beides können: Daten anzeigen und Daten ändern. Das Ergebnis ist ein Werkzeug, das dein Ops-Team selbst anpassen kann, ohne für jede neue Ansicht einen Analysten zu brauchen.

Anders als Tableau-Dashboards verbindet sich Retool direkt mit deiner Produktions-Datenbank über einen Read-Only-User. Kein Daten-Kopieren nötig.

Der moderne Dashboard-Stack: Retool + PostgreSQL + REST APIs

Hier ist die Architektur, die wir in unseren Custom-Development-Implementierungen nutzen:

Warum Retool?

Drag-and-Drop UI Builder: Kein React/Vue-Coding erforderlich
Native Datenbank-Konnektoren: PostgreSQL, MySQL, MongoDB, Snowflake und mehr
REST-API-Integration: Direkt mit Stripe, Shopify, HubSpot verbinden
Zugangskontrolle: Berechtigungsgruppen und Zugriffsstufen pro App
Self-Hosted-Option: Auf deiner Infrastruktur ausführen, auf allen Plänen

Kostenvergleich (offizielle Preislisten, Stand September 2026):

Tableau Standard, jährlich abgerechnet: Creator 75 $, Explorer 42 $, Viewer 15 $ pro User und Monat. Beispiel mit 10 Usern, davon 2 Creator und 8 Explorer: 150 $ + 336 $ = 486 $/Monat (5.832 $/Jahr)
Retool Team, jährlich abgerechnet: 9 € pro Builder und 5 € pro internem User und Monat. Beispiel mit 10 Usern, davon 2 Builder und 8 interne User: 18 € + 40 € = 58 €/Monat (696 €/Jahr)
Retool Free: 0 € bis 5 User, unbegrenzt Apps

Retool zeigt seine Preisseite in der Währung deines Standorts an, Tableau listet in US-Dollar mit Währungsumrechner. Deshalb rechnen wir hier nicht gegeneinander um. Prüf beide Seiten vor der Entscheidung, die Preise ändern sich.

Schritt 1: Retool aufsetzen (Cloud oder Self-Hosted)

Option A: Retool Cloud (am schnellsten)

Geh zu retool.com und registriere dich
Der Free-Plan gilt für bis zu 5 User mit unbegrenzt Web- und Mobile-Apps
Diesen Abschnitt überspringen

Was der Free-Plan sonst begrenzt: 500 Workflow-Runs pro Monat, 5 GB Speicher in der Retool Database, bis zu 5 Module und 250 AI-Credits pro Monat. Ab dem sechsten User brauchst du den Team-Plan. Staging-Umgebung und App-Releases gibt es ab Team, Audit-Logs und eigene Berechtigungsgruppen ab Business, SAML/OIDC-SSO und Source Control nur auf Enterprise. Alle Angaben laut Preisseite.

Option B: Self-Hosted

Self-Hosting ist auf allen Plänen möglich, auch auf Free. Enterprise brauchst du für unbegrenzte User, SSO und erweiterte Self-Hosting-Funktionen (Preisseite, Tab Self-host). Den Lizenzschlüssel holst du dir im Self-Hosted-Portal unter my.retool.com.

Für Tests und Proof-of-Concepts reicht Docker Compose auf einer Linux-VM. Retool nennt als Mindestausstattung Ubuntu 22.04 oder neuer, 8 vCPUs, 64 GiB RAM und 60 GiB Speicher und schreibt ausdrücklich, dass Docker-Deployments nicht für den Produktivbetrieb geeignet sind. Für Production ist Kubernetes mit Helm die offiziell unterstützte Konfiguration.

Die Docker-Variante in vier Befehlen:

git clone https://github.com/tryretool/retool-onpremise.git && cd retool-onpremise
./install.sh
sudo docker compose up -d
sudo docker compose ps

Zwischen ./install.sh und dem Start trägst du in docker.env drei Werte ein: LICENSE_KEY mit deinem Schlüssel aus dem Portal, BASE_DOMAIN mit der vollständigen URL deiner Instanz (für lokale Tests http://localhost:3000) und COOKIE_INSECURE=true, solange du ohne HTTPS testest. Das Skript erzeugt außerdem einen ENCRYPTION_KEY. Sichere ihn, er lässt sich nicht wiederherstellen. Danach erreichst du Retool unter http://localhost:3000/auth/signup und legst den ersten Admin an. Die Compose-Datei bringt einen PostgreSQL-Container für die Retool-eigene Datenbank mit.

Pro-Tipp: Self-Hosting ersetzt nicht die User-Gebühren. Du zahlst weiterhin den Plan pro Builder und internem User, dazu deine eigene Infrastruktur. Der Gewinn liegt woanders: Deine Daten und die Retool-Instanz bleiben in deinem Netz.

Schritt 2: Datenquellen verbinden

Retool’s Killer-Feature: mit jeder Datenquelle ohne ETL verbinden.

PostgreSQL verbinden:

In Retool, geh zu Resources → Create new → Resource und wähle die PostgreSQL-Kachel (Anleitung)

Verbindungsdetails eingeben:

Host: your-db.aws.rds.amazonaws.com
Port: 5432
Database name: production
Username: retool_readonly
Password: [sicheres Passwort]

SSL/TLS aktivieren und Test connection → Save klicken

Nutzt du Retool Cloud, muss deine Datenbank Verbindungen von den Retool-IP-Adressen zulassen. Retool bietet dafür drei Ausgangsregionen an: us-west-2 (Standard), eu-central-1 (Frankfurt) und ap-southeast-1 (Outbound Regions). Wichtig für Datenschutz-Fragen: Die Ausgangsregion ändert laut Retool nichts daran, wo Retool deine Apps und Daten speichert. Wer echte Datenresidenz braucht, hostet selbst.

KRITISCH: Read-Only-Credentials nutzen

Leg in PostgreSQL einen eigenen User an, der nur lesen darf. Die letzte Anweisung sorgt dafür, dass auch später angelegte Tabellen automatisch lesbar sind:

CREATE USER retool_readonly WITH PASSWORD 'secure_password';
GRANT CONNECT ON DATABASE production TO retool_readonly;
GRANT USAGE ON SCHEMA public TO retool_readonly;
GRANT SELECT ON ALL TABLES IN SCHEMA public TO retool_readonly;
ALTER DEFAULT PRIVILEGES IN SCHEMA public
  GRANT SELECT ON TABLES TO retool_readonly;

REST APIs verbinden (Stripe, Shopify, etc.):

Geh zu Resources → Create new → Resource → REST API
Base-URL eingeben: https://api.stripe.com/v1
Authentifizierung hinzufügen:
- Type: Bearer Token
- Token: ein Restricted Key mit Präfix rk_live_ und nur Leserechten. Stripe empfiehlt Restricted Keys statt des Secret Keys sk_live_, weil sie nur die freigegebenen Rechte tragen
Als “Stripe API” speichern

Brauchst du Hilfe beim Verbinden custom Integrationen? Wir können sichere API-Gateways mit Rate Limiting aufsetzen.

Schritt 3: Dein erstes Dashboard bauen (Order Management)

Bauen wir ein Echtzeit-Bestell-Dashboard. Das ist der häufigste Use Case, den wir bei unserem Dashboard-Implementierungs-Service sehen.

Ein Hinweis vorab: Retool hat 2026 einen neuen, KI-gestützten App Builder eingeführt, in dem du Apps per Prompt beschreibst und den React-Code direkt bearbeitest. Die bisherige Drag-and-Drop-Oberfläche heißt jetzt “Classic Apps” und bleibt verfügbar. Dieser Guide nutzt Classic Apps, weil dort jede Komponente und jede Eigenschaft dokumentiert und nachvollziehbar ist. Die Unterschiede erklärt Retool in seinem Vergleich beider Ansätze.

Dashboard-Features:

Echtzeit-Bestellliste mit Filtern (Status, Datumsbereich, Kunde)
Bestelldetails-Panel (Line Items, Versand, Kundeninfos)
Quick Actions (als versendet markieren, Rückerstattung, Kunde mailen)
Umsatz-Metriken (tägliche, wöchentliche, monatliche Trends)

Neue App erstellen

In Retool, klicke Create → App und wähle die Classic-Variante
Nenn sie “Order Dashboard”
Wähle das Desktop-Layout

Bestellliste hinzufügen (Table Component)

Table-Komponente auf den Canvas ziehen
Umbenennen zu orderTable
Klicke New Query → Wähle die “PostgreSQL”-Ressource
Query getOrders schreiben:

SELECT
  o.id,
  o.order_number,
  o.created_at,
  o.status,
  o.total_price,
  o.currency,
  c.email AS customer_email,
  c.first_name || ' ' || c.last_name AS customer_name,
  COUNT(oi.id) AS item_count
FROM orders o
LEFT JOIN customers c ON o.customer_id = c.id
LEFT JOIN order_items oi ON o.id = oi.order_id
WHERE
  o.created_at >= {{ startDate.value }}
  AND o.created_at <= {{ endDate.value }}
  AND ({{ statusFilter.value }} = 'all' OR o.status = {{ statusFilter.value }})
GROUP BY o.id, c.id
ORDER BY o.created_at DESC
LIMIT 100;

Retool schickt SQL-Queries standardmäßig als Prepared Statements. Jeder {{ }}-Ausdruck wird als Parameter übergeben, nie als Text in die Query geklebt. Das schützt vor SQL-Injection, bedeutet aber auch: Tabellen- und Spaltennamen kannst du so nicht dynamisch setzen.

Data source für die Tabelle setzen: {{ getOrders.data }}
Spalten konfigurieren (Spalten-Guide):
- id-Spalte verstecken
- created_at: Im Inspector unter Format den Typ Datetime wählen
- total_price: Format Currency wählen und die Währung setzen
- status: Format Tag mit Farbe je Wert (grün = fulfilled, gelb = pending, rot = cancelled)
- Für eigene Formate steht in Mapped Values currentRow bereit, zum Beispiel {{ moment(currentRow.created_at).format('D. MMM YYYY HH:mm') }}. Moment.js ist in Retool vorgeladen

Filter hinzufügen

Datumsbereich:

Zwei Date-Komponenten über die Tabelle ziehen
Umbenennen zu startDate und endDate
Defaults setzen: {{ moment().subtract(7, 'days').format('YYYY-MM-DD') }} und {{ moment().format('YYYY-MM-DD') }}
Bei der Query getOrders das Run-Verhalten auf Automatic lassen. Dann läuft sie neu, sobald sich ein referenzierter Wert ändert (Run behavior)

Wir nehmen zwei einzelne Date-Komponenten statt der Date-Range-Komponente, weil ihr value laut Referenz ein einfacher String ist. Das macht die Query lesbar und vermeidet Überraschungen mit der Struktur des Range-Werts.

Status-Filter:

Select-Dropdown ziehen
Umbenennen zu statusFilter

Optionen setzen:

[
  { label: 'Alle Bestellungen', value: 'all' },
  { label: 'Ausstehend', value: 'pending' },
  { label: 'Erfüllt', value: 'fulfilled' },
  { label: 'Storniert', value: 'cancelled' }
]

Default-Wert: 'all'

Bestelldetails-Panel hinzufügen

Container auf die rechte Bildschirmseite ziehen
Umbenennen zu orderDetailsPanel
Sichtbarkeit setzen: {{ orderTable.selectedRow !== null }}
Im Container Text-Komponenten hinzufügen:

Bestellung #{{ orderTable.selectedRow.order_number }}
Kunde: {{ orderTable.selectedRow.customer_name }}
E-Mail: {{ orderTable.selectedRow.customer_email }}
Status: {{ orderTable.selectedRow.status }}
Gesamt: {{ orderTable.selectedRow.total_price }} {{ orderTable.selectedRow.currency }}

Table für Line Items hinzufügen:
- Query getOrderItems erstellen:

SELECT
  product_name,
  quantity,
  price,
  quantity * price AS subtotal
FROM order_items
WHERE order_id = {{ orderTable.selectedRow.id }};

Tabellendaten setzen: {{ getOrderItems.data }}

Quick Actions hinzufügen

“Als versendet markieren”-Button:

Button in das Details-Panel ziehen
Label: “Als versendet markieren”
Click → New Query → Type: PostgreSQL, Run-Verhalten Manual
Query markShipped:

UPDATE orders
SET
  status = 'fulfilled',
  fulfilled_at = NOW()
WHERE id = {{ orderTable.selectedRow.id }}
RETURNING *;

Diese Query braucht Schreibrechte. Leg dafür eine zweite Ressource mit einem User an, der nur UPDATE auf orders darf, statt dem Read-Only-User mehr Rechte zu geben.

Im Tab Event handlers der Query einen Handler für das Event Success anlegen: Aktion Control query → getOrders → Trigger, damit die Tabelle neu lädt (Event Handler)
Zweiten Success-Handler mit Show notification: "Bestellung #{{ orderTable.selectedRow.order_number }} als versendet markiert"

“Kunde mailen”-Button:

Weiteren Button hinzufügen
Label: “Kunde mailen”
Click → New Query → Type: REST API
Zuerst eine SendGrid-Ressource anlegen: Base-URL https://api.sendgrid.com/v3, Auth Bearer Token mit deinem SendGrid API Key. Nutzt du einen EU-Subuser bei SendGrid, lautet die Base-URL https://api.eu.sendgrid.com/v3
Query sendEmail mit Method POST und Pfad /mail/send anlegen (Mail Send API). Body als JSON:

{
  "personalizations": [{
    "to": [{ "email": "{{ orderTable.selectedRow.customer_email }}" }],
    "subject": "Ihre Bestellung #{{ orderTable.selectedRow.order_number }} wurde aktualisiert"
  }],
  "from": { "email": "support@yourstore.com" },
  "content": [{
    "type": "text/plain",
    "value": "Hallo {{ orderTable.selectedRow.customer_name }}, der Status Ihrer Bestellung lautet jetzt: {{ orderTable.selectedRow.status }}"
  }]
}

Willst du automatisierte E-Mail-Workflows statt manueller Klicks? Schau dir unseren Workflow-Automation-Service an.

Schritt 4: Umsatz-Metriken hinzufügen (Charts)

Ops-Teams müssen Trends sehen, nicht nur Rohdaten.

Tägliches-Umsatz-Chart:

Line Chart-Komponente über die Tabelle ziehen. Die ältere Komponente namens “Chart” ist laut Retool Legacy, nimm die neueren Chart-Komponenten (Charts-Guide)
Query getDailyRevenue erstellen:

SELECT
  DATE(created_at) AS date,
  SUM(total_price) AS revenue,
  COUNT(*) AS order_count
FROM orders
WHERE
  created_at >= {{ startDate.value }}
  AND created_at <= {{ endDate.value }}
  AND status != 'cancelled'
GROUP BY DATE(created_at)
ORDER BY date ASC;

Chart konfigurieren:
- Data source: {{ getDailyRevenue.data }}
- X-Achse: Spalte date
- Y-Achse: Spalte revenue
- Titel: “Täglicher Umsatz”

Metrik-Karten (KPIs):

3 Statistic-Komponenten nebeneinander ziehen
Konfigurieren:
- Gesamt-Bestellungen: {{ getOrders.data.length }}
- Gesamt-Umsatz: {{ getOrders.data.reduce((sum, row) => sum + row.total_price, 0) }} mit Format Currency
- Durchschn. Bestellwert: {{ getOrders.data.reduce((sum, row) => sum + row.total_price, 0) / getOrders.data.length }} mit Format Currency

Schritt 5: Zugangskontrolle hinzufügen (rollenbasierte Berechtigungen)

Verschiedene Teams brauchen verschiedene Zugangslevel.

User-Gruppen erstellen:

Geh zu Settings → Groups (Anleitung)
Gruppen erstellen:
- ops_team (View + Edit Orders)
- support_team (nur View)
- admin (Full Access)

Eigene Gruppen und Rechte pro App gibt es laut Retool erst ab dem Business-Plan. Auf Free und Team existieren nur die Standardgruppen “All Users” und “Admin”.

App-Berechtigungen setzen:

Öffne die Gruppe und weise die App mit einer der drei Stufen zu (Permission Levels): Use (App ausführen, kein Editor), Edit (App bauen und veröffentlichen) oder Own (zusätzlich Freigaben verwalten)
Setzen:
- ops_team: Use
- support_team: Use, zusätzlich den “Als versendet markieren”-Button für diese Gruppe verstecken
- admin: Own

Sensible Daten verstecken:

Das Objekt current_user liefert die Gruppen des angemeldeten Users als Liste von Objekten mit id und name. In der Spalte für Kunden-E-Mails hinterlegst du als Mapped Value:

{{ current_user.groups.map(g => g.name).includes('admin') ? currentRow.customer_email : '***@***' }}

Denselben Ausdruck (negiert) setzt du in die Hidden-Eigenschaft des Versand-Buttons, damit support_team ihn nicht sieht.

Brauchst du Enterprise-Grade Security-Controls? Wir implementieren SSO, Audit Logs und Field-Level-Encryption. Beachte dabei: SAML- und OIDC-SSO bietet Retool laut Preisseite nur auf Enterprise an, die Einrichtung beschreibt der SSO-Quickstart.

Schritt 6: Live-APIs verbinden (Stripe, Shopify, etc.)

Die meisten Dashboards brauchen Daten aus mehreren Quellen.

Stripe-Payment-Daten hinzufügen:

Query getStripePayments mit der Stripe-Ressource erstellen, Method GET, Pfad:

/charges?limit=100&created[gte]={{ moment(startDate.value).unix() }}

Stripe’s Charges-Liste akzeptiert limit zwischen 1 und 100 (Standard 10) und filtert mit created[gte] nach Unix-Zeitstempel in Sekunden. Die Antwort liefert die Charges im Feld data und meldet mit has_more, ob du mit starting_after weiterblättern musst.

In einer separaten Tabelle anzeigen

Mit Bestelldaten joinen:

Leg eine JavaScript-Query joinPayments an:

const orders = getOrders.data;
const payments = getStripePayments.data.data;

return orders.map(order => ({
  ...order,
  stripe_charge_id: payments.find(p => p.metadata.order_id === String(order.id))?.id,
  payment_method: payments.find(p => p.metadata.order_id === String(order.id))?.payment_method_details?.type
}));

Das setzt voraus, dass dein Checkout beim Anlegen des Charges die Bestell-ID in metadata.order_id schreibt. Stripe speichert Metadata als Strings, daher der Vergleich mit String(order.id).

Production-Deployment-Checkliste

Bevor du mit deinem Team teilst:

Mit Read-Only-DB-User testen: Niemals Admin-Credentials nutzen
Error-Handling hinzufügen: Für jede Query einen Failure-Handler mit verständlicher Fehlermeldung
Query-Timeouts prüfen: Retool bricht Queries nach 10 Sekunden ab, auf Retool Cloud lässt sich das auf höchstens 120 Sekunden erhöhen, self-hosted per Umgebungsvariable. Queries, die länger brauchen, gehören optimiert
Loading-States hinzufügen: Spinner während Daten laden anzeigen
Queries optimieren: Indexes auf gefilterte Spalten hinzufügen (created_at, status)
Monitoring aufsetzen: Query-Performance und Error-Rates tracken
Für Ops-Team dokumentieren: Kurzes “How to Use”-Dokument erstellen
Auf Custom Domain deployen: dashboard.yourcompany.com statt yourcompany.retool.com. Auf Retool Cloud richtest du das unter Settings → Branding mit einem CNAME auf custom-domain.retool.com ein (Anleitung). Branding führt die Preisseite ab dem Business-Plan

Brauchst du Hilfe mit Production-Monitoring? Wir setzen Alerts für langsame Queries und Downtime auf.

Advanced: Multi-Tab-Dashboards

Echte interne Tools brauchen mehrere Views:

Tabs hinzufügen:

Tabs-Komponente ziehen
Tabs erstellen:
- Bestellungen (deine aktuelle View)
- Inventar (Low-Stock-Alerts)
- Kunden (Support-Ticket-Historie)
- Analytics (Kohorten-Analyse, Retention)

Inventar-Tab-Beispiel:

Query getLowStockItems:

SELECT
  p.id,
  p.name,
  p.sku,
  i.quantity_available,
  i.quantity_reserved,
  i.reorder_threshold
FROM products p
JOIN inventory i ON p.id = i.product_id
WHERE i.quantity_available < i.reorder_threshold
ORDER BY (i.quantity_available - i.reorder_threshold) ASC;

In einer Tabelle mit farbcodierten Lagerbestandsleveln anzeigen (rot = ausverkauft, gelb = niedrig, grün = gut).

Häufige Fallstricke (und wie wir sie beheben)

Fallstrick 1: Produktions-DB-Credentials nutzen Immer Read-Only-User erstellen. Write-Operationen bekommen einen eigenen User mit minimalen Rechten oder laufen durch einen API-Layer mit Validierung.

Fallstrick 2: N+1-Query-Probleme Nicht in Tabellenzeilen-Renders querien. Alle Daten vorab mit JOINs fetchen.

Fallstrick 3: Kein Query-Result-Caching Für teure Queries ohne Echtzeitbedarf im Query-Editor unter Advanced die Option Cache the results of this query aktivieren und die Dauer in Sekunden angeben, zum Beispiel 3600 für eine Stunde (Caching). Der Cache gilt standardmäßig für alle User der Organisation.

Fallstrick 4: Werte hardcoden Variablen für alles nutzen: API-Keys in Resources, Filter in Components, nicht in Raw Queries.

Fallstrick 5: Mobile-User ignorieren Retool-Dashboards sind Desktop-first. Für Mobile-Zugriff Retool Mobile nutzen, das native iOS- und Android-Apps baut und laut Preisseite auf allen Plänen enthalten ist.

Retool vs. Tableau: Der echte Vergleich

Feature	Tableau	Retool
Preis pro User und Monat	Standard: Creator 75 $, Explorer 42 $, Viewer 15 $, jährlich abgerechnet	Team: Builder 9 €, interner User 5 €, jährlich abgerechnet, Free bis 5 User
Datenverbindung	Konnektoren zu Datenquellen	Direkte DB-Queries und REST/GraphQL-APIs
Customization	Charts, Tabellen, Dashboards	Beliebige Komponenten, JavaScript, Full CRUD
Schreibaktionen	Nicht vorgesehen	Native (mit Permission-Controls)
Zugriff pro App	Rollen Creator, Explorer, Viewer	Stufen Use, Edit, Own je Gruppe (eigene Gruppen ab Business)
Self-Hosting	Tableau Server zu denselben Listenpreisen	Auf allen Plänen, Enterprise für unbegrenzte User und SSO

Für mehr Details schau dir unsere Tableau-Vergleichsseite an.

Professionelle Hilfe benötigt?

Diese Dashboard-Architektur ist getestet für Operations-, Support-, Sales- und Finance-Teams. Unser Custom-Dashboard-Service umfasst:

Requirements Gathering: Dein Team interviewen, um exakte Workflow-Bedürfnisse zu verstehen
Multi-Source-Integration: DBs + APIs + Spreadsheets in einem Dashboard verbinden
Custom Business Logic: Komplexe Berechnungen, Forecasting, Anomalieerkennung
Access-Control-Setup: SSO, rollenbasierte Berechtigungen, Audit-Logging
Performance-Optimierung: Query-Tuning, Caching-Strategien, Lazy Loading
Team-Training: Deinem Ops-Team beibringen, Dashboards selbst zu bearbeiten

Was du sparst, hängt von deiner heutigen Lizenz ab. Rechne es mit den oben verlinkten Preislisten für deine User-Zahl durch, wir helfen gern dabei.

Buche eine kostenlose 30-minütige Dashboard-Planungssession: Hier Termin vereinbaren

Nächster Ratgeber

Willst du Retool mit Snowflake oder BigQuery verbinden? Schau dir unseren Guide zu Data-Warehouse-Dashboards mit Retool + dbt bauen an.

Custom Dashboard mit Retool bauen (besser als Tableau)