← All postsBlog

The KPI dashboard we built entirely with agents

· Avery NXR

Every founder has at least one KPI dashboard they wish existed but never built. The data lives across multiple systems. Getting it into one view requires either expensive BI tooling, a data engineer, or weeks of manual SQL writing.

For Avery Software, we wanted a daily KPI view that pulled from: → Stripe (revenue, MRR, churn) → Mixpanel (product usage) → HubSpot (pipeline, deals) → GitHub (engineering velocity) → Linear (issue throughput) → Internal Postgres (custom metrics)

We didn't want to pay for Tableau, Looker, or Sigma. We didn't want to spend weeks on dbt + Metabase setup. We didn't want a dedicated data role yet.

So we built it with Avery NXR agents. Took about 6 hours total. Here's how.

The architecture

The dashboard isn't a single dashboard in the traditional sense. It's a daily email that lands in our inbox at 7 AM with the KPIs we care about.

Reasoning: we don't need real-time. We need daily awareness. Email is the surface that's already part of our morning routine. A dashboard webpage adds a step we'd forget to take.

The KPI email is composed by a single coordinator agent that pulls from multiple sub-agents, each handling one data source.

The agent structure

Coordinator agent: "Daily KPI digest"

Triggers: scheduled, every weekday at 6:45 AM.

Steps:

  1. Call Stripe sub-agent → get revenue metrics
  2. Call Mixpanel sub-agent → get product usage
  3. Call HubSpot sub-agent → get pipeline state
  4. Call GitHub sub-agent → get engineering throughput
  5. Call Linear sub-agent → get issue resolution data
  6. Call Postgres sub-agent → get custom metrics
  7. Compose summary email
  8. Send to founders' inboxes

The composition step uses an LLM call to write the summary in our preferred style (concise, with deltas vs. previous day/week, highlighting anything anomalous).

The sub-agents

Each sub-agent is small and focused. Here's a representative one:

Stripe sub-agent:

Connector: Stripe API key (one of the 48 API-key connectors)

Logic:

  1. Query Stripe API for yesterday's transactions
  2. Query for yesterday's new subscriptions
  3. Query for yesterday's cancellations
  4. Query for current MRR
  5. Calculate: net new MRR, gross new MRR, churn MRR, transaction volume
  6. Return structured data to coordinator

The sub-agent uses no LLM call for the data pulling — it's deterministic API queries. LLM only comes in at the composition step.

The other sub-agents work similarly. Each pulls its source, formats data, returns to coordinator.

What the daily email looks like

Roughly:

Daily KPI Digest — June 23, 2026
═══════════════════════════════════

REVENUE
→ Yesterday: $2,418 (▲ $214 vs. day-7-avg)
→ MRR: $42,917 (▲ $487 since last week)
→ New subscriptions: 8 (▲ 2)
→ Cancellations: 1 (Sarah's startup — context: ran out of runway, told us)

PRODUCT USAGE
→ DAU: 247 (▲ 4)
→ New signups: 31 (▲ 8 — see anomaly note)
→ Agent executions: 18,442 (▲ 1,237)
→ Anomaly note: signup spike correlates with HN comment thread yesterday

PIPELINE
→ Active deals: 47
→ Stalled (>14 days no activity): 6
→ Moving forward (advanced stage yesterday): 3
→ Recommended actions: ping the 6 stalled, especially [3 specific deals named]

ENGINEERING
→ Merged PRs yesterday: 7
→ Open PRs: 12
→ Cycle time (7-day avg): 1.8 days
→ Linear issues closed: 14

ANOMALIES + NOTES
→ Cancellation rate this week is highest in 8 weeks. Worth investigating?
→ HN engagement from yesterday is driving signups today.
→ One competitor (named) released a feature similar to our Y. Yuki's full report attached.

Have a good morning,
KPI Agent

The email format is tuned to our taste over a few weeks of iteration. Yours would be different.

What this saves

Pre-agent setup: → Manual check of Stripe each morning: 5 min → Mixpanel scan: 5-10 min → HubSpot pipeline review: 10 min → GitHub/Linear glance: 5 min → Custom Postgres queries occasionally: 15-30 min

Total morning data-gathering time: 30-60 min on days when I did it (often I didn't).

Post-agent: → Read email: 3-5 min

Time saved: ~25-55 min per business day. Across 220 business days = 90-200 hours/year.

Plus the qualitative improvement: I actually look at the data daily instead of intermittently. Anomalies get caught when they happen, not weeks later.

What this cost to build

→ Stripe sub-agent: 45 min → Mixpanel sub-agent: 30 min → HubSpot sub-agent: 45 min → GitHub sub-agent: 30 min → Linear sub-agent: 30 min → Postgres sub-agent: 30 min → Coordinator agent: 60 min → Iteration on the email format/content: ~90 min spread over a week

Total: about 6 hours of build time.

Ongoing maintenance: ~30 min/month tuning, updating logic when our metrics evolve.

Cost: included in our Avery NXR Pro subscription, which we'd be paying anyway. Marginal additional cost: $0.

What this would cost differently

If we'd built this same dashboard with:

A BI tool (Looker, Tableau, Sigma): → Initial setup: 2-4 weeks (configuring data sources, building dashboards) → Annual cost: $5,000-30,000+ depending on tier → Maintenance: ongoing dashboard tweaking

A dbt + Metabase pipeline: → Initial setup: 2-3 weeks (modeling data, building dashboards) → Annual cost: ~$500-2,000 for hosting, free for software → Maintenance: data model + dashboard tweaking

A custom internal tool: → Initial setup: 2-3 weeks of engineer time = ~$20K-30K opportunity cost → Annual cost: hosting + ongoing maintenance → Maintenance: ongoing engineer time

Hire a data analyst: → Initial setup: 1-2 months ramp + dashboard build → Annual cost: $90K-150K loaded → Maintenance: their ongoing role

The agent approach was meaningfully faster + cheaper than any of these. The trade-off: less interactive than a real BI tool, no historical dashboards (just daily emails), less suitable for deep ad-hoc analysis.

For our use case (daily KPI awareness), the trade-off is right. For deeper analytical work, BI tools are still better.

Where this approach doesn't work

We're honest about limits:

You need interactive dashboards. If product team or sales team needs to drill into the data themselves, a BI tool is better than an email.

You need historical trending. Email digests don't make historical charts easy. BI tools do.

Your data is large. Pulling from millions of rows daily is harder via agent. Better suited to a proper data pipeline.

You need real-time alerts. Daily email is daily. If you need real-time monitoring, a different architecture is needed.

For most early-stage companies and small teams: daily email KPI agent fits the need. Larger companies graduate to BI tools when complexity requires.

What we learned

Building this taught us a few things:

Sub-agents are the right pattern for multi-source data. Each source-specific agent does one thing well. Coordinator composes. Easier to debug than a monolith.

LLM only for the composition step. Don't waste tokens on deterministic API queries. Save LLM for where natural language formatting actually helps.

The email format matters more than the data. First versions were data-dense, hard to scan. Iteration on format made the daily check actually useful.

Anomaly detection is the high-value feature. Surfacing "this is unusual" beats showing the same numbers every day. We invested in the anomaly note section over time.

Tune the cadence. We tried multiple times/day, weekly, monthly variations. Daily morning landed as the right cadence for our team.

What we'd recommend you build

If you're a founder or operator wanting a similar KPI digest:

→ Start with one source. Pick the metric you check most often (Stripe, GA, your CRM). Build that sub-agent first. → Add sources as you trust the first one. Don't try to build the full 6-source coordinator on day one. → Tune the email format heavily. First versions will be too data-heavy. Iterate over weeks. → Add anomaly notes after you have stable baselines. Doesn't work without a few weeks of data to compare against. → Make it a habit. The agent isn't useful if nobody reads the email. Build the morning ritual.

What this generalizes to

The "daily digest agent" pattern works for many use cases beyond KPI dashboards:

→ Daily competitor digest (Yuki template variation) → Daily customer health summary (churn risk monitoring) → Daily fundraising pipeline (for fundraising founders) → Daily product feedback summary (from support + reviews + social) → Daily team health (Linear + GitHub + Slack signals)

Any time you have "I should be looking at X daily but never actually do" — a daily agent that pulls X and emails you can absorb the habit problem.

The principle

Some workflows that feel like they need expensive tooling actually need just a daily email. The email is the user interface. The agent is the engine.

For our 5-person company, agent-driven daily emails replace what bigger companies use BI tools for. We grow into BI tools when complexity demands. We're still at the email-is-enough stage.

If you're at that stage too, the agent approach is dramatically faster and cheaper than the alternatives.

→ avery.software — Free Desktop tier. Build the KPI dashboard your team actually needs (without buying a BI tool).