Build an Internal CRM in a Weekend

Most solo founders start with a spreadsheet. Then they add a second one. Then a third. Before long, client notes live in five different places, follow-up emails get missed, and the 'system' is held together by memory alone. The real problem is not a lack of tools — it is a lack of a single, intentional place where client information lives and moves.

You do not need Salesforce. You do not need HubSpot. What you need is a lightweight internal CRM built around how you actually work — and the good news is you can ship a working version over a single weekend.

What a Lean CRM Actually Needs

Before writing a single line of logic, it helps to define the minimum set of things a CRM needs to do for a solo operation. Strip away the noise and you are left with four core functions:

  • Contact records — who the person is, how to reach them, and what company or project they belong to
  • Status tracking — where each relationship stands in your pipeline (lead, proposal sent, active client, archived)
  • Interaction log — a simple timestamped history of calls, emails, or meetings
  • Next action — one clear field that tells you what to do next and when

That is the entire foundation. Everything else — tags, scoring, integrations — comes later if you actually need it.

Choosing the Right Backend Approach

For a weekend build, the stack should be boring and fast. Three approaches work well depending on your comfort level:

Option 1 — Airtable or Notion as the database, no-code frontend If you want zero backend work, Airtable gives you a relational database with API access out of the box. You can build views for each pipeline stage, set up automations for reminders, and even expose a simple form for adding new leads. This works well if your needs are mostly read/write and you do not need custom logic.

Option 2 — A lightweight app with a real database If you want more control, a simple app built on top of a Postgres or SQLite database gives you full ownership of your data and allows custom automation logic. Frameworks like Next.js or a minimal Python backend (FastAPI or Flask) let you ship a working internal tool quickly. You own the schema, the queries, and the display logic.

Option 3 — A hosted internal tool builder Tools like Retool, Appsmith, or Budibase let you connect a database and build a functional UI in hours without designing from scratch. This is the fastest path to a working interface if you are comfortable with SQL and basic configuration.

For most solo founders, Option 1 gets you live fastest. Option 2 is the right choice if you want to extend the system over time without hitting platform limits.

The Weekend Build Plan

Here is a concrete breakdown of how to approach this across two days.

Saturday — Data Model and Core Views

Start by defining your schema. Keep it minimal:

  • Contacts table: name, email, phone, company, source, created date
  • Deals table: contact ID, status, estimated value, last contact date, next action, next action date
  • Log table: deal ID, entry date, channel (email / call / meeting), notes

Spend the first morning setting this up in your chosen tool. If you are using Airtable, create the three tables and link them with relational fields. If you are building a real app, write the schema and run your first migration.

Saturday afternoon: build the two views you will actually use every day.

Pipeline view — a kanban or list grouped by deal status. You should be able to see at a glance what is in each stage and who needs attention.

Next actions view — filtered and sorted by next action date, showing only contacts where something is due today or overdue. This becomes your daily dashboard.

Sunday — Automation and First Integrations

A CRM without automation is just a fancy spreadsheet. Sunday is for adding the logic that makes it active.

Reminder automation: when a next action date passes and the status is still open, trigger a notification — email, Slack message, or SMS depending on your setup. In Airtable, this is a native automation. In a custom app, a simple cron job running every morning handles this in under 20 lines of code.

New lead intake: build a minimal form (a Typeform, a Tally form, or a plain HTML form posting to your backend) that writes directly to your Contacts table. When someone fills out your contact form on your website, the record appears in your CRM automatically — no copy-pasting.

Status change log: every time a deal moves from one stage to another, automatically write an entry to the Log table with a timestamp and the old/new status. This gives you a clean audit trail without any manual effort.

If you finish those three automations, your CRM is genuinely functional. Everything else is polish.

One Field That Changes Everything

The single most impactful field in any lean CRM is the next action field — not a to-do list, not a set of tags, just one plain-text field that answers the question: what is the one thing I need to do next with this person, and by when?

When every deal has a clear next action with a date, the pipeline stops being a passive archive and becomes an active system. You stop relying on memory. You stop missing follow-ups. The CRM tells you what to do each morning instead of waiting for you to remember.

This sounds obvious, but most founders skip it or bury it under layers of other fields. Make it prominent. Make it required. Build your daily view around it.

Keeping It Alive

The most common failure mode for internal tools is abandonment. You build it, use it for two weeks, then drift back to the spreadsheet because updating the CRM feels like overhead.

The fix is reducing the friction of entry to near zero. A few principles that help:

  • Log from wherever you already are — add a quick-add shortcut or browser bookmark that opens a pre-filled form. The fewer clicks between a call ending and the log entry appearing, the better.
  • Weekly review, not daily maintenance — do not try to keep the CRM perfectly up to date in real time. Instead, build a 15-minute Friday habit: update statuses, clear overdue actions, archive dead leads.
  • Never add a field you do not query — every field that sits empty is a reminder that the system is incomplete. Add fields only when you find yourself actually needing the data.

Conclusion

A lean internal CRM is not a software project — it is a decision about how you want to manage relationships. The tool can be simple. The logic can be minimal. What matters is that it is yours, it fits your workflow, and it removes the mental overhead of tracking everything in your head.

Two days of focused work is enough to go from scattered spreadsheets to a functional, automated system that tells you what to do next. That is the kind of infrastructure that compounds over time — every week slightly less friction, every month slightly fewer missed opportunities.

If you want help designing or building an internal tool like this for your studio or business, get in touch with Pillet Grenié Bureau. We build lean digital systems for founders who want to operate smarter.