Custom Dashboard mit Retool bauen (besser als Tableau)

Warum Tableau Ihr Ops-Team in den Bankrott treibt

Ihr Operations-Team braucht Echtzeit-Dashboards zur Verwaltung von Bestellungen, Inventar und Kundensupport. Tableau verspricht “Business Intelligence”, verlangt aber 70€/User/Monat (840€/Jahr) und benötigt einen Datenanalysten, um jede View zu bauen. Schlimmer noch: Es sperrt Ihre Daten in proprietären Extracts, die bei Schema-Änderungen kaputtgehen.

Wir haben 30+ Unternehmen von Tableau zu Custom Dashboards über unseren Dashboards-Service migriert. Typisches Ergebnis? 10.000€+/Jahr gespart bei Lizenzierung und 10x schnellere Iteration, weil Ihr Ops-Team Views selbst bearbeiten kann.

Anders als starre Tableau-Dashboards, die Data-Warehouse-ETL-Pipelines benötigen, verbindet sich Retool direkt mit Ihrer Produktions-Datenbank mit Read-Only-Queries-kein Daten-Kopieren nötig.

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

Hier ist die produktionsreife 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, etc.
REST-API-Integration: Direkt mit Stripe, Shopify, HubSpot verbinden
Zugangskontrolle: Rollenbasierte Berechtigungen out-of-the-box
Self-Hosted-Option: Auf Ihrer Infrastruktur ausführen (kein Vendor Lock-in)

Kostenvergleich:

Tableau: 70€/User/Monat = 840€/Jahr × 10 User = 8.400€/Jahr
Retool: 10€/User/Monat = 120€/Jahr × 10 User = 1.200€/Jahr
Ersparnis: 7.200€/Jahr (und Sie können nach Jahr 1 kostenlos self-hosten)

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

Option A: Retool Cloud (am schnellsten)

Gehen Sie zu retool.com und registrieren sich
Wählen Sie “Start with free plan” (5 User, unbegrenzt Apps)
Diesen Abschnitt überspringen

Option B: Self-Hosted (empfohlen für Production)

# Retool auf Ihrem Server ausführen (Docker erforderlich)
git clone https://github.com/tryretool/retool-onpremise.git
cd retool-onpremise

# Lizenzschlüssel generieren (Retool für kostenlose Self-Hosted-Lizenz kontaktieren)
# Zu docker.env hinzufügen:
# LICENSE_KEY=your-license-key

# Retool starten
docker-compose up -d

# Zugriff unter http://localhost:3000

Pro-Tipp: Self-Hosting bedeutet keine Per-User-Gebühren nach dem ersten Jahr. Sie zahlen nur für Infrastruktur (20-50€/Monat auf AWS/GCP).

Schritt 2: Datenquellen verbinden

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

PostgreSQL verbinden:

In Retool, gehen Sie zu Resources → Create New
Wählen Sie PostgreSQL

Verbindungsdetails eingeben:

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

Klicken Sie Test connection → Save

KRITISCH: Read-Only-Credentials nutzen

-- Read-Only-User in Ihrer PostgreSQL-Datenbank erstellen
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;

-- Auto-Grant SELECT auf zukünftige Tabellen
ALTER DEFAULT PRIVILEGES IN SCHEMA public
  GRANT SELECT ON TABLES TO retool_readonly;

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

Gehen Sie zu Resources → Create New → REST API
Base-URL eingeben: https://api.stripe.com/v1
Authentifizierung hinzufügen:
- Type: Bearer Token
- Token: sk_live_your_stripe_key
Als “Stripe API” speichern

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

Schritt 3: Ihr erstes Dashboard bauen (Order Management)

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

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, klicken Sie Create → App
Nennen Sie es “Order Dashboard”
Wählen Sie “Desktop”-Layout

Bestellliste hinzufügen (Table Component)

Table-Komponente auf Canvas ziehen
Umbenennen zu orderTable
Klicken Sie New Query → Wählen Sie “PostgreSQL”-Ressource
Query schreiben:

-- query: getOrders
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 >= {{ dateRangePicker.value.start }}
  AND o.created_at <= {{ dateRangePicker.value.end }}
  AND ({{ statusFilter.value }} = 'all' OR o.status = {{ statusFilter.value }})
GROUP BY o.id, c.id
ORDER BY o.created_at DESC
LIMIT 100;

Data source für Tabelle setzen: {{ getOrders.data }}
Spalten konfigurieren:
- id-Spalte verstecken
- created_at als Datum formatieren: {{ moment(currentRow.created_at).format('D. MMM YYYY HH:mm') }}
- total_price als Währung formatieren: {{ currentRow.total_price.toFixed(2) + '€' }}
- Badge für status hinzufügen: Konditionale Farbe (grün = erfüllt, gelb = ausstehend, rot = storniert)

Filter hinzufügen

Datumsbereich-Picker:

Date Range Picker über Tabelle ziehen
Umbenennen zu dateRangePicker
Default setzen: Letzte 7 Tage
“Run queries automatically on change” aktivieren

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 zur rechten Bildschirmseite ziehen
Umbenennen zu orderDetailsPanel
Sichtbarkeit setzen: {{ orderTable.selectedRow !== null }}
In 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 }}€

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 Details-Panel ziehen
Label: “Als versendet markieren”
Click → New Query → Type: PostgreSQL
Query:

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

Nach Erfolg → Trigger getOrders zum Aktualisieren der Tabelle
Erfolgsbenachrichtigung anzeigen: "Bestellung #{{ orderTable.selectedRow.order_number }} als versendet markiert"

“Kunde mailen”-Button:

Weiteren Button hinzufügen
Label: “Kunde mailen”
Click → New Query → Type: REST API
Zürst SendGrid-Ressource erstellen (oder SMTP nutzen):

// query: sendEmail
// Method: POST
// URL: https://api.sendgrid.com/v3/mail/send
// Headers: { "Authorization": "Bearer {{ sendgridKey }}" }
// Body:
{
  "personalizations": [{
    "to": [{"email": "{{ orderTable.selectedRow.customer_email }}"}],
    "subject": "Ihre Bestellung #{{ orderTable.selectedRow.order_number }} wurde aktualisiert"
  }],
  "from": {"email": "support@yourstore.com"},
  "content": [{
    "type": "text/html",
    "value": "<p>Hallo {{ orderTable.selectedRow.customer_name }},</p><p>Ihr Bestellstatus: {{ orderTable.selectedRow.status }}</p>"
  }]
}

Wollen Sie automatisierte E-Mail-Workflows statt manueller Klicks? Schauen Sie sich 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:

Chart-Komponente über Tabelle ziehen
Query erstellen:

-- query: getDailyRevenue
SELECT 
  DATE(created_at) AS date,
  SUM(total_price) AS revenue,
  COUNT(*) AS order_count
FROM orders
WHERE 
  created_at >= {{ dateRangePicker.value.start }}
  AND created_at <= {{ dateRangePicker.value.end }}
  AND status != 'cancelled'
GROUP BY DATE(created_at)
ORDER BY date ASC;

Chart konfigurieren:
- Type: Line Chart
- X-Achse: {{ getDailyRevenue.data.map(row => row.date) }}
- Y-Achse: {{ getDailyRevenue.data.map(row => row.revenue) }}
- Label: “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).toFixed(2) }}€
- Durchschn. Bestellwert: {{ (getOrders.data.reduce((sum, row) => sum + row.total_price, 0) / getOrders.data.length).toFixed(2) }}€

Schritt 5: Zugangskontrolle hinzufügen (rollenbasierte Berechtigungen)

Verschiedene Teams brauchen verschiedene Zugangslevel.

User-Gruppen erstellen:

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

App-Berechtigungen setzen:

In Ihrer App, gehen Sie zu Settings → Permissions
Setzen:
- ops_team: Kann App nutzen
- support_team: Kann App nutzen (aber “Als versendet markieren”-Button für diese Gruppe deaktivieren)
- admin: Full Access

Sensible Daten verstecken:

// In Tabellenspalten, Kunden-E-Mails konditional verstecken:
{{ currentUser.groups.includes('admin') ? currentRow.customer_email : '***@***' }}

Brauchen Sie Enterprise-Grade Security-Controls? Wir implementieren SSO, Audit Logs und Field-Level-Encryption.

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

Die meisten Dashboards brauchen Daten aus mehreren Quellen.

Stripe-Payment-Daten hinzufügen:

Query mit Stripe-Ressource erstellen:

// query: getStripePayments
// Method: GET
// URL: /charges?limit=100&created[gte]={{ Math.floor(dateRangePicker.value.start / 1000) }}

// In separater Tabelle anzeigen

Mit Bestelldaten joinen:

// In einer JavaScript-Query:
const orders = {{ getOrders.data }};
const payments = {{ getStripePayments.data.data }};

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

Production-Deployment-Checkliste

Bevor Sie mit Ihrem Team teilen:

Mit Read-Only-DB-User testen: Niemals Admin-Credentials nutzen
Error-Handling hinzufügen: Alle Queries in Try-Catch mit benutzerfreundlichen Fehlermeldungen
Query-Timeouts setzen: Long-running Queries verhindern (30 Sekunden Max)
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 nutzen

Brauchen Sie 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 (Ihre 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 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 sollten durch API-Layer mit Validierung gehen.

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

Fallstrick 3: Kein Query-Result-Caching Retool’s Query-Caching (5-Minuten-Default) für teure Queries aktivieren, die keine Echtzeitdaten brauchen.

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 separate Mobile-App bauen oder Retool Mobile nutzen.

Retool vs. Tableau: Der echte Vergleich

Feature	Tableau	Retool
Kosten/User/Jahr	840€	120€ (oder 0€ self-hosted)
Datenverbindung	Benötigt ETL/Extracts	Direkte DB-Queries
Build-Zeit	2-3 Tage mit Analyst	4-6 Stunden Self-Service
Customization	Begrenzt auf Charts/Tabellen	Full CRUD-Operationen
Echtzeitdaten	Benötigt Extract-Refresh	Immer live
Write-Operationen	Nicht supported	Native (mit Permission-Controls)
API-Integrationen	Begrenzte Konnektoren	Jede REST/GraphQL-API
Self-Hosting	Nur Enterprise (4.000€+)	In Free Tier enthalten

Für mehr Details schauen Sie sich 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: Ihr 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: Ihrem Ops-Team beibringen, Dashboards selbst zu bearbeiten

Die meisten Kunden launchen ihr erstes Dashboard in 2 Wochen und sparen 10.000€+/Jahr bei BI-Tool-Lizenzierung.

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

Nächster Ratgeber

Wollen Sie Retool mit Snowflake oder BigQuery verbinden? Schauen Sie sich unseren Guide zu Data-Warehouse-Dashboards mit Retool + dbt bauen an.