We build the dashboards
and CRMs your team
can't buy off the shelf.
We design and ship production-grade dashboards, CRMs, and internal tools for tech businesses.
TradeFlow — analytics dashboard · Read the case study
Most teams don't need
another subscription.
Every growing company reaches the point where the tools stop fitting. The CRM has forty fields nobody uses and none of the three you need. Reporting lives in a spreadsheet one person maintains and nobody else fully understands. The work that actually keeps the business running happens across five browser tabs and a group chat.
The usual answers are both bad. Off-the-shelf software makes you reshape your process around assumptions somebody else made about a company that isn't yours. Building an in-house team is slow and expensive, and hard to justify for software that isn't the product you sell.
We're the third option. We build the specific tool your team needs, ship it to production, document it, and hand you the keys. Then you own it outright.
Four things, done properly
Most engagements are a combination of these rather than one in isolation — a dashboard usually needs integrations behind it, and a CRM is an internal tool with a pipeline attached.
Analytics dashboards
Live views of the numbers your team makes decisions with, pulled from the systems that already hold them.
Real-time metrics
Live figures, not yesterday's export
Custom reporting
The cuts your team actually asks for
Data pipelines
Scheduled and event-driven ingestion
Role-based views
People see only their own numbers
Exports & alerts
PDF, CSV and threshold notifications
Outcome
A dashboard your team opens every morning.
Custom CRMs
Pipelines, records and workflows modelled on how your team actually sells or supports — not on someone else's template.
Custom pipelines
Stages that match how you really sell
Records & relationships
Your objects, fields and links
Workflow automation
The repetitive parts, handled
Email & calendar
Integrated where it earns its keep
Activity history
Notes, ownership and full audit trail
Outcome
A CRM that matches your process on day one.
Internal tools
The back-office software that replaces spreadsheets, manual copy-paste, and the one person who knows how it works.
Admin panels
Safe interfaces over your database
Approval flows
Multi-step sign-off with a paper trail
Audit logging
Who changed what, and when
Bulk operations
Guardrails on destructive actions
Granular permissions
Down to the individual record
Outcome
Operational software your team trusts with real data.
Data & integrations
The plumbing that moves data between systems reliably, including the parts that fail quietly at three in the morning.
REST & webhooks
Two-way sync between services
Third-party APIs
Vendor integrations and migrations
Background jobs
Queues, retries and dead letters
Schema migrations
Moved without downtime
Backfills & clean-up
Historic data made trustworthy
Outcome
Systems that talk to each other without babysitting.
You probably recognise one of these
Different starting points, same underlying problem — the software your team relies on doesn't fit the way your team works.
Teams outgrowing spreadsheets
The process works, but it lives in a shared sheet that breaks when two people open it. You need the same logic as real software with real permissions.
Companies stuck with generic SaaS
You pay monthly for a tool that does 60% of the job and forces workarounds for the rest. Replacing it costs less than you would think.
Products that need an admin side
The customer-facing product exists. What's missing is the internal console your team needs to actually operate it day to day.
Engineering teams short on capacity
You know exactly what needs building and have no one free to build it. We work inside your repository and your process.
Built, shipped, and running
We keep this section short and honest. Everything below is software that exists and is in use — not concepts, and not work we only advised on.
TradeFlow
In-house product · Live in productionA platform that mirrors trading activity from one brokerage account across many others in real time, with per-account risk rules, live portfolio analytics and full subscription billing. We designed it, built it, and run it ourselves — so every decision in it is one we had to live with.
The hard part
Replicating activity between accounts is easy to demo and hard to operate. Connections drop, source accounts go quiet, position sizes have to be recalculated per destination, and billing has to actually stop service when a payment fails. Most of the work is in the failure cases.
What we built
- Real-time replication from a source account to many destinations over persistent streaming connections
- A risk engine with three independent position-sizing modes and configurable fallback behaviour when a source trade arrives without a stop loss
- Multi-tenant data model with row-level security, so one customer's accounts are invisible to every other customer
- Full subscription lifecycle — checkout, plan changes, cancellation, failed payments, and automatic enforcement that suspends service and releases paid infrastructure when a subscription lapses
- Ten transactional email templates triggered from both the app and server-side billing webhooks
- An admin console covering users, subscriptions, connected accounts and trade history
Stack
- Frontend
- Next.js 14, React 18, TypeScript, Tailwind CSS, TanStack Query, Framer Motion
- Backend
- Python 3.11, FastAPI, Uvicorn
- Data
- Supabase (PostgreSQL), row-level security policies
- Payments
- Stripe subscriptions, webhook-driven state
- Integrations
- MetaApi real-time MT4/MT5 streaming, Resend
- Infrastructure
- Vercel, Railway
Risk configuration
Per-account configuration from the same platform. Three position-sizing modes, hard limits, and an explicit choice of what should happen when an incoming trade is missing a stop loss — the kind of screen where a wrong default costs somebody real money.
Next.js · TypeScript · Tailwind CSS
How a project runs
Four stages. You get something concrete at the end of each one, and you can stop after any of them.
Discovery
We map the workflow, the data behind it, and the people who will use it every day. Usually this surfaces a simpler problem than the one you came in with.
You get
A written scope, a build plan, and a price.
Design
Wireframes first, then interface, so you can react to something concrete before a line of production code exists. Changing a screen is cheap. Changing a built feature is not.
You get
Clickable screens and an agreed visual direction.
Build
Production code shipped in reviewable increments to a staging URL you can open whenever you like. No month-long silences ending in a surprise.
You get
Working software you can use as it lands.
Handoff
Deployment, documentation and repository access. If you never speak to us again, everything still runs and someone else can pick it up.
You get
The code, the infrastructure, and no lock-in.
How we actually operate
You own the code
Repository, infrastructure and documentation are yours from the first commit. No licence fee, no proprietary runtime, nothing that stops another developer picking it up after us.
We'll tell you if you don't need us
Sometimes the fix is a setting in a tool you already pay for. We would rather give you that answer for free than sell you a build you did not need.
Scope before price
We don't quote a number before we understand the problem. Discovery is a real deliverable with a written scope attached — useful even if you stop there and build it elsewhere.
You work with the people who build it
No account manager sitting between you and the person writing the code. The people in the first call are the people in the repository.
How we work together
Three ways to bring us in. Scope and cost are agreed in writing before any build starts, so there is no open-ended meter running.
Fixed-scope project
Let's talk
A defined deliverable, an agreed timeline, and a price set before anyone starts.
- Scoped and quoted after discovery
- Milestone-based delivery and invoicing
- Change requests priced separately, never absorbed silently
Best for
A known, bounded build with a clear finish line.
Monthly retainer
Let's talk
Ongoing design and development capacity, reserved for you and billed monthly.
- A set amount of capacity each month
- Reprioritise at the start of every cycle
- Rolling — cancel with notice, no long lock-in
Best for
A product that keeps evolving after launch.
Embedded team
Let's talk
We work inside your team, your tools and your existing process.
- Your repository, your stack, your rituals
- Direct collaboration with your engineers
- Code review and handover built in from the start
Best for
Adding capacity to a team that already has direction.
How long does a project take?
It depends entirely on scope, and we won't pretend otherwise before understanding yours. Discovery ends with a written timeline you can hold us to, and you see that timeline before committing to the build.
What does it cost?
Fixed-scope work is priced up front, once discovery has told us what the work actually is. Retainers and embedded work are billed monthly. We give you a number in writing before any build starts, and we would rather quote accurately than quote fast.
Can you work with our existing codebase?
Yes. Most work of this kind is extending or replacing something that already exists rather than starting from an empty repository. We'll read what you have before proposing anything.
Who owns the code and the infrastructure?
You do, throughout. We work in your repository and your cloud accounts where possible, or hand both over completely at the end if we start in ours.
What happens after launch?
Handoff includes deployment and documentation, so you are not dependent on us. If you want us to stay involved for changes and maintenance, that becomes a retainer.
Do you work with our designer or design system?
Yes. If you already have a design system or a designer, we build to it. If you don't, design is part of the engagement.
Will you sign an NDA?
Yes, and we'll sign yours rather than insisting on our own paperwork.
What don't you do?
We're not the right people for brand identity work, native mobile apps, or anything that needs a large agency team. If your project is one of those, we'll say so early rather than three weeks in.
Got something that needs building?
Tell us what your team is working around today. We'll tell you straight whether we're the right people to fix it — and if we aren't, we'll say so.