How to Build an AI-Powered Job Search Dashboard with OpenBrain and Claude

Why Spreadsheets Fail Job Seekers — and What to Do Instead

Most people start a job search with a spreadsheet. It works for about a week. Then columns multiply, rows fall out of order, and the things that actually matter — who referred you where, which application closes Friday, which contact hasn’t heard from you in three weeks — get buried.

An AI-powered job search dashboard fixes this by replacing the static spreadsheet with a living system: structured data your AI agent can read, update, and reason across in real time.

This guide walks through building that system using MindStudio’s OpenBrain shared database and Claude as the reasoning model. When you’re done, you’ll have a dashboard that tracks companies, contacts, applications, and interviews — and an agent that surfaces warm introduction paths and flags expiring deadlines automatically, without you having to ask.

What You’ll Build

The dashboard has four core data objects and one active AI reasoning layer sitting on top of them.

The Four Data Objects

Companies — Each record holds the company name, industry, size, your target roles there, notes on culture fit or research, and a pipeline status (researching, applied, interviewing, offer, closed).

Contacts — Linked to companies. Each contact has a name, current role, relationship strength (cold/warm/close), last contact date, and notes on how you met or who introduced you.

Applications — Linked to companies. Each record tracks the specific role, submission date, application deadline, current status, and the job posting URL.

Interviews — Linked to both applications and contacts. Tracks interview type (phone screen, technical, panel), date, interviewer names, prep notes, outcome, and whether a follow-up was sent.

What the Agent Does

Claude, connected to OpenBrain, does three things a spreadsheet can’t:

Finds warm intro paths — Given a target company, it queries your contacts and surfaces the best path to an introduction — direct connections first, then second-degree options through your close contacts.
Flags expiring windows — It checks application deadlines and interview follow-up timelines, then surfaces anything that needs action in the next 48–72 hours.
Prioritizes your pipeline — On request, it ranks your active opportunities by a combination of role fit, relationship strength, and deadline urgency.

What You Need Before You Start

Before building, make sure you have:

A MindStudio account (free to start at mindstudio.ai)
Basic familiarity with the MindStudio visual builder — if you haven’t used it before, 15 minutes on a sample project helps a lot
A list of 5–10 target companies to seed your initial data (you can always add more)
Any existing job search notes or data you want to import — rough notes are fine, you don’t need clean records

You don’t need to know how to code. Everything in this build uses the visual editor and pre-built integrations.

Step 1: Define Your OpenBrain Schema

OpenBrain is MindStudio’s shared persistent data layer. Think of it as a structured database your agents can read from and write to across sessions. Unlike a regular variable — which only exists during a single agent run — data stored in OpenBrain persists between conversations and is accessible to any agent in your workspace.

Start by defining your four tables.

Set Up the Companies Table

In your MindStudio workspace, open OpenBrain and create a new table called Companies. Add these fields:

company_name (text)
industry (text)
size (select: startup / mid-size / enterprise)
target_roles (text)
status (select: researching / applied / interviewing / offer / closed / not pursuing)
notes (long text)
date_added (date)

Set Up the Contacts Table

Create a Contacts table with:

full_name (text)
company_name (linked to Companies)
role (text)
relationship (select: cold / warm / close)
last_contact_date (date)
intro_source (text — who introduced you or how you met)
notes (long text)

Set Up the Applications Table

Create an Applications table with:

company_name (linked to Companies)
role_title (text)
submission_date (date)
deadline (date)
status (select: drafting / submitted / under review / phone screen / interviews / offer / rejected / withdrawn)
job_posting_url (text)
notes (long text)

Set Up the Interviews Table

Create an Interviews table with:

application_id (linked to Applications)
interview_type (select: phone screen / technical / case / panel / final round / other)
date (date)
interviewers (text)
prep_notes (long text)
outcome (select: pending / passed / failed / no response)
follow_up_sent (yes/no)
follow_up_date (date)

Once these four tables exist, your agent has a structured knowledge base to query. Claude can run across all four tables simultaneously to answer questions like “Which companies do I have warm contacts at that I haven’t applied to yet?” — which is exactly what makes this system worth building.

Step 2: Build the Data Entry Agent

The fastest way to fall behind on a job search tracker is when updating it feels like work. This step builds an agent that accepts natural language input — a quick note, a forwarded email, a pasted job description — and writes the structured records for you.

Design the Input Interface

In MindStudio’s visual builder, create a new AI app. Keep the interface minimal:

A single text input labeled something like “Tell me what happened” or “Add a note, application, or contact”
A display area that confirms what was saved
Optional: a recent activity section showing your last five updates

The point is that updating the dashboard should take 30 seconds. If it takes five minutes, you’ll stop doing it.

Write the Claude Extraction Prompt

Configure the agent with Claude — available natively in MindStudio, no API key needed — and set a system prompt along these lines:

You are a job search tracking assistant. The user will give you unstructured 
information — a new company they're targeting, a contact they met, an 
application they submitted, or an interview they completed.

Your job is to:
1. Identify what type of record this is (company, contact, application, 
   or interview).
2. Extract the relevant fields from the user's input.
3. Check whether a related record already exists in OpenBrain 
   (the company must exist before a contact can be linked to it).
4. Write the structured record to the correct table.
5. Confirm what was saved and flag any missing fields to fill in later.

If the input contains information for multiple record types, handle both.

The OpenBrain integration handles the actual read/write operations. Your Claude prompt just describes the logic.

Handle Ambiguous Input

Add a fallback instruction for cases where Claude isn’t sure what the user means:

If you're unsure which record type applies, or which existing record to link 
to, ask one clarifying question before proceeding. Don't guess at links 
between records.

This prevents the most common data quality problem in builds like this: mislinked records that make the reasoning layer unreliable. One clarifying question is far less painful than debugging bad data later.

Step 3: Build the Reasoning Layer

The reasoning layer is a second workflow — or a second mode within the same agent — that runs on demand or on a schedule. Its job is to look across all four tables and surface insights.

Surface Warm Introduction Paths

Create a workflow that accepts a company name as input and does the following:

Query Contacts for anyone where company_name matches
Query Contacts for anyone with relationship = “close” or “warm” who might know someone at the company
Query Companies for the current status and existing notes

Feed that data to Claude with a prompt like:

Given the user's contacts and their notes about this company, identify the 
most promising path to a warm introduction.

Consider:
- Direct contacts at the company (any relationship strength)
- Close contacts who might know someone there (second-degree)
- Notes about how the user met these contacts and whether an introduction 
  ask would be appropriate

Return 1–3 recommended actions, each with a specific suggested next step.
For example: "Message Sarah Kim — you met at the Austin UX meetup, she 
worked at [Company] until 2022 and likely knows the current hiring manager."

This is the part that justifies the whole build. A spreadsheet can’t do this reasoning. Claude can, as long as it has structured data to work with.

Flag Expiring Windows

Create a scheduled workflow (MindStudio supports cron-style scheduling) that runs daily and checks:

Applications where deadline is within 7 days and status is still “drafting”
Interviews where follow_up_sent = no and date was more than 48 hours ago
Contacts where last_contact_date is more than 30 days ago and the linked company is in “interviewing” status

For each match, Claude generates a short action item in plain language. Push these to your preferred channel — Slack, email, or a digest displayed in the app. MindStudio has direct integrations with both Slack and Gmail, so routing notifications is a configuration change, not a new build.

Prioritize Your Active Pipeline

Add a “show me my priorities” command that queries all open applications and interviews, then asks Claude to rank them:

Given the user's open applications and interviews, rank their top 5 
priorities for today. Weight by:
1. Urgency (deadline within 7 days = high, interview this week = critical)
2. Relationship strength at the company (warm/close contacts = higher priority)
3. Role fit based on notes in the Companies table

Return a numbered list with one sentence of reasoning per item.

Run this at the start of each job search session. It replaces the mental overhead of figuring out where to focus.

Step 4: Set Up Notifications and Automated Updates

A dashboard you don’t check doesn’t help. This step makes the system reach out to you rather than requiring you to remember to log in.

Configure a Daily Digest

Set up a scheduled agent in MindStudio that runs every morning. It queries OpenBrain, runs the expiring-windows check and the priority ranking, then sends a formatted email or Slack message with:

Your top 3 priorities for the day
Any expiring deadlines or overdue follow-ups
Any active applications that haven’t had contact activity in 10+ days

Keep the digest short — three to five items, plain language, one clear action per item. The goal is easy to act on, not exhaustive.

Automate Status Updates from Email

For a more connected setup, add an email-triggered workflow that watches for specific patterns (subject lines containing “interview,” “offer,” “application received”). When a match arrives, Claude extracts the relevant information and updates the correct record in OpenBrain automatically.

This is optional but meaningful. The hardest part of any tracking system is keeping it current, and automating even half of your status updates saves real time over the course of a search. MindStudio’s email-triggered agent type makes this straightforward to configure.

How MindStudio Makes This Build Accessible

Everything described above — the OpenBrain schema, the data entry agent, the reasoning layer, the scheduled digest — can be built in MindStudio without writing any code.

The visual workflow builder lets you chain together data reads, Claude calls, and integrations using a drag-and-drop interface. For a build this scope, expect one to three hours the first time. Less if you start from a template.

A few specifics worth knowing:

Claude is built in. You don’t need an Anthropic account or API key. Claude — and over 200 other models — is available natively through MindStudio. Pick it from a dropdown, configure the prompt, and connect it to OpenBrain in the same workflow.

OpenBrain is designed for this. It’s built specifically for agents that need to persist and reason over structured data across sessions. Records are directly queryable by the agent with no glue code required. This is different from storing data in an external Airtable or Notion database, where you’d need to configure and maintain a separate connection.

Integrations handle everything else. Slack, Gmail, Google Calendar, Notion, Airtable — these are all available as pre-built integrations in MindStudio’s library of 1,000+ connections. Routing your daily digest to a different channel or adding a new notification trigger is a configuration change, not a rebuild.

If you want to explore the platform before committing to a full build, MindStudio’s AI automation guides include templates and examples for data tracking workflows you can adapt directly.

You can start building for free at mindstudio.ai.

Common Mistakes to Avoid

Even with the right tools, a few patterns cause problems in builds like this.

Over-engineering the schema upfront. Start with the four tables and the fields listed above. Don’t add 20 custom fields on day one — you won’t use most of them, and they’ll make data entry slower. Add fields when you discover a real need for them.

Vague Claude prompts. The more specific your prompts, the more consistent the output. If Claude is returning imprecise records, add examples to the prompt showing exactly what a well-formed output looks like.

Inconsistent company naming. If you type “Google” in one record and “Google LLC” in another, Claude will treat them as different companies. Standardize names early, or add a normalization step to the data entry agent that checks for near-matches before creating a new record.

Skipping the clarification fallback. If the data entry agent doesn’t ask for clarification when it’s unsure, it will guess — and it will sometimes guess wrong. The single-question fallback is worth keeping in the prompt.

Not seeding the system before testing. The reasoning layer works best when there’s real data to work with. Spend 20–30 minutes loading your current job search data before testing the warm intro and prioritization features. With sparse data, the outputs will feel thin.

Frequently Asked Questions

What is OpenBrain in MindStudio?

OpenBrain is MindStudio’s shared persistent data layer for AI agents. It stores structured records that persist across sessions and are directly readable by any agent in your workspace. Unlike a regular variable — which only exists during a single agent run — OpenBrain data is durable, structured, and queryable by the agent without manual data transfer or export steps.

Can Claude reason across multiple tables at once?

Yes. When you pass Claude a query involving data from multiple tables — for example, “which of my warm contacts work at companies where I haven’t applied yet?” — Claude processes the returned records and identifies patterns across them. The key requirement is that you fetch the relevant data and include it in Claude’s prompt context. MindStudio’s OpenBrain integrations let you chain a multi-table read before the Claude step, which handles this automatically.

Do I need to know how to code to build this?

No. The entire build in this article uses MindStudio’s visual builder, pre-built integrations, and Claude prompt configuration. There’s no requirement for JavaScript, Python, or API setup. MindStudio does support custom code functions if you want to add more complex logic later — but for this use case, it isn’t necessary.

How is this different from using a spreadsheet with a chatbot?

A spreadsheet and a chatbot are disconnected systems. You’d have to manually copy data from one to the other and keep both in sync. The dashboard described here is a closed loop: the agent reads from and writes to OpenBrain directly, so the data is always current and the reasoning always reflects your actual pipeline state. There’s no copy-paste step, no version drift, and no manual sync to maintain.

MindStudio supports shared workspaces and access controls, so you can give a collaborator read access to your OpenBrain data or build a view-only version of the dashboard that shows summary data without exposing detailed notes. This is useful for working with a career coach who wants pipeline visibility without managing the system themselves.

How do I handle data privacy for sensitive job search information?

MindStudio encrypts data at rest and in transit. For most job search tracking — company names, contact notes, application statuses — the standard security model is appropriate. If you’re storing sensitive information like salary negotiation notes or confidential referral details, review MindStudio’s data handling policies before including that data. As a general rule, treat OpenBrain data the same way you’d treat data stored in any cloud-based business tool.

Key Takeaways

A job search dashboard built on OpenBrain and Claude replaces scattered spreadsheets with a structured system your AI agent can actively reason across.
The four core data objects — companies, contacts, applications, and interviews — give Claude enough context to surface warm intro paths and flag expiring windows without manual prompting.
The data entry agent parses natural language input and writes structured records, making it fast enough to update in real time.
Scheduled workflows handle daily digests and proactive reminders so the system surfaces what matters rather than waiting for you to check in.
MindStudio’s visual builder makes the full build accessible without code — typical build time for this scope is one to three hours.

If you want to build this yourself, start for free at MindStudio. The visual builder, Claude integration, and OpenBrain data layer are all available on the free plan to get started.