The Growth Edge is an internal reporting and management dashboard I designed and built for a Google Ads agency. It pulls performance data from across the agency's entire book of accounts, measures that data against the specific goals set for each client, and automatically surfaces underperformance to the right person — admin, pod manager, or media buyer — before it becomes a problem the client notices first.

The core idea: an agency managing 100+ ad accounts can't manually eyeball every metric every day. The platform does the watching, the math, and the routing, so humans only spend attention where it's actually needed.

A growing Google Ads agency runs into the same wall every time it scales:

Data is scattered. Spend, conversions, ROAS, and revenue live across Google Ads, Triple Whale, and the client's store. Nobody has one screen that tells the truth.

Goals are implicit. Each client has a target (a ROAS floor, a spend ceiling, a revenue goal), but those targets live in spreadsheets and people's heads — not in anything that can check itself.

Accountability is fuzzy. When an account slips, who's supposed to act? The buyer running it? Their pod manager? The admin? Without a clear routing model, alerts get ignored or everyone assumes someone else has it.

It doesn't scale linearly. Doubling the number of accounts shouldn't double the number of people staring at dashboards.

A single platform that aggregates performance data, layers per-client goals on top of it, and runs a tiered alerting flow — underperformance is detected automatically, scored for severity, and routed up the hierarchy (media buyer → pod manager → admin) based on who owns the account and how bad the miss is.

Aggregates ad performance across the agency's full account list on an automated sync schedule.

Tracks per-account goals, including manually-set target ROAS, and colors live actuals against those targets so a miss is visible at a glance.

Drills down through the org hierarchy — organization → pod/group → member → individual account — so leadership can zoom from "how's the whole agency doing" to "this one account is bleeding" in a few clicks.

Surfaces underperformance in a dedicated Performance view that walks groups → members → accounts and flags the red ones.

Routes alerts to the right role, scoped by an access model that mirrors the real org chart.

Pulls revenue truth from Triple Whale (a rich ~49-metric dashboard per account) for source-aware ROAS, not just what the ad platform self-reports.

The platform is invite-only and built around three roles that map to how the agency actually operates:

Role In the agency What they see Admin Agency operator Everything — all pods, all accounts, all alerts Leader Pod manager Their pod's members and accounts; alerts escalated to them Member Media buyer The accounts assigned to them; alerts they own first

Account access is granted three ways — direct admin grant, direct user assignment, or pod-level assignment — and surfaced as inline tags right on the accounts table.

Scheduled sync runs a lightweight set of conversion, reach, and management reports across all ~112 accounts in roughly a minute, keeping the dashboard fresh without hammering the Google Ads API.

On-demand deep sync — heavier, detailed per-account reports are fetched lazily the first time someone opens that account's workspace, so we only pay for detail people actually look at.

Goal evaluation compares live metrics against each account's targets and assigns severity.

Alert routing sends each flagged issue to the correct role based on ownership and severity.

Per-account workspace — an 8-tab dashboard (performance, conversions, reach, activity, revenue, and more) that auto-syncs its detailed data on first view.

This was engineered as a modern, server-first Next.js application with a tight, intentional stack:

Framework: Next.js 16 (App Router, Server Components, Turbopack)

Language: TypeScript (strict mode)

Styling: Tailwind CSS v4 (CSS-first @theme), shadcn "base-luma" design system on @base-ui/react + class-variance-authority, light/dark/system theming with switchable accent palettes

Database: PostgreSQL via Supabase, accessed through @supabase/supabase-js with a service-role client for privileged work and an SSR cookie client for session-bound reads

Data layer: hand-written SQL migrations with Postgres RPC functions powering the hierarchy, reporting, and dashboard reads

Auth: Supabase Auth (@supabase/ssr cookie sessions) wrapped in a custom invite-only flow with admin / leader / member roles and a client-scoped access hierarchy

Integrations: Google Ads API (live Basic Access tier, multi-account), Triple Whale for revenue and source-aware ROAS

Email: nodemailer over Gmail SMTP for all transactional mail (invites, resets)

Automation: Vercel cron jobs for the scheduled syncs, each gated behind a bearer secret

Hosting: Vercel

Extras: an MCP server for programmatic access to the reporting layer

The stack is deliberately lean — server-rendered by default, database queries never exposed to the client, every route and action behind an auth check, and credentials read encrypted from the database per request rather than cached.

The agency gets one screen of truth: live performance, measured against real goals, with underperformance automatically flagged and pushed to the person responsible for fixing it. Instead of scaling headcount with account count, the agency scales attention — humans look only where the system says to look.