CRM for Technical Founders Who Hate CRM

You built the product. You understand the architecture. You can read a stack trace and have opinions about database indexes. And then someone tells you to "update your CRM" and you'd rather rewrite the auth system from scratch.

That's fair. Most CRMs are hostile to technical people. They're designed for salespeople who need guided workflows, not engineers who want to query a database. Let's talk about what's actually wrong with traditional CRMs, what you actually want, and why DenchClaw was basically built for people like you.

Why Technical Founders Hate Traditional CRMs#

It's not irrational. Here's the actual list of complaints:

Too much clicking, not enough power#

You can write a SQL query that answers any question about your data in 30 seconds. But in Salesforce, you have to navigate to Reports, create a new report type, drag fields into columns, add filters, save the report, run it, and then squint at the output. For a question you'll never ask the same way again.

Pipedrive has a slightly better UI but the same fundamental problem: it's built for people who think a "report" means a bar chart with three options.

Data locked away#

You know your data is in there. You just can't get to it in a useful form. The export button gives you a CSV with 47 columns and inconsistent naming. The API requires OAuth and has a weird nested object format. There's no way to just SELECT * FROM deals WHERE stage = 'proposal'.

This drives technically-minded people insane. Your data should be queryable. Full stop.

Monthly fees for features you'll never use#

HubSpot's starter tier doesn't include the features you might actually want (custom reports, API access). The tiers that have those features cost $800/month. You're paying for a UI that you'd rather replace with a terminal anyway.

No hackability#

You want to extend your CRM to do new things. Add a custom field, write a script that enriches leads from LinkedIn, build a dashboard that shows pipeline health. In Salesforce, this requires learning Apex (Salesforce's proprietary Java-ish language). In HubSpot, you get "workflows" — a visual builder that can do about 15% of what you'd want.

Neither of these is acceptable for someone who writes code for a living.

What Technical Founders Actually Want from a CRM#

Let's be concrete:

1. SQL access to your own data. Not a report builder. Not a CSV export. SELECT statements.

2. A real API. Not a rate-limited REST API with 47 endpoints you have to figure out. Something you can curl.

3. Local-first. Your data shouldn't live on someone else's server. If you want to query 10 million records, you should be able to, without paying $500/month for "enterprise" tier.

4. Extensible. You should be able to add fields, create objects, write scripts, build dashboards — without learning a proprietary platform.

5. Free or cheap. You built a product. You know what software actually costs to run. $75/user/month for a contact database is offensive.

6. Open source, ideally. You want to be able to read the code, find bugs, contribute fixes, and not worry about the vendor shutting down or changing the pricing.

DenchClaw is all of these things.

The CRM That Respects Your Technical Intelligence#

DenchClaw is built on DuckDB — an embedded analytical database that runs locally on your machine. Your CRM data is a .duckdb file on your filesystem. You own it. You control it. You can query it directly with SQL.

duckdb ~/.openclaw-dench/workspace/workspace.duckdb
 
# Now you're in a SQL shell
SELECT name, email, status, created_at
FROM v_person
WHERE status = 'lead'
  AND created_at > now() - INTERVAL '7 days'
ORDER BY created_at DESC;

That's it. No report builder. No dashboard wizard. Just SQL.

You can also query from your Node.js scripts, Python scripts, or any DuckDB client. Direct file access, no server needed.

Building Custom Views with SQL#

DenchClaw creates flat PIVOT views for each object type (v_person, v_company, v_deal). But you can write your own views for the analyses you run frequently:

-- High-value pipeline by company
CREATE VIEW v_hot_pipeline AS
SELECT
  c.name AS company,
  count(d.id) AS deal_count,
  sum(CAST(d.value AS DECIMAL)) AS total_value,
  max(d.close_date) AS latest_close,
  string_agg(d.stage, ', ') AS stages
FROM v_company c
JOIN v_deal d ON d.company_id = c.id
WHERE d.stage NOT IN ('closed_won', 'closed_lost')
GROUP BY c.name
HAVING sum(CAST(d.value AS DECIMAL)) > 10000
ORDER BY total_value DESC;

Save these views as .sql files in your workspace. Run them with:

openclaw db run ./views/hot-pipeline.sql

Or add them to a cron job to get a daily Slack message with your pipeline status:

openclaw db query "SELECT * FROM v_hot_pipeline" --format json | \
  jq '.[] | "• \(.company): $\(.total_value) (\(.deal_count) deals)"' | \
  xargs -I{} curl -X POST $SLACK_WEBHOOK -d "{\"text\": \"{}\"}"

The CLI Interface#

If the thought of opening a GUI CRM makes you tired, you'll appreciate that DenchClaw is almost entirely terminal-driven.

# Add a contact
openclaw message "Add contact: John Doe, john@example.com, CTO at Example Inc, status=lead"
 
# Query the pipeline
openclaw db query "SELECT name, stage, value FROM v_deal WHERE stage != 'closed_lost'"
 
# Run lead enrichment
openclaw skill run browser-automation "Find LinkedIn profiles for all leads missing a linkedin_url"
 
# Export for analysis
openclaw db query "SELECT * FROM v_person" --format csv > contacts.csv
 
# Ask questions in English
openclaw message "Which companies have been in 'proposal' stage for more than 30 days?"

Your CRM is a combination of SQL for precise queries, natural language for quick questions, and shell scripts for automation. All from a terminal. No GUI required unless you want one.

Building Enrichment Scripts#

Technical founders don't just use CRMs — they build on top of them. Here's an enrichment script that queries DuckDB for unenriched leads and calls the Hunter.io API:

npm install duckdb node-fetch

// enrich-leads.js
const duckdb = require('duckdb');
const fetch = require('node-fetch');
 
const db = new duckdb.Database(
  `${process.env.HOME}/.openclaw-dench/workspace/workspace.duckdb`,
  { access_mode: 'READ_ONLY' }
);
 
db.all(
  `SELECT id, name, email FROM v_person
   WHERE status = 'lead' AND linkedin_url IS NULL LIMIT 20`,
  async (err, rows) => {
    db.close();
    for (const row of rows) {
      const resp = await fetch(
        `https://api.hunter.io/v2/email-verifier?email=${row.email}&api_key=${process.env.HUNTER_KEY}`
      );
      const data = await resp.json();
      if (data.data?.status === 'valid') {
        await fetch(`http://localhost:3000/api/entries/${row.id}`, {
          method: 'PATCH',
          headers: {
            Authorization: `Bearer ${process.env.DENCH_TOKEN}`,
            'Content-Type': 'application/json'
          },
          body: JSON.stringify({ fields: { email_verified: true } })
        });
      }
      await new Promise(r => setTimeout(r, 500));
    }
  }
);

This is 40 lines of standard Node.js. No Salesforce Apex. No HubSpot workflow builder. Just code.

Contributing to the Open Source Codebase#

DenchClaw is MIT licensed and lives on GitHub. If you find a bug, you can fix it. If there's a feature you want, you can build it. If the enrichment script pattern you wrote is useful to others, you can contribute it as an example.

# Star the repo
gh repo star DenchHQ/denchclaw
 
# Clone and run locally
git clone https://github.com/DenchHQ/denchclaw
cd denchclaw
npm install
npm run dev

The codebase is TypeScript, built on Node.js, with DuckDB for storage. If you've used modern Node.js tooling, you'll be productive in the codebase within an hour.

Custom skills (the plugin system) are especially good contribution targets. A skill is a markdown file that teaches your agent a new capability. Writing one requires:

1. Understanding what you want the agent to do
2. Writing clear instructions in markdown
3. Testing it on your own data

No proprietary platform knowledge needed. Skills can be published to ClawHub (the skill registry) for others to install:

openclaw skill publish my-custom-skill

The DenchClaw Mental Model for Technical Founders#

Think of it this way:

• DuckDB is your CRM database. Query it directly with SQL.
• The agent is a natural language interface to that database. Ask questions, create entries, run reports — in English.
• Skills are plugins. They're markdown files that extend what the agent can do.
• The REST API is the programmatic interface. Write scripts that read/write your CRM data.
• Dench Apps are lightweight web UIs for dashboards and internal tools.
• MCP exposes your CRM to any AI tool that supports the protocol.

Each layer is optional. You can use just the SQL interface if that's all you want. You can use just the API if you're building automation. You can use the natural language interface if you want a convenient way to query on the go.

It's modular by design. Technical founders don't want a monolithic system that forces them to use its UI. DenchClaw gives you the data layer and lets you build around it however you want.

That's the CRM for people who build software for a living.

Ready to try DenchClaw? Install in one command: npx denchclaw. Full setup guide →