I have more side projects than I'd like to admit. Most developers I know do too: the thing that pays the bills, the thing that might pay the bills next year, and three ideas sitting in a folder called experiments.
Every one of them has users. And at some point, every one of them needs a CRM: who signed up, who's on which plan, who I promised a feature to, who went quiet after their trial.
That's where it always went wrong for me.
The CRM asks you to become a different business
Open any mainstream CRM and the first hour looks the same:
- Create "contacts". Decide which of your fields map to theirs.
- Export a CSV of your users. Import it. Fix the columns it guessed wrong.
- Create custom fields for the things that actually matter to your product: plan, usage, sign-up source, whatever your schema already says.
- Wire up Zapier, a webhook, or a sync job so the data doesn't go stale by Friday.
- Watch it go stale anyway.
None of that is selling or supporting customers. It's translation work. Your database already knows exactly who your customers are. The CRM just doesn't speak its language, so you end up reshaping your business into theirs: their idea of a contact, their pipeline stages, their field types.
For one product, that's annoying. For several, it's a tax on every idea you have.
The many-ideas problem
Here's what running a few projects through a traditional CRM actually looks like:
- Either you cram everything into one workspace, and spend your days filtering "is this a Project A user or a Project B user?" with a custom field you keep forgetting to set.
- Or you set up a separate CRM for each one, and repeat the import → map → sync → babysit dance every time. Per seat. Per workspace. So the new idea never gets a CRM at all. Its first users live in a spreadsheet, a Notion page, or your head. Which is exactly when you most need to remember who they are and what they asked for.
The friction isn't the price tag on its own. It's that setting up a CRM is a project, and you already have enough of those.
Flip it: the CRM adapts to your app
I built Clivly around one idea: the CRM should read your schema, instead of asking you to rebuild it.
You install a package in the app you already have:
npm install clivly
npx clivly init # detects your framework, ORM and auth, then pairs the app
npm run dev # starting the app is what connects it
init reads your Drizzle schema and asks which table holds your customers. For one app that's users. For another it might be participants, accounts or members. Whatever you already called it. Your columns become the CRM's fields: plan, status, sign-up date, the things you'd otherwise have recreated as custom fields by hand.
What that means in practice:
- No CSV. Your users show up in the CRM because they're in your app.
- No custom-field busywork. Your schema is the field list. Add a column, and the CRM knows about it.
- No sync job to babysit. Clivly keeps pulling from your app, so the record your team is looking at matches what your app knows.
- Your tables stay yours. clivly init doesn't create tables or touch your ORM schema, and the CRM never writes to your business tables.
- Then your team gets on with the actual CRM work at clivly.com: contacts and companies, deal pipelines, tasks, a shared inbox, notes, and email to the people your app already knows.
One account, a workspace per idea
This is the part I built for myself.
In Clivly, every project gets its own workspace, and all your workspaces live in one account behind a switcher. Each workspace connects one app, with its own contacts, pipeline and team, so Project A's users never bleed into Project B's.
Spinning up a CRM for the new idea is the same three commands, not another afternoon of imports.
90 days free for every new idea
A pre-revenue experiment shouldn't cost the same as the product that pays your bills. So once you have one paid workspace, every workspace you add after it is free for its first 90 days.
Ninety days is roughly what it takes to get a project off the ground: ship it, get your first users in, follow up with them, and see whether anyone pays. The point is that the idea gets a real CRM from day one, and the chance to make its first revenue before it costs you anything.
When the 90 days are up you choose: start paying for that workspace, or park it. A parked workspace is kept read-only, so nothing you recorded is lost if you come back to the idea later. (Each workspace is billed on its own; I'd rather be clear about that up front.)
Email marketing, built on the data you already have
Getting your first users is one problem. Growing an audience is the next one, and for most apps that means email: a launch announcement, an onboarding series, a "here's what's new" update, a nudge for people who signed up and never came back.
The usual answer is another tool. Export your users again, import them into Mailchimp or Brevo, rebuild your segments there, and hope the two lists don't drift apart. Then try to work out who unsubscribed where.
In Clivly it's the same contacts and the same data:
Campaigns with a visual editor and your brand kit (logo, colours, footer), sent from your own domain.

Segments built from your app's fields. "On the free plan, signed up over 30 days ago, hasn't logged in this week" is a filter on columns Clivly already reads. Segments stay live, so a scheduled campaign goes to whoever matches on the day it sends.
Sequences for onboarding and follow-ups: a series of emails that stops on its own when someone replies.
Consent handled properly. Opt-ins (including double opt-in) and unsubscribes are tracked per contact, and anyone who opted out is never sent bulk email, whatever your sync says.
Replies come back to the CRM, into the shared inbox and onto the contact's timeline, next to their deals and notes.
One-to-one email is included with every member. Bulk email (campaigns and sequences) is priced by how many you send a month, starting at $15 for 1,500, and Scale includes 5,000. It doesn't eat into AI credits.
Where it fits, honestly
Today: TypeScript apps on Drizzle + Postgres, with TanStack Start and Next.js as the main targets. Prisma, Kysely and raw SQL work by writing a small fetch function instead of the generated config.
Not trying to be: the cheapest CRM on earth, or Salesforce. If you want a free self-hosted CRM in its own container, there are good ones.
Trying to be: the CRM that already knows your customers, because it reads the same database your app does.
The client packages are MIT, so you can read every line of what you're putting in your app.
Try it
If you've got a project (or five) with users and nowhere good to keep track of them:
👉 clivly.com: 14-day trial, no card.
Launching on Product Hunt on 23 November. Code FOUNDING30 gets founding pricing until 29 November.
I'd genuinely like to hear how you handle this today. Spreadsheet? One giant HubSpot? Nothing at all? Tell me in the comments. It'll shape what I build next.
Top comments (0)