PipelineReplay - CRM Pipeline History Snapshots and Trending
Automatically snapshots your Salesforce or HubSpot pipeline daily, stores the history, and surfaces month-over-month trending in a 3-line dashboard. See what deals moved, stalled, or closed—without manual exports.
Difficulty
intermediate
Category
Sales Automation
Market Demand
Very High
Revenue Score
8/10
Platform
Web App
Vibe Code Friendly
⚡ YesHackathon Score
🏆 7/10
Validated by Real Pain
— seeded from real developer complaints
Sales teams cannot view historical CRM pipeline state because CRMs only display current moment data. Teams resort to manual exports and spreadsheets to compare pipeline month-over-month, which is error-prone and time-consuming.
What is it?
Sales teams cannot see historical pipeline state because CRMs only show the current moment. When a deal closes, the team has no record of when it was added, how long it stayed in each stage, or velocity trends. Teams resort to manual spreadsheet exports, screenshots, or guesswork. PipelineReplay solves this by automatically pulling your CRM pipeline daily via Zapier-style integration, storing snapshots in a time-series database, and surfacing trends: total pipeline value over time, deal age by stage, conversion rates, and cycle-time metrics. The MVP supports Salesforce and HubSpot, pulls daily at 9am, and renders a simple 3-line chart dashboard (total pipeline value, deals in stage, average deal age). Why 100% buildable right now: Salesforce and HubSpot both have stable REST APIs with webhook support. Supabase TimescaleDB extension handles time-series data. Recharts or Chart.js renders the dashboard instantly. No custom ML or data science needed—just aggregation and visualization.
Why now?
Salesforce and HubSpot APIs are now stable and widely accessible via OAuth. TimescaleDB Postgres extension (native to Supabase) makes time-series data cheap and fast. Sales teams are increasingly focused on metrics and cycle-time reduction, and CRM-native reporting is no longer sufficient.
- ▸Daily automatic pipeline snapshot from Salesforce or HubSpot (captures deal value, stage, owner, close date)
- ▸Time-series storage of snapshots for historical trending
- ▸Dashboard with 3-line charts: total pipeline value over time, deals by stage, average deal age per stage
- ▸Rep and team-level drill-down to compare velocity and conversion rates
Target Audience
B2B sales teams in mid-market SaaS companies (5-50 reps). Focus on revenue operations managers and sales leaders. TAM: ~15k SaaS companies in US with 5+ reps.
Example Use Case
Emma, revenue ops manager at a $2M ARR SaaS company, used to export Salesforce every Friday and manually compare pipeline in Excel. PipelineReplay now shows her that deals in the 'proposal' stage average 45 days (up from 30 days 6 months ago), so she implements faster sales enablement and reduces cycle time by 20%. She also spots that 3 reps have half the deal velocity of peers, triggering coaching conversations. Saves 3 hours per week.
User Stories
- ▸As a revenue ops manager, I want to see how pipeline value changes month-over-month so that I can forecast revenue accurately and identify sales process bottlenecks.
- ▸As a sales leader, I want to see how long deals stay in each stage compared to 6 months ago so that I can spot if my sales process is slowing down.
- ▸As a sales rep, I want to see if my deal velocity is matching my teammates so that I can adjust my tactics and stay competitive.
Acceptance Criteria
Salesforce Sync: done when deal data syncs daily and historical snapshots are visible in Supabase. HubSpot Sync: done when HubSpot deal API integration works and produces equivalent data to Salesforce. Dashboard Charts: done when 3 line charts render with real data and respond to date range filters. Team Access: done when user can invite teammate and they see same data. Export: done when CSV export includes all snapshots and deal-level details.
Is it worth building?
$199/month × 10 customers = $1,990 MRR at month 3. $299/month × 8 multi-CRM teams + $199 × 12 single-CRM = $5,780 MRR at month 5. Realistic for bootstrapped B2B with OAuth trust barrier.
Unit Economics
CAC: $100 via LinkedIn DMs (15 DMs per conversion). LTV: $2,388 (12 months at $199/month, 75% retention year 1). Payback: 1.2 months. Gross margin: 90%.
Business Model
SaaS subscription: $199/month for single CRM, $299/month for multi-CRM
Monetization Path
Free tier: 14-day history, 1 dashboard. Paid: unlimited history, 5 custom dashboards, team access.
Revenue Timeline
First dollar: week 3 (beta trial to paid). $1k MRR: month 2 (5 customers). $3k MRR: month 4 (12-15 customers). $7k MRR: month 7 (25-30 customers).
Estimated Monthly Cost
Salesforce API: free (tier included). HubSpot API: free. Claude API: $0 (not used in MVP). Supabase: $50 (TimescaleDB with larger storage). Vercel: $20. Stripe fees: ~$40 (2% on payments). Monitoring (Sentry): $29. Total: ~$165/month at launch.
Profit Potential
Full-time viable at $5k–$15k MRR. Realistic path to $20k MRR in 12 months.
Scalability
High — can add Pipedrive, Microsoft Dynamics, custom CRM APIs, and predictive churn modeling.
Success Metrics
Week 1: 50 API key signups. Week 2: 15 paid trials. Month 2: 28 paid customers, 65% retention.
Launch & Validation Plan
Survey 40 sales leaders and revenue ops managers on LinkedIn. Build landing page with metrics calculator (show ROI). Recruit 6 beta testers (mid-market SaaS companies with 5-20 reps) for 3-week free trial. Measure: dashboard usage (daily active %, chart views), insights generated from trending (survey), time saved.
Customer Acquisition Strategy
First customer: DM 15 revenue ops managers on LinkedIn offering 2 months free in exchange for 30-min weekly calls and case study. Second: ProductHunt launch, Reddit r/sales and r/startups, Twitter/X threads on sales metrics, targeted LinkedIn ads to VP Sales titles, partner outreach to Salesforce/HubSpot consultants.
What's the competition?
Competition Level
Low
Similar Products
Salesforce Reports and Dashboards show current state only. Looker and Tableau require heavy BI configuration. Clari (pipeline inspection and forecasting) and People.ai (revenue intelligence) are direct competitors but far more expensive and complex. Gong focuses on call intelligence, not pipeline history snapshots.
Competitive Advantage
Salesforce and HubSpot only show snapshots of current state; PipelineReplay adds the time dimension. Simpler than full BI platforms (Looker, Tableau) with zero configuration needed.
Regulatory Risks
GDPR: Must delete user data on request. CCPA: Disclose data use. No HIPAA or financial regulations needed.
What's the roadmap?
Feature Roadmap
V1 (week 2): Salesforce and HubSpot sync, daily snapshots, 3-line dashboard, team access. V2 (month 2-3): Custom dashboards (user-created charts), deal-level drill-down, Pipedrive integration, CSV export. V3 (month 4+): Predictive deal close probability (ML), sales rep benchmarking, white-label reselling, API access for custom integrations.
Milestone Plan
Phase 1 (Week 1): Build Next.js scaffold, Supabase schema with TimescaleDB, Salesforce OAuth endpoint. Done when: local auth flow works, Salesforce token persists. Phase 2 (Week 2): HubSpot OAuth, daily cron job, aggregation queries, v0 dashboard. Done when: cron runs at 9am, dashboard renders with 3 charts. Phase 3 (Month 1): Stripe billing, team access RLS, 6 beta customers on-boarded. Done when: first 3 customers sync data for 7+ days and view dashboard.
How do you build it?
Tech Stack
Next.js, Salesforce REST API, HubSpot API, Supabase Postgres (with date-partitioned snapshots table or timescaledb extension on dedicated instance), Recharts, Stripe, Vercel Cron Jobs — build with Cursor for API integrations, v0 for dashboard charts.
Suggested Frameworks
Vercel Cron Jobs (vercel.json) for daily snapshots, Supabase Postgres for time-series storage with date-based table partitioning, Recharts for charting
Time to Ship
2 weeks
Required Skills
Salesforce and HubSpot API integration, time-series database design, basic dashboard UI
Resources
Salesforce REST API docs, HubSpot API docs, Supabase TimescaleDB docs, Recharts docs
MVP Scope
Create: (1) Next.js app with Supabase auth and Stripe billing. (2) Salesforce OAuth + daily pull via node-cron (SOQL query for all open deals + closed in last 90 days). (3) HubSpot OAuth + daily pull (REST API). (4) Supabase TimescaleDB schema (snapshots, deals, time-series aggregations). (5) Recharts dashboard with 3 line charts (built with v0). (6) Team access controls (basic role: admin, viewer). (7) CSV export of historical data. (8) Stripe webhook for subscription lifecycle.
Core User Journey
Install app -> authorize Salesforce/HubSpot -> wait for first daily snapshot (or manually trigger) -> view dashboard with 3 charts -> identify one actionable trend -> upgrade to paid.
Architecture Pattern
Daily cron at 9am -> Salesforce/HubSpot OAuth token refresh -> REST API query -> parse deals into normalized schema -> INSERT INTO snapshots table (TimescaleDB) -> trigger aggregation query (group by stage, sum value, count deals) -> dashboard fetches aggregates -> Recharts renders line chart.
Data Model
User has one CRMIntegration (Salesforce or HubSpot). CRMIntegration has many PipelineSnapshots (one per day). PipelineSnapshot has many Deals. Deal tracks: value, stage, owner, close_date, created_date.
Integration Points
Salesforce REST API for deal data, HubSpot API for deal and pipeline data, Supabase for storage and TimescaleDB extension, Stripe for billing, Recharts for charting.
V1 Scope Boundaries
V1 excludes: predictive churn, opportunity scoring, team coaching tools, white-label, mobile app, deal-level alerts.
Success Definition
A paying customer (revenue ops manager) discovers the product, connects their Salesforce account, views the 3-line dashboard with historical trending, runs one custom report without founder help, and renews after 30 days.
Challenges
Handling duplicate deals and stage remappings across different CRM configurations. Keeping snapshots performant as history grows to 1M+ records.
Avoid These Pitfalls
Salesforce SOQL returns max 2000 records per query — implement pagination with nextRecordsUrl or deals will silently truncate for large orgs. HubSpot OAuth refresh tokens expire after 6 months of user inactivity — build a token health check or customers will silently lose sync with no error. CRM stage names are mutable — if a user renames a stage mid-history, your trend charts will split into two phantom stages; store a stage_id not just stage_name and prompt users to re-map on stage rename detection. Do not build deal forecasting until you have 90+ days of snapshot history per customer — earlier predictions will be statistically meaningless and erode trust. Salesforce orgs often have thousands of closed-lost deals in the last 90 days — cap initial historical pull to open deals plus closed-won only, or the first sync will hit API rate limits.
Security Requirements
Auth: Supabase Auth with Salesforce and HubSpot OAuth. RLS enabled on snapshots and deals tables (users see only their integration data). Rate limiting: 50 req/min per user to avoid API quota burnout. Input validation: OAuth tokens stored encrypted in Supabase. GDPR: delete endpoint removes all snapshots and integrations on user request.
Infrastructure Plan
Hosting: Vercel. Database: Supabase Postgres (date-partitioned snapshots table; timescaledb extension optional on dedicated Supabase instance). Cron: Vercel Cron Jobs configured in vercel.json (calls /api/jobs/snapshot on schedule). Monitoring: Sentry for errors, Vercel Analytics for usage. CI/CD: GitHub Actions. Environments: dev (local), staging (Vercel preview), prod (Vercel main). Cost: Vercel $20, Supabase $50, Sentry $29, Total: $99/month.
Performance Targets
Expected DAU at launch: 30. Requests/day: 200. Daily cron execution: under 2 minutes per customer. Dashboard load: under 1.5s (LCP). Time-series query response: under 500ms even with 100k snapshots.
Go-Live Checklist
- ☐✓ Salesforce OAuth tested with 2 real accounts
- ☐✓ HubSpot OAuth tested with 2 real accounts
- ☐✓ Daily cron job tested for 3 days in staging (verify snapshots insert correctly)
- ☐✓ Dashboard charts render with real data
- ☐✓ Team access RLS rules verified
- ☐✓ Stripe checkout tested end-to-end
- ☐✓ Error tracking live (Sentry)
- ☐✓ Monitoring dashboard shows cron performance
- ☐✓ Custom domain configured with SSL
- ☐✓ Privacy policy and terms published
- ☐✓ 6 beta testers signed off (synced data for 7+ days)
- ☐✓ Rollback plan: revert Vercel, restore Supabase snapshot
- ☐✓ ProductHunt and Reddit launch posts drafted.
How to build it, step by step
1. npx create-next-app@latest pipelinereplay --typescript --app. 2. npm install @supabase/supabase-js @supabase/auth-helpers-nextjs stripe recharts. 3. In Supabase SQL editor: CREATE TABLE integrations (id uuid PRIMARY KEY, user_id uuid REFERENCES auth.users, crm_type text, access_token text, refresh_token text, token_expires_at timestamptz, created_at timestamptz DEFAULT now()); CREATE TABLE snapshots (id uuid PRIMARY KEY, integration_id uuid REFERENCES integrations, snapshot_date date NOT NULL, total_pipeline_value numeric, deal_count int, created_at timestamptz DEFAULT now()); CREATE TABLE deals (id uuid PRIMARY KEY, snapshot_id uuid REFERENCES snapshots, crm_deal_id text, name text, stage_id text, stage_name text, owner_id text, value numeric, close_date date, created_date date); CREATE INDEX ON deals (snapshot_id); CREATE INDEX ON snapshots (integration_id, snapshot_date DESC). 4. Enable RLS on all three tables: ALTER TABLE integrations ENABLE ROW LEVEL SECURITY; CREATE POLICY user_integrations ON integrations FOR ALL USING (user_id = auth.uid()); repeat equivalent policies for snapshots (JOIN to integrations WHERE user_id = auth.uid()) and deals (JOIN to snapshots to integrations). 5. Register a Salesforce Connected App at developer.salesforce.com — set callback URL to /api/auth/salesforce/callback. Build /api/auth/salesforce/route.ts: redirect to Salesforce OAuth authorize URL with response_type=code, client_id, redirect_uri, scope=api. Build /api/auth/salesforce/callback/route.ts: exchange code for access_token + refresh_token via POST to https://login.salesforce.com/services/oauth2/token, store encrypted in integrations table. 6. Register HubSpot app at developers.hubspot.com — set callback to /api/auth/hubspot/callback, request scopes crm.objects.deals.read and oauth. Build equivalent /api/auth/hubspot and /api/auth/hubspot/callback routes mirroring step 5 but posting to https://api.hubapi.com/oauth/v1/token. 7. Add vercel.json with cron config: { "crons": [{ "path": "/api/jobs/snapshot", "schedule": "0 9 * * *" }] }. Build /api/jobs/snapshot/route.ts: fetch all active integrations, for each refresh OAuth token if expires_at < now + 10min (POST to token URL with grant_type=refresh_token), then for Salesforce run SOQL: SELECT Id, Name, StageName, Amount, CloseDate, CreatedDate, OwnerId FROM Opportunity WHERE IsClosed = false OR (IsClosed = true AND CloseDate = LAST_N_DAYS:90) with pagination via nextRecordsUrl loop until done, INSERT snapshot row, bulk INSERT deals rows. 8. For HubSpot snapshot: GET https://api.hubapi.com/crm/v3/objects/deals?properties=dealname,dealstage,amount,closedate,createdate,hubspot_owner_id&limit=100 with after cursor pagination until no paging.next.after. Normalize to same deals schema. 9. Build /api/dashboard/trends/route.ts: query SELECT snapshot_date, SUM(value) as total_value, COUNT(*) as deal_count, AVG(CURRENT_DATE - created_date) as avg_age_days FROM deals JOIN snapshots ON deals.snapshot_id = snapshots.id WHERE snapshots.integration_id = $1 AND snapshot_date >= NOW() - INTERVAL '90 days' GROUP BY snapshot_date ORDER BY snapshot_date ASC. 10. Build dashboard page in v0: prompt 'Recharts dashboard with 3 LineCharts sharing an XAxis of dates: (1) total pipeline value in dollars, (2) deal count, (3) average deal age in days. Use ResponsiveContainer, Tooltip, Legend. Accept data prop as array of {date, totalValue, dealCount, avgAge}.' Drop generated component into app/dashboard/page.tsx and wire to /api/dashboard/trends. 11. Add Stripe: create two Price IDs in Stripe dashboard ($199/month single CRM, $299/month multi-CRM). Build /api/billing/checkout/route.ts using stripe.checkout.sessions.create with price ID and customer email. Build /api/billing/webhook/route.ts to handle checkout.session.completed (activate subscription in DB) and customer.subscription.deleted (deactivate). 12. Deploy: push to GitHub, connect Vercel, set env vars (SUPABASE_URL, SUPABASE_SERVICE_ROLE_KEY, SALESFORCE_CLIENT_ID, SALESFORCE_CLIENT_SECRET, HUBSPOT_CLIENT_ID, HUBSPOT_CLIENT_SECRET, STRIPE_SECRET_KEY, STRIPE_WEBHOOK_SECRET), verify Vercel Cron Jobs tab shows schedule, test OAuth flows end-to-end with real Salesforce Developer Edition org and HubSpot free account.
Generated
March 30, 2026
Model
claude-haiku-4-5-20251001 · reviewed by Claude Sonnet