---
# === IDENTITY ===
id: software/startup-dashboard/data-integration-architecture/2026
canonical_question: "How do I integrate data sources — CRM, ad platforms, analytics, banking, email into a unified dashboard?"
aliases:
  - "Startup data integration architecture for unified dashboard"
  - "How to connect CRM Stripe GA4 ad platforms into one dashboard"
  - "Airbyte vs Fivetran for startup data pipeline"
  - "ETL ELT pipeline setup for startup metrics dashboard"
entity_type: execution_recipe
domain: software > startup-dashboard > data integration architecture
region: global
jurisdiction: global
temporal_scope: 2025-2026

# === VERIFICATION ===
last_verified: 2026-03-12
confidence: 0.88
version: 1.0
first_published: 2026-03-12

# === TEMPORAL VALIDITY ===
temporal_validity:
  status: evolving
  last_breaking_change: "Airbyte Cloud launched agent-native connectors (real-time fetch SDKs) in late 2025; Fivetran added Hybrid Deployment model in 2025; Google Analytics 4 data API v2 released mid-2025"
  next_review: 2026-09-08
  change_sensitivity: high

# === CONSTRAINTS ===
constraints:
  - "Airbyte Cloud free tier includes 10 credits/month (approximately 100K rows synced) — sufficient for early-stage startups with under $50K MRR"
  - "Fivetran pricing starts at $1/credit with minimum spend — costs scale with data volume; expect $100-500/mo at Series A scale"
  - "Stripe API rate limit: 100 read requests/second in live mode — pace bulk historical syncs accordingly"
  - "Google Ads API requires a developer token and Manager Account (MCC) — approval takes 3-5 business days"
  - "Banking data via Plaid costs $0.30-$3.00 per connection/month — use only for active accounts, disconnect dormant ones"
  - "Data warehouse storage costs compound: BigQuery charges $5/TB stored per month, Snowflake charges $23-40/TB compressed — monitor warehouse growth quarterly"

# === SKIP CONDITIONS ===
skip_this_unit_if:
  - condition: "User needs a pre-built dashboard, not a data pipeline"
    use_instead: "software/startup-dashboard/dashboard-template-library/2026"
  - condition: "User needs only CRM setup, not multi-source integration"
    use_instead: "business/startup-sales/crm-setup-guide/2026"
  - condition: "User needs enterprise ERP integration, not startup-scale"
    use_instead: "Browse knowledgelib.io's ERP integration units for enterprise data integration patterns"

# === AGENT HINTS ===
inputs_needed:
  - key: data_sources
    question: "Which data sources need to be integrated?"
    type: choice
    options: ["CRM (HubSpot/Salesforce)", "Payments (Stripe/Paddle)", "Analytics (GA4/Mixpanel)", "Ads (Google/Meta)", "Banking (Plaid)", "Email (Mailchimp/Sendgrid)", "All of the above"]
  - key: technical_skill
    question: "What is the user's technical skill level?"
    type: choice
    options: ["non-technical (no-code only)", "semi-technical (can edit code)", "developer (can write code)"]
  - key: budget_for_tools
    question: "What's the tool/API budget?"
    type: choice
    options: ["free tier only", "up to $100/month", "up to $500/month", "no limit"]
  - key: data_warehouse
    question: "Which data warehouse to use?"
    type: choice
    options: ["Supabase (Postgres)", "BigQuery", "Snowflake", "DuckDB (local)", "no preference — auto-select"]

# === EXECUTION METADATA ===
execution:
  required_inputs:
    - name: "List of data sources with access credentials"
      source: "user"
      format: "API keys, OAuth tokens, or account credentials for each data source"
    - name: "KPI definitions and required metrics"
      source: "business/startup-metrics/startup-kpi-framework-by-stage/2026"
      format: "list of metrics mapped to data sources (e.g., MRR from Stripe, CAC from ad platforms)"
  outputs:
    - name: "Configured data pipeline"
      format: "Airbyte/Fivetran connections syncing to warehouse"
      description: "All data sources connected and syncing on schedule to a central data warehouse"
    - name: "Unified data warehouse"
      format: "PostgreSQL/BigQuery/Snowflake database"
      description: "Normalized tables with clean joins between CRM contacts, payments, analytics events, and ad spend"
    - name: "Data transformation layer"
      format: "SQL views or dbt models"
      description: "Business-ready tables: daily_mrr, customer_ltv, channel_attribution, cohort_metrics"
  tools_required:
    - name: "Airbyte"
      purpose: "ELT data pipeline — extract from sources, load to warehouse"
      tier: "free"
      cost: "$0 (self-hosted open-source), $0 for 10 credits/mo (Cloud)"
      alternatives: ["Fivetran ($1/credit)", "Hevo ($249/mo)", "Stitch Data"]
    - name: "Supabase"
      purpose: "PostgreSQL data warehouse for small-scale startups"
      tier: "free"
      cost: "$0 (500MB), $25/mo (8GB)"
      alternatives: ["BigQuery ($5/TB/mo)", "Snowflake ($2/credit)", "DuckDB (free, local)"]
    - name: "dbt"
      purpose: "Data transformation — SQL-based modeling layer"
      tier: "free"
      cost: "$0 (dbt Core open-source), $100+/mo (dbt Cloud)"
      alternatives: ["SQL views (manual)", "Metabase custom questions"]
    - name: "Metabase"
      purpose: "Dashboard visualization on top of the warehouse"
      tier: "free"
      cost: "$0 (open-source self-hosted), $85/mo (Cloud for 5 users)"
      alternatives: ["Retool ($0-10/user/mo)", "Looker Studio (free)", "Preset/Superset"]
  credentials_needed:
    - service: "Stripe"
      type: "API key (restricted, read-only)"
      where_to_get: "https://dashboard.stripe.com/apikeys"
      free_tier_limits: "100 requests/second"
    - service: "Google Analytics 4"
      type: "Service account JSON key"
      where_to_get: "https://console.cloud.google.com/iam-admin/serviceaccounts"
      free_tier_limits: "10,000 requests/day per property"
    - service: "HubSpot"
      type: "Private app access token"
      where_to_get: "https://app.hubspot.com/settings/private-apps"
      free_tier_limits: "100 requests per 10 seconds"
    - service: "Plaid"
      type: "API key + secret"
      where_to_get: "https://dashboard.plaid.com/team/keys"
      free_tier_limits: "100 items (connections) in development mode"
  estimated_duration: "6-12 hours for basic pipeline, 2-4 weeks for full transformation layer"
  estimated_cost: "$0 (free tier) to $200-500/month (production scale)"

# === DISTRIBUTION ===
canonical_source: "https://knowledgelib.io/software/startup-dashboard/data-integration-architecture/2026"
suggested_citation: "Source: knowledgelib.io — AI Knowledge Library (verified 2026-03-12)"

# === RELATED UNITS ===
related_kos:
  depends_on:
    - id: "business/startup-metrics/startup-kpi-framework-by-stage/2026"
      label: "KPI definitions that determine which data to collect"
    - id: "business/startup-sales/crm-setup-guide/2026"
      label: "CRM must be configured before integration"
  feeds_into:
    - id: "software/startup-dashboard/dashboard-template-library/2026"
      label: "Templates consume the unified data warehouse"
    - id: "software/startup-dashboard/notification-automation-rules/2026"
      label: "Alerts trigger based on integrated data"
    - id: "business/startup-metrics/investor-reporting-template/2026"
      label: "Investor reports pull from unified data"
  related_to:
    - id: "business/startup-metrics/dashboard-design-for-startups/2026"
      label: "Dashboard design patterns"
  alternative_to:
    - id: "business/startup-metrics/startup-kpi-framework-by-stage/2026"
      label: "Manual metric tracking alternative"

# === SOURCES ===
sources:
  - id: src1
    title: "What is Data Integration Architecture: Diagram & Best Practices in 2026"
    author: Airbyte
    url: https://airbyte.com/data-engineering-resources/data-integration-architecture
    type: official_docs
    published: 2025-10-01
    reliability: authoritative
  - id: src2
    title: "Fivetran vs Hevo vs Matillion vs Informatica vs Rivery vs Airbyte"
    author: Airbyte
    url: https://airbyte.com/data-engineering-resources/compare-data-management-platforms
    type: industry_analysis
    published: 2025-09-01
    reliability: high
  - id: src3
    title: "Data integration tools compared: Fivetran, Airbyte, DLT, dbt"
    author: Xenoss
    url: https://xenoss.io/blog/data-integration-platforms
    type: industry_analysis
    published: 2025-06-01
    reliability: high
  - id: src4
    title: "Stripe Connector Documentation"
    author: Airbyte
    url: https://docs.airbyte.com/integrations/sources/stripe
    type: official_docs
    published: 2025-11-01
    reliability: authoritative
  - id: src5
    title: "Best SaaS Data Integration Tools in 2026"
    author: Airbyte
    url: https://airbyte.com/data-engineering-resources/saas-data-integration
    type: industry_report
    published: 2025-12-01
    reliability: high
  - id: src6
    title: "Airbyte Architecture and Use Cases: A Practical Guide"
    author: BIX Tech
    url: https://bix-tech.com/airbyte-architecture-and-use-cases-a-practical-guide-to-modern-data-integration/
    type: technical_guide
    published: 2025-08-01
    reliability: high
  - id: src7
    title: "Top Data Integration Techniques for 2025"
    author: Airbyte
    url: https://airbyte.com/data-engineering-resources/data-integration-techniques
    type: official_docs
    published: 2025-07-01
    reliability: authoritative
---

# Data Integration Architecture for Startup Dashboards

## Purpose

This recipe builds a unified data pipeline that connects CRM, payment processing, analytics, advertising, banking, and email platforms into a single data warehouse, with a transformation layer that produces business-ready metrics tables. The output is a fully syncing data pipeline where MRR, CAC, LTV, retention, and channel attribution are computed automatically from raw source data — eliminating manual spreadsheet consolidation. [src1]

## Prerequisites

- [ ] **API credentials for each data source** — Stripe API key, GA4 service account, HubSpot private app token, ad platform credentials
- [ ] **KPI definitions** from `metrics framework` — [Startup KPI Framework by Stage](/business/startup-metrics/startup-kpi-framework-by-stage/2026)
- [ ] **CRM configured with pipeline stages** — [CRM Setup Guide](/business/startup-sales/crm-setup-guide/2026)
- [ ] **Data warehouse selected** — Supabase (Postgres), BigQuery, or Snowflake account ready
- [ ] **Docker installed** (if self-hosting Airbyte) — [Docker Desktop](https://www.docker.com/products/docker-desktop/)

## Constraints

- Airbyte Cloud free tier: 10 credits/month (~100K rows). Self-hosted open-source is unlimited but requires Docker and ~4GB RAM. [src2]
- Fivetran costs scale with data volume at $1/credit — budget $100-500/mo at Series A scale. For pre-revenue startups, Airbyte self-hosted is more cost-effective.
- Stripe API allows 100 read requests/second — pace historical backfills to avoid throttling. Initial sync of 2+ years of data may take 30-60 minutes. [src4]
- Google Ads API requires a developer token with Standard access — apply through Google Ads API Center, approval takes 3-5 business days.
- Banking data via Plaid costs $0.30-$3/connection/month in production — use development mode (free, 100 items) for testing.
- All data pipelines introduce latency: batch syncs (hourly/daily) mean dashboards show data 1-24 hours behind real-time. Real-time is possible but costs 3-5x more.

## Tool Selection Decision

```
Which path?
├── Non-technical AND budget = free
│   └── PATH A: Zapier + Google Sheets — basic integration, limited scale
├── Semi-technical AND budget = free
│   └── PATH B: Airbyte (self-hosted) + Supabase + Metabase — full pipeline, $0
├── Developer AND budget = $0-100/mo
│   └── PATH C: Airbyte Cloud + Supabase + dbt + Metabase — managed pipeline
└── Developer AND budget = $100-500/mo
    └── PATH D: Fivetran + BigQuery/Snowflake + dbt Cloud + Looker Studio — enterprise-grade
```

| Path | Tools | Cost | Setup Time | Scalability |
|------|-------|------|-----------|------------|
| A: No-Code | Zapier + Google Sheets | $0-20/mo | 2-4 hours | Low (breaks at 1K rows/source) |
| B: Self-Hosted | Airbyte OSS + Supabase + Metabase | $0 (+ server) | 8-12 hours | Medium (10M+ rows) |
| C: Managed Free | Airbyte Cloud + Supabase + dbt + Metabase | $0-25/mo | 4-8 hours | Medium-High |
| D: Enterprise | Fivetran + BigQuery + dbt Cloud | $200-500/mo | 6-12 hours | Very High (billions of rows) |

## Execution Flow

### Step 1: Set Up the Data Warehouse

**Duration**: 30-60 minutes
**Tool**: Supabase (Path B/C) or BigQuery (Path D)

**Path B/C — Supabase**:

Create a dedicated schema for raw data and another for transformed data:

```sql
-- Create schemas for data pipeline
CREATE SCHEMA IF NOT EXISTS raw_data;
CREATE SCHEMA IF NOT EXISTS analytics;

-- Grant Airbyte user access to raw_data schema
CREATE ROLE airbyte_user WITH LOGIN PASSWORD 'secure_password_here';
GRANT ALL ON SCHEMA raw_data TO airbyte_user;
GRANT USAGE ON SCHEMA analytics TO airbyte_user;

-- Create analytics tables for business metrics
CREATE TABLE analytics.daily_mrr (
  date DATE PRIMARY KEY,
  mrr_cents BIGINT NOT NULL,
  new_mrr_cents BIGINT DEFAULT 0,
  expansion_mrr_cents BIGINT DEFAULT 0,
  churned_mrr_cents BIGINT DEFAULT 0,
  active_subscriptions INTEGER,
  computed_at TIMESTAMPTZ DEFAULT NOW()
);

CREATE TABLE analytics.customer_ltv (
  customer_id TEXT PRIMARY KEY,
  first_payment_date DATE,
  total_revenue_cents BIGINT,
  months_active INTEGER,
  ltv_cents BIGINT,
  acquisition_channel TEXT,
  computed_at TIMESTAMPTZ DEFAULT NOW()
);
```

**Verify**: Can connect to the database from Airbyte using the airbyte_user credentials.
**If failed**: Check Supabase connection pooler settings — use port 5432 for direct connections from Airbyte.

### Step 2: Configure Data Source Connections

**Duration**: 2-4 hours
**Tool**: Airbyte (Path B/C) or Fivetran (Path D)

Set up connectors for each data source. Priority order for startup dashboards:

1. **Stripe** (revenue data) — select streams: charges, subscriptions, customers, invoices, balance_transactions
2. **CRM (HubSpot)** — select: contacts, deals, companies, deal_pipelines
3. **Google Analytics 4** — select: active_users, sessions, conversions (key_events), page_views
4. **Ad platforms** — Google Ads: campaigns, ad_groups, ads, keywords; Meta Ads: campaigns, ad_sets, ads, insights
5. **Email (Mailchimp/Sendgrid)** — select: lists, campaigns, campaign_stats
6. **Banking (Plaid)** — select: transactions, accounts, balances

**Path B/C — Airbyte Configuration**:

```bash
# Self-hosted Airbyte setup (Path B)
git clone https://github.com/airbytehq/airbyte.git
cd airbyte
./run-ab-platform.sh

# Access UI at http://localhost:8000
# Default credentials: airbyte / password
```

For each connector: (1) Add source with API credentials; (2) Select destination (Postgres/Supabase); (3) Choose streams and sync mode (incremental preferred); (4) Set sync frequency (every 6 hours for most sources, daily for ad platforms).

**Verify**: Run a manual sync for Stripe connector — should complete in 5-15 minutes and show rows synced in Airbyte dashboard. Check `raw_data.stripe_subscriptions` table has records.
**If failed**: Check API key permissions (read-only scope). For HubSpot, verify the private app has CRM scopes (crm.objects.contacts.read, crm.objects.deals.read).

### Step 3: Build the Transformation Layer

**Duration**: 4-8 hours
**Tool**: dbt or SQL views

Transform raw data into business-ready metrics tables:

```sql
-- MRR calculation from Stripe subscriptions
CREATE OR REPLACE VIEW analytics.v_daily_mrr AS
SELECT
  date_trunc('day', s.current_period_start)::date AS date,
  SUM(CASE WHEN s.status = 'active' THEN si.amount ELSE 0 END) AS mrr_cents,
  COUNT(DISTINCT CASE WHEN s.status = 'active' THEN s.customer END) AS active_subscriptions
FROM raw_data.stripe_subscriptions s
JOIN raw_data.stripe_subscription_items si ON s.id = si.subscription
GROUP BY 1;

-- Customer LTV from Stripe charges
CREATE OR REPLACE VIEW analytics.v_customer_ltv AS
SELECT
  c.customer AS customer_id,
  MIN(c.created)::date AS first_payment_date,
  SUM(c.amount) AS total_revenue_cents,
  COUNT(DISTINCT date_trunc('month', c.created)) AS months_active,
  SUM(c.amount) AS ltv_cents
FROM raw_data.stripe_charges c
WHERE c.status = 'succeeded' AND c.refunded = false
GROUP BY 1;

-- CAC by channel from ad platform spend + CRM attribution
CREATE OR REPLACE VIEW analytics.v_channel_cac AS
SELECT
  COALESCE(d.source, 'organic') AS channel,
  date_trunc('month', d.close_date)::date AS month,
  COUNT(DISTINCT d.id) AS customers_acquired,
  SUM(ad.spend_cents) AS total_spend_cents,
  CASE WHEN COUNT(DISTINCT d.id) > 0
    THEN SUM(ad.spend_cents) / COUNT(DISTINCT d.id)
    ELSE 0
  END AS cac_cents
FROM raw_data.hubspot_deals d
LEFT JOIN analytics.v_monthly_ad_spend ad
  ON ad.channel = d.source AND ad.month = date_trunc('month', d.close_date)
WHERE d.stage = 'closed_won'
GROUP BY 1, 2;
```

**Verify**: `SELECT * FROM analytics.v_daily_mrr ORDER BY date DESC LIMIT 7` returns the last 7 days of MRR data matching Stripe dashboard.
**If failed**: Check raw data schema for column name mismatches — Airbyte may use different names than native APIs.

### Step 4: Set Up Incremental Sync Schedules

**Duration**: 30-60 minutes
**Tool**: Airbyte/Fivetran scheduler

Configure sync frequencies by data criticality:

| Source | Frequency | Mode | Rationale |
|--------|-----------|------|-----------|
| Stripe | Every 6 hours | Incremental (append) | Revenue data needs same-day accuracy |
| CRM (HubSpot) | Every 6 hours | Incremental (dedup) | Deal stage changes need timely reflection |
| GA4 | Daily (6 AM) | Full refresh | GA4 data finalizes 24-48 hours after collection |
| Google Ads | Daily (7 AM) | Incremental | Ad spend finalizes end of day |
| Meta Ads | Daily (7 AM) | Incremental | Ad spend finalizes end of day |
| Banking (Plaid) | Daily (8 AM) | Incremental | Transaction data updates once daily |
| Email (Mailchimp) | Daily (9 AM) | Incremental | Campaign stats finalize within 24 hours |

**Verify**: Check Airbyte/Fivetran sync history — each source should show successful syncs with row counts.
**If failed**: Enable sync alerts (email or Slack) for failed syncs. Most failures are auth token expirations — set calendar reminders for token renewals.

### Step 5: Connect Visualization Layer

**Duration**: 2-4 hours
**Tool**: Metabase (Path B/C) or Looker Studio (Path D)

Connect the dashboard tool to the data warehouse and build initial views:

```bash
# Self-hosted Metabase (Path B)
docker run -d -p 3000:3000 \
  -e MB_DB_TYPE=postgres \
  -e MB_DB_DBNAME=metabase \
  -e MB_DB_PORT=5432 \
  -e MB_DB_USER=metabase_user \
  -e MB_DB_PASS=secure_password \
  -e MB_DB_HOST=your-supabase-host \
  --name metabase metabase/metabase
```

Create these initial dashboard panels: (1) MRR trend (line chart from v_daily_mrr); (2) Customer LTV distribution (histogram from v_customer_ltv); (3) CAC by channel (bar chart from v_channel_cac); (4) Active subscriptions (number card); (5) Pipeline value (from CRM deals).

**Verify**: Dashboard loads in under 5 seconds with data matching the direct SQL query results.
**If failed**: Check Metabase database connection uses the analytics schema, not raw_data.

### Step 6: Data Quality Monitoring

**Duration**: 1-2 hours
**Tool**: SQL alerts or Metabase alerts

Set up data quality checks that run after each sync:

```sql
-- Freshness check: alert if Stripe data is more than 12 hours stale
SELECT
  MAX(updated_at) AS last_sync,
  NOW() - MAX(updated_at) AS staleness,
  CASE WHEN NOW() - MAX(updated_at) > INTERVAL '12 hours'
    THEN 'STALE' ELSE 'FRESH' END AS status
FROM raw_data.stripe_charges;

-- Completeness check: alert if MRR drops to zero (likely sync failure)
SELECT date, mrr_cents
FROM analytics.v_daily_mrr
WHERE date = CURRENT_DATE AND mrr_cents = 0;

-- Consistency check: Stripe MRR should not drop >20% day-over-day
SELECT
  today.date,
  today.mrr_cents AS today_mrr,
  yesterday.mrr_cents AS yesterday_mrr,
  ROUND(100.0 * (today.mrr_cents - yesterday.mrr_cents) / NULLIF(yesterday.mrr_cents, 0), 1) AS pct_change
FROM analytics.v_daily_mrr today
JOIN analytics.v_daily_mrr yesterday ON yesterday.date = today.date - 1
WHERE today.date = CURRENT_DATE
  AND ABS(today.mrr_cents - yesterday.mrr_cents) > 0.2 * yesterday.mrr_cents;
```

**Verify**: Quality checks return no alerts when data is syncing correctly.
**If failed**: Investigate the specific source connector — most data quality issues trace back to sync failures or API changes.

## Output Schema

```json
{
  "output_type": "data_pipeline",
  "format": "configured pipeline + data warehouse + transformation layer",
  "components": [
    {"name": "source_connections", "type": "Airbyte/Fivetran configs", "description": "Connected sources syncing on schedule", "required": true},
    {"name": "raw_data_warehouse", "type": "PostgreSQL/BigQuery schema", "description": "Raw tables from all sources in raw_data schema", "required": true},
    {"name": "transformation_layer", "type": "SQL views or dbt models", "description": "Business-ready tables: daily_mrr, customer_ltv, channel_cac", "required": true},
    {"name": "data_quality_monitors", "type": "SQL alerts", "description": "Freshness, completeness, and consistency checks", "required": true},
    {"name": "visualization_connection", "type": "Metabase/Looker config", "description": "Dashboard tool connected to analytics schema", "required": true}
  ],
  "expected_table_count": "5-8 raw tables, 4-6 analytics views",
  "sync_frequency": "6-24 hours depending on source"
}
```

## Quality Benchmarks

| Quality Metric | Minimum Acceptable | Good | Excellent |
|---------------|-------------------|------|-----------|
| Sync success rate | > 90% | > 95% | > 99% |
| Data freshness (Stripe) | < 24 hours | < 12 hours | < 6 hours |
| MRR accuracy vs Stripe dashboard | Within 5% | Within 2% | Within 0.5% |
| Source coverage | 3+ sources | 5+ sources | 7+ sources |
| Data quality alerts firing | Weekly | Monthly | Quarterly |

**If below minimum**: Check sync logs for failures, verify API credentials are not expired, and confirm rate limits are not exceeded.

## Error Handling

| Error | Likely Cause | Recovery Action |
|-------|-------------|----------------|
| Sync failure: 401 Unauthorized | API key expired or revoked | Regenerate API key, update connector settings |
| Sync failure: 429 Rate Limited | Too many concurrent requests | Reduce sync frequency or add request throttling |
| Schema drift: column missing | Source API updated schema | Update Airbyte connector to latest version; map new columns |
| MRR calculation mismatch | Currency conversion or tax inclusion | Verify Stripe amounts are in cents and exclude taxes |
| Warehouse storage full | Raw data growing unchecked | Implement data retention policy — archive data older than 2 years |
| Slow dashboard queries | Missing indexes on analytics views | Add indexes on date and customer_id columns |

## Cost Breakdown

| Component | Free Tier | Growth ($50-200/mo) | Scale ($200-500/mo) |
|-----------|-----------|---------------------|---------------------|
| Data pipeline (Airbyte) | $0 (self-hosted or 10 credits) | $50-100/mo (Cloud) | $200-400/mo |
| Data warehouse (Supabase/BQ) | $0 (500MB/10GB) | $25-50/mo | $50-200/mo |
| Transformation (dbt) | $0 (Core) | $0 (Core) | $100/mo (Cloud) |
| Visualization (Metabase) | $0 (self-hosted) | $85/mo (Cloud) | $85-200/mo |
| Banking API (Plaid) | $0 (dev mode) | $10-30/mo | $30-100/mo |
| **Total** | **$0** | **$170-265/mo** | **$465-1,000/mo** |

## Anti-Patterns

### Wrong: Building Custom ETL Scripts Instead of Using Connectors
Writing custom Python scripts to extract data from each API. These scripts break on every API version change, lack error handling, and require ongoing maintenance. A startup engineering team typically spends 2-4 hours/month maintaining custom scripts per source. [src3]

### Correct: Use Managed Connectors with Custom Transforms
Use Airbyte or Fivetran for extraction and loading (600+ pre-built connectors with automatic schema handling). Write custom code only for the transformation layer where business logic is unique.

### Wrong: Syncing Everything in Real-Time
Setting all connectors to real-time sync when dashboards are only viewed daily. Real-time syncs cost 3-5x more in API calls and warehouse compute, with no benefit if the team checks metrics once a day. [src1]

### Correct: Match Sync Frequency to Decision Cadence
Revenue data (Stripe): every 6 hours. Ad spend: daily. Analytics: daily. Banking: daily. Only enable real-time for data that drives real-time decisions (e.g., fraud alerts).

## When This Matters

Use when a startup needs to combine data from 3+ sources into a single dashboard view. Required once the team stops being able to track metrics by manually checking individual tool dashboards. Typically becomes necessary between seed and Series A, when investor reporting demands consistent, auditable metrics.

## Related Units

- [Startup KPI Framework by Stage](/business/startup-metrics/startup-kpi-framework-by-stage/2026)
- [CRM Setup Guide](/business/startup-sales/crm-setup-guide/2026)
- [Dashboard Template Library](/software/startup-dashboard/dashboard-template-library/2026)
- [Notification Automation Rules](/software/startup-dashboard/notification-automation-rules/2026)
- [Investor Reporting Template](/business/startup-metrics/investor-reporting-template/2026)