DenchClaw for Job Search: Track Applications and Contacts

A job search is a sales process where you're the product. Like any sales process, it benefits from a CRM: structured tracking of your pipeline, clear visibility on where each opportunity stands, and systematic follow-ups that keep you moving. DenchClaw — a local-first, open-source AI CRM — is a surprisingly powerful tool for job searching. Here's how to set it up.

What is DenchClaw? — DuckDB-backed, runs on your machine, free. If you're new, start there.

Why most job seekers don't track properly#

The default approach to job searching looks like this: a pile of browser bookmarks, a vague memory of what you applied to last week, a hope that someone will email you back, and a slowly growing panic as interviews multiply.

This is chaos. It produces missed follow-ups, forgotten deadlines, duplicate applications, and an inability to spot patterns in your pipeline ("Why does my response rate drop after I mention X in my cover letter?").

A job search managed in DenchClaw looks different:

• Every application tracked with status and timeline
• Every contact logged with interaction history
• Interview prep notes attached to company entries
• A Kanban board showing exactly where you stand
• SQL queries that let you analyze what's working

It takes 30 minutes to set up and pays back that time within the first week.

Step 1: Install DenchClaw#

npx denchclaw

Frontend at localhost:3100. First run initializes DuckDB locally.

Step 2: Set up your data model#

You need three core objects for a job search:

Applications#

The central object — one entry per job you've applied to or are considering.

Fields:

• company_name (text)
• role_title (text)
• job_url (url)
• status (select — see below)
• date_applied (date)
• source (select: LinkedIn, Referral, Company Site, Recruiter, Job Board, Other)
• salary_range (text)
• location (text)
• remote_policy (select: Remote, Hybrid, Onsite)
• next_action (textarea)
• next_action_date (date)
• notes (entry document)

Status options (your pipeline stages):

1. Bookmarked
2. Applied
3. Phone Screen
4. Technical / Skills Interview
5. Onsite / Panel
6. Final Round
7. Offer Received
8. Offer Accepted
9. Rejected
10. Withdrawn

Contacts#

People you know or are meeting at each company.

Fields:

• name (text)
• email (email)
• role (text)
• company (text — or relation to a Companies object)
• relationship (select: Recruiter, Hiring Manager, Interviewer, Referral, Employee, Alumni)
• last_contact_date (date)
• application (relation → Applications)
• notes (entry document)

Interactions#

Log every meaningful touchpoint — emails, calls, referral conversations.

Fields:

• date (date)
• type (select: Email, Call, Meeting, LinkedIn, Referral Request)
• contact (relation → Contacts)
• application (relation → Applications)
• summary (textarea)
• follow_up (textarea)
• follow_up_date (date)

Step 3: Set up the Kanban view#

This is the view you'll use most. Switch Applications to Kanban, grouped by status.

| Bookmarked | Applied | Phone Screen | Technical | Onsite | Final | Offer |
|------------|---------|--------------|-----------|--------|-------|-------|
| Role A     | Role D  | Role G       | Role I    | Role K |       |       |
| Role B     | Role E  | Role H       |           |        |       |       |
| Role C     | Role F  |              |           |        |       |       |

Drag cards as your status changes. At a glance, you see your full pipeline.

Color-code by role type or company size if you're applying across multiple tracks (e.g., startup vs. large company).

Step 4: Use entry documents for interview prep#

Every application entry has a markdown document. Use it as your interview prep file:

# Acme Engineering — Senior Software Engineer
 
## Role Context
Full-stack role, Python/TypeScript stack. Small team (8 engineers). 
Working on data pipelines for enterprise customers. Series B ($40M raised).
 
## Why I'm Interested
- Technical challenge matches my background (distributed systems)
- Small team = high ownership
- Sector (data infrastructure) aligns with my experience
 
## Research
- Founded 2021, YC S21 alumni
- Main competitor: DataCo (they differentiate on latency)
- Recent news: hired new VP of Sales in Jan 2026 — growth phase
 
## Interviewers
- Round 1: Sarah (recruiter) — ask about team structure
- Round 2: James (hiring manager, VP Eng) — prepared questions below
- Round 3: Panel with 2 engineers
 
## Questions I want to ask
- What does success look like in the first 90 days?
- How does the team handle on-call? What's the incident rate?
- What's the growth path for this role?
- Why is this role open now?
 
## Interview notes
Mar 15 - Phone screen with Sarah. Went well. She mentioned they want 
someone with Kafka experience specifically — highlight in next round.
 
Mar 22 - Technical with James. Discussed distributed system design. 
He seemed interested in my work at BuilderCo. Follow up with case study.
 
## Offer details
Base: $180K  
Equity: 0.3% (4yr vest, 1yr cliff)  
Bonus: Up to 15%  
Decision deadline: Mar 30

This is richer prep than any spreadsheet or notes app provides. All in one place, attached to the structured fields.

Step 5: Log every interaction#

After every call, email exchange, or message — log it in Interactions. This takes 2-3 minutes.

Over time, this creates a searchable history of every touchpoint in your search. Useful when:

• You can't remember if you already emailed someone
• You're following up and want to reference what you discussed last time
• You want to analyze patterns in your process

-- Response rate by application source
SELECT source, 
  COUNT(*) as applied,
  COUNT(CASE WHEN status != 'Applied' AND status != 'Bookmarked' THEN 1 END) as progressed,
  ROUND(100.0 * COUNT(CASE WHEN status != 'Applied' AND status != 'Bookmarked' THEN 1 END) / COUNT(*), 1) as response_rate_pct
FROM v_applications
WHERE date_applied IS NOT NULL
GROUP BY source
ORDER BY response_rate_pct DESC;

This tells you whether referrals are outperforming cold applications (they almost always are, by a lot).

Step 6: Follow-up workflow#

The biggest difference between systematic job searchers and haphazard ones is follow-up discipline.

After every application or interaction, set a next_action_date. In DenchClaw, set up a Table view filtered by next_action_date <= today, sorted ascending. This is your daily work queue.

Typical follow-up schedule:

• No response after 5-7 days: Follow up once on application
• Post-phone screen: Thank you email within 24 hours, reference something specific from the conversation
• Post-technical round: Follow up within 48 hours if you haven't heard
• Awaiting decision: Gentle check-in after their stated timeline passes

DenchClaw's AI action fields can draft these follow-ups for you, pulling context from the entry document and interaction history.

Step 7: Track your contacts strategically#

Warm introductions have a dramatically higher response rate than cold applications. Use DenchClaw to map your network to your target companies.

-- Which target companies do I have connections at?
SELECT a.company_name, a.role_title, c.name as contact, c.relationship
FROM v_applications a
JOIN v_contacts c ON c.application_id = a.id
WHERE c.relationship IN ('Referral', 'Employee', 'Alumni')
AND a.status IN ('Bookmarked', 'Applied')
ORDER BY a.company_name;

For every company you're targeting, ask yourself: do I know anyone there? Can I get a referral? Often one degree of separation is enough — a mutual contact who can forward your resume with a note is worth 20 cold applications.

Analytics on your job search#

Because everything is in DuckDB, you can run analyses that spreadsheets can't easily handle:

-- Pipeline funnel
SELECT status, COUNT(*) as count
FROM v_applications
GROUP BY status
ORDER BY CASE status
  WHEN 'Bookmarked' THEN 1
  WHEN 'Applied' THEN 2
  WHEN 'Phone Screen' THEN 3
  WHEN 'Technical' THEN 4
  WHEN 'Onsite' THEN 5
  WHEN 'Final Round' THEN 6
  WHEN 'Offer Received' THEN 7
  WHEN 'Rejected' THEN 8
  ELSE 9
END;
 
-- Average time from application to first response
SELECT 
  AVG(DATEDIFF('day', date_applied, first_response_date)) as avg_days_to_response
FROM v_applications
WHERE first_response_date IS NOT NULL;
 
-- Applications by week
SELECT DATE_TRUNC('week', date_applied) as week, COUNT(*) as applications
FROM v_applications
GROUP BY week
ORDER BY week;

These queries surface real signal: Are you applying enough? Where are you losing candidates? Which sources convert?

For more on managing pipeline views, see DenchClaw Kanban for tips on configuring your board optimally.

Tips for making this stick#

Log as you go, not at the end of the week. Context is freshest immediately. A 2-minute log right after a call is worth more than a 20-minute reconstruction days later.

Use the entry document before every interview. Open the document, read your notes, review your questions, refresh your research. Walk in prepared.

Do a weekly review. Every Sunday (or Monday morning), open your Kanban, check next_action_dates, identify what needs follow-up. 15 minutes keeps the whole system current.

Track rejections honestly. A rejection entry with notes on why (wrong level, different background needed, role cancelled) helps you calibrate your targeting over time.

See best personal CRM in 2026 for how DenchClaw compares to other tools for job search use cases.

FAQ#

Isn't a spreadsheet good enough for job searching? For 5-10 applications, sure. For a serious search with 30+ active applications, multiple contacts per company, and weeks of follow-ups, a spreadsheet becomes a bottleneck. DenchClaw gives you Kanban views, relational data (contacts linked to applications), and query-level analysis — all locally.

How long does it take to set this up? About 30 minutes to create the objects and fields. Then 5-10 minutes per week to maintain. The upfront investment is minimal.

Can I use DenchClaw alongside LinkedIn? Yes — DenchClaw is your record of truth; LinkedIn is your research tool. Use the browser agent to pull job details from LinkedIn directly into application entries.

What if I'm applying to 100+ roles? That level of volume is actually where the Kanban and SQL views become essential. You can't hold a 100-role pipeline in your head. DenchClaw can.

Should I track companies I've rejected myself? Absolutely. Note why you decided not to pursue them (comp too low, poor culture signals, role not a fit). If they re-approach you later or have a different role open, you want that context.

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