Next.js 15 App Router with Server Components for data-heavy dashboard views and Client Components for interactive pipeline kanban boards. Supabase provides PostgreSQL with Row Level Security for enterprise access control, Realtime subscriptions for live pipeline state synchronisation, and Edge Functions for workflow automation. Deployed on Vercel with Supabase Vector for AI-powered lead scoring and semantic search.
Where enterprise projects fail
But watch what happens when you're at 200. Salesforce Enterprise runs $165/user/month, so a team of 200 hits nearly $400K annually, and that's before add-ons, premium support tiers, or the inevitable "we need this module too" conversations mid-contract. The real kicker? That number compounds every single time you hire someone. Growth becomes a cost penalty. We've watched companies in Chicago, Austin, and London quietly absorb $500K+ yearly just keeping the lights on in their CRM -- money that's funding Oracle's shareholders, not your product roadmap. And it never goes down. Headcount fluctuates, but SaaS contracts don't forgive you on the way back.
Not my number -- that's a widely cited industry stat, and honestly, it tracks with what we see. Companies drop six figures on Salesforce or Dynamics, spend months on configuration, and then watch their sales team quietly drift back to Google Sheets by Q2. Why? Because the tool wasn't built around how those specific people actually sell. So the adoption never sticks. The training sessions get forgotten. And the investment -- sometimes $200K+ when you include consultants -- just evaporates. It's a painful pattern, and it's almost always avoidable.
Strong ones. And they'll bend your sales process to fit their data model whether that makes sense for your business or not. So reps start working around the tool -- keeping notes in Notion, tracking deals in a side spreadsheet, skipping pipeline updates because the workflow doesn't match reality. That's not a people problem. That's a software problem. The efficiency loss is real and it compounds quietly: slower forecasting, missed follow-ups, managers making decisions off stale data. A CRM should fit how your team sells, not the other way around.
So someone is manually re-entering data between them. Every day. That manual bridge introduces errors, creates reporting lag, and means your "real-time" dashboard is actually 48 hours behind. Integration gaps aren't a minor inconvenience. They're a silent tax on every department that touches customer data.
What we deliver
Why Off-the-Shelf CRMs Fail at Enterprise Scale
Salesforce costs $150-300/user/month. HubSpot wants you to reshape your entire sales process around their pipeline model. Microsoft Dynamics needs a dedicated admin just to stay functional. And the numbers aren't kind: 55% of CRM implementations fail — mostly because of poor user adoption, data entry friction, and integration gaps.
The problem isn't CRM as a concept. It's that legacy CRMs are general-purpose tools jammed into specific business processes. Your sales team has a workflow. Your ops team has a dashboard they actually rely on. Leadership needs something that surfaces the three metrics that matter — not 47 charts nobody reads.
We build the CRM your business actually needs. No per-seat licensing. No vendor lock-in. No features you'll never touch.
What a Purpose-Built CRM Command Centre Looks Like
A custom CRM isn't a stripped-down Salesforce clone. It's a unified internal tool that maps exactly to how your organisation sells, manages relationships, and moves deals through the pipeline.
Sales Pipeline Management
Drag-and-drop kanban boards with real-time state sync across every connected user. Deal stages that match your actual sales process — not some generic template someone in California designed. Automated stage transitions triggered by real events: signed contracts, payment received, onboarding complete.
Every pipeline view is a live query against your Postgres database. No stale data. No manual refreshes. When a rep moves a deal to "Contract Sent", the ops team sees it instantly.
Admin Dashboard & Role-Based Access
Row Level Security at the database layer means access control isn't something bolted onto the UI as an afterthought. Sales reps see their deals. Regional managers see their region. Leadership sees everything. Audit logs capture every state change, every login, every data export.
This isn't just a dashboard — it's a governance layer. SOC2-aligned access patterns, JWT-based authentication, and granular permission matrices that map to your actual org chart.
Workflow Automation Engine
The 23% of CRM users who cite data entry as their primary pain point aren't lazy — they're stuck with tools that demand manual work for tasks that should just run automatically. Our workflow engine handles:
- Lead routing: Inbound leads auto-assigned based on territory, deal size, or round-robin logic
- Notification chains: Slack alerts, email sequences, and SMS triggers fired by pipeline events
- Approval flows: Multi-step approval processes for discounts, custom terms, or escalations
- Scheduled jobs: Automated deal aging, follow-up reminders, and pipeline health reports via pg_cron
Every automation runs on Supabase Edge Functions — serverless, low-latency, and scalable without touching infrastructure.
Architecture: Next.js + Supabase for Enterprise Internal Tools
We chose this stack deliberately. Not because it's trendy — because it solves specific enterprise problems that legacy platforms genuinely can't.
Frontend: Next.js App Router
Next.js 15 with the App Router gives us nested layouts that map cleanly to complex internal tool navigation. A sales rep's view at /dashboard/pipeline shares layout components with /dashboard/reports but renders completely different data and interactions.
Server Components fetch data on the server, so your CRM loads with data already rendered — no loading spinners, no client-side waterfall requests. Interactive elements like pipeline kanban boards, inline-editable data tables, and chart filters use Client Components only where interactivity actually makes sense.
Turbopack delivers sub-second hot module replacement during development. That matters when you're iterating on complex dashboard layouts with stakeholders in the room.
Backend: Supabase (Postgres + Realtime + Edge Functions)
Supabase gives us a production-grade Postgres database with built-in realtime subscriptions. When a deal changes stage, every connected client gets the update via WebSocket — no polling, no stale state.
Row Level Security policies live at the database level, not in application code. That means even if a frontend bug exposes an API endpoint, unauthorised users physically can't access rows they shouldn't see. Security by architecture, not security by hope.
Edge Functions handle workflow logic — lead scoring, notification dispatch, third-party API calls to your ERP or accounting system. They run on Deno at the edge, with sub-50ms cold starts and global distribution.
Data Layer & Integrations
Your CRM doesn't exist in isolation. We build integration layers that connect to:
- Accounting: Xero, QuickBooks, NetSuite via REST APIs
- Communication: Resend for transactional email, Twilio for SMS
- Payments: Stripe for billing and subscription management
- AI/ML: OpenAI embeddings stored in Supabase Vector for semantic lead search and deal similarity scoring
- Legacy systems: Custom ETL pipelines for migrating historical data from Salesforce, HubSpot, or spreadsheets
Why In-House Teams Struggle With This
Building a custom CRM sounds straightforward until you're three months in and wondering where it all went sideways. Here are the failure modes we see consistently.
Underestimating the Permissions Model
Role-based access control for a 500-person sales org — with regional hierarchies, cross-functional teams, and executive overrides — is a months-long design challenge on its own. Most in-house teams build a basic admin/user toggle, then spend the next year patching edge cases.
Real-Time State Management at Scale
A pipeline board that works fine for 10 users breaks at 200 concurrent connections. Optimistic UI updates, conflict resolution when two reps edit the same deal simultaneously, and WebSocket connection management across unstable mobile networks require deep infrastructure knowledge that most teams simply don't have on hand.
Data Migration Without Data Loss
Your Salesforce instance has 7 years of deal history, custom fields that evolved organically, and duplicate records nobody ever cleaned up. Migrating that into a clean schema without losing business context is its own project.
Maintaining Momentum Post-Launch
The CRM that's perfect at launch needs iteration as your sales process changes. In-house teams get pulled to other priorities. The CRM stagnates. Adoption drops. You're back to spreadsheets.
How We Deliver
Our engagement model is built for organisations that need certainty.
Discovery & Architecture (Weeks 1-3)
We map your sales process, interview stakeholders from reps to leadership, audit your existing tools and data, and produce a technical architecture document — schema designs, integration maps, UI wireframes. No surprises later.
Build & Iterate (Weeks 4-12)
Two-week sprint cycles with deployable increments. You see working software from week 4. Deployed to Vercel preview environments so stakeholders can test real functionality, not static mockups.
Migration & Launch (Weeks 12-16)
Parallel running with your existing CRM. Automated data sync ensures nothing falls through the cracks. Training sessions for power users who become internal champions.
Ongoing Support & Evolution
Retainer-based support for feature additions, performance monitoring, and Supabase infrastructure management. Your CRM evolves with your business — it doesn't freeze at launch.
Production Proof
We've built data-driven platforms at scales that stress-test every architectural decision. A directory platform managing 137,000+ listings with real-time search. A content platform with 91,000+ dynamically generated pages indexed by Google. A real-time auction system processing bids at sub-200ms latency. A multilingual enterprise hub deployed across 30 languages.
Every one of those projects demanded the same things a custom CRM demands: solid data architecture, real-time state management, role-based access, and performance that holds up under real load.
The Business Case
The average enterprise spends $100K+/year on CRM licensing for 500 users. A custom build at $150K-$250K pays for itself within 18-24 months while eliminating per-seat costs permanently. More importantly, you own the IP. You control the roadmap. Your CRM becomes a competitive advantage instead of a recurring line item.
Industry data shows an $8.71 return per $1 spent on CRM and a 29% average sales increase from proper implementation. The question isn't whether you can afford to build custom — it's whether you can afford not to.
See this capability in action
Frequently asked
How long does it take to build a custom CRM from scratch?
A production-ready MVP -- pipeline management, admin dashboard, core workflows -- typically lands in 12-16 weeks. That covers discovery, architecture, build sprints, data migration, and launch. Add AI features, multi-tenant architecture, or deep third-party integrations and you're looking at 20-24 weeks. And look, there's no shortcut through that complexity. Anyone quoting you 6 weeks for a full custom CRM is either scoping something very thin or planning to cut corners you'll discover later.
How does a custom CRM cost compare to Salesforce licensing over 3 years?
Run the numbers honestly. Salesforce Enterprise at $165/user/month for 500 users is roughly $990K over 3 years -- and that's before implementation consultants, which commonly add another $150K-$300K for an enterprise rollout. A custom build runs $150K-$250K upfront, plus $1.5K-$3K/month for hosting and ongoing support. Over 3 years that's $200K-$360K total. So you're saving $600K-$800K, you own the IP outright, and you're not locked into a vendor's pricing decisions for the next decade. The math isn't close.
Can you migrate our existing CRM data without downtime?
Yes -- and we don't do big-bang cutovers. We run both systems in parallel with automated bidirectional sync so your team keeps working without interruption while migration happens underneath them. Historical deals, contacts, activity logs, custom fields -- everything gets mapped to a clean schema, not just dumped in. We validate data integrity at every stage. The cutover only happens when both systems are fully in sync with zero discrepancies. That's not a nice-to-have, it's the whole point.
How does Supabase Row Level Security protect sensitive sales data?
Row Level Security means access policies live at the PostgreSQL layer -- not in your application code where a frontend bug or a misconfigured API route could accidentally expose data. Even if something breaks at the app level, the database itself rejects unauthorised queries. Full stop. Policies mirror your actual org structure: reps see their deals, managers see their teams, executives see everything. And every access event gets logged, so you have a full audit trail without building a separate logging system on top.
Will the custom CRM integrate with our existing ERP and accounting tools?
We build REST API integration layers for NetSuite, QuickBooks, Xero, Stripe, and most SaaS tools with documented APIs. For legacy systems without APIs -- and yes, those still exist everywhere -- we build custom ETL pipelines using Supabase Edge Functions and scheduled jobs. The part most agencies skip? Testing against real production data volumes. We don't just confirm it works in a demo environment with 200 records. We validate it holds up under the actual load your business runs, because that's where integrations typically fall apart.
What happens after launch — who maintains the CRM?
Post-launch, we offer retainer-based support covering feature development, performance monitoring, Supabase infrastructure management, and security updates. But here's the thing -- you're not hostage to us. The Next.js/Supabase stack uses standard TypeScript and SQL, so any competent full-stack developer can jump in and contribute. We deliver full documentation and handover training precisely so that your team has real options. Some clients stay on retainer for years. Others take the wheel after three months. Both work fine.
Can the CRM handle real-time collaboration across distributed teams?
Supabase Realtime uses WebSocket-based subscriptions that push database changes to connected clients the moment they happen. So when a rep in London updates a deal stage, a manager in New York sees it within milliseconds -- not after a page refresh, not after a polling interval fires. And it's not just fast under ideal conditions. We implement optimistic UI updates and conflict resolution so simultaneous edits get handled gracefully even on flaky connections. That last part matters more than most people realise until two reps edit the same deal at the same time.
Browse all 15 enterprise capability tracks or compare with our SME-scale industry solutions.
Schedule Discovery Session
We map your platform architecture, surface non-obvious risks, and give you a realistic scope — free, no commitment.
Schedule Discovery Call
Let's build
something together.
Whether it's a migration, a new build, or an SEO challenge — the Social Animal team would love to hear from you.