Building a Job Search System That Makes Progress Visible

Role: System Designer & Creator | Timeline: 3+ months iterative development | Platform: Notion

At a glance

Job searching creates unique anxiety: the hard part isn't applying—it's not knowing if your effort matters. Most job trackers treat this as an organization problem, but it's actually a visibility problem. When progress is invisible, the brain assumes there is none.

I designed a Notion-based job tracking system with automated progress counters, status-driven views, and visual dashboards that make effort tangible. The result: a single-source-of-truth system that reduces cognitive load and provides evidence of progress—even on low-motivation days.

The Challenge

Job searching is operationally complex and emotionally draining. Applicants must track dozens of simultaneous conversations, remember follow-up dates, monitor application statuses, and maintain momentum—all while managing the uncertainty of non-responses and rejections.

The problems existing solutions create:

• Fragmented information. Application details scattered across email, spreadsheets, browser tabs, and mental notes

• Invisible progress. No tangible proof that effort is translating into forward movement

• Manual overhead. Constant mental load of remembering what to do next and where things stand

• Emotional weight. Uncertainty about whether you're doing enough or missing opportunities

• System abandonment. Complex trackers feel like homework and get abandoned during low-motivation periods

The core insight: This isn't just a data organization problem—it's a visibility and cognitive load problem. Users need external scaffolding that reduces mental burden and makes progress tangible without adding administrative work.

The stakes: For job seekers—especially those with ADHD or anxiety—the lack of a reliable tracking system creates constant low-level stress and genuine missed opportunities (forgotten follow-ups, lost track of conversations, unclear sense of progress).

My Approach

I started by identifying why existing job trackers fail: they optimize for data capture instead of emotional usability, and they require manual maintenance that breaks down when motivation is low.

Discovery & User Research

I observed my own job search behavior and interviewed other job seekers to identify core pain points:

Key insights:

• Visibility drives motivation. Users who could see their application count reported higher satisfaction and sustained effort

• Progress must be automatic. Any system requiring manual tallies or calculations gets abandoned

• Status clarity matters more than detail. Users want to know "where things stand" at a glance, not navigate complex pipelines

• Fragmentation creates anxiety. Having to check multiple places increases stress and mental load

• System must tolerate gaps. Job searches have variable intensity—the system needs to work even with inconsistent daily use

Design Principles

Single source of truth. All job search information consolidated in one place with automatic tracking.

Visibility infrastructure. Automated counters and progress metrics that provide tangible evidence of effort.

Emotional usability. Designed to be opened even on low-motivation days—no required fields, no shame for gaps, gentle structure.

Status-driven views. Databases organize themselves based on application state, minimizing manual sorting.

Cognitive scaffolding. Clear next actions, obvious organization, visual progress feedback.

What I Built

System Architecture

I designed an integrated Notion system with 1 core database, 6 custom views, and automated progress tracking across multiple dashboard pages:

Core Database:

• Jobs Database – Relational database tracking all applications with status, dates, contacts, and notes

Custom Views:

• Dashboard Summary – Key metrics and real-time counters (applications this week, total applications, active interviews)

• Board View – Kanban-style pipeline (Applied → Waiting → Interviewing → Offer/Rejected)

• Table View – Full data table with sorting and filtering

• Calendar View – Timeline visualization of application and follow-up dates

• Active Applications – Filtered view showing only in-progress opportunities

• Archive – Closed/rejected applications for reference

Dashboard Pages:

• Job Tracker Dashboard – Command center with summary stats, active applications, and next actions

• Weekly Progress – Application activity by week with visual progress indicators

• Interview Pipeline – Dedicated view for active interview processes

Database Schema & Properties

Jobs Database includes:

Core Identification:

• Company (Title property) – Company name

• Position (Text) – Job title

• Status (Select) – Pipeline stage with 6 stages: Applied, Waiting, Interviewing, Offer, Rejected, Archived

Dates & Timeline:

• Application Date (Date) – When application was submitted

• Follow-up Date (Date) – Next planned touchpoint

• Last Contact (Date) – Most recent interaction

• Interview Date (Date) – Scheduled interview time

Contact & Details:

• Contact Person (Text) – Recruiter or hiring manager name

• Contact Info (Text) – Email or LinkedIn

• Salary Range (Text) – Listed compensation

• Location (Select) – Remote, Hybrid, On-site

• Link to Posting (URL) – Original job listing

Tracking & Notes:

• Notes (Text) – Interview prep, conversation details, research

• Materials Submitted (Multi-select) – Resume variant, cover letter, portfolio

• Source (Select) – LinkedIn, Indeed, Referral, Company Site

• Priority (Select) – High, Medium, Low

Automated Properties:

• Days Since Application (Formula) – Auto-calculates elapsed time

• Needs Follow-up (Checkbox formula) – Flags applications older than X days with no response

• Status Color (Formula) – Conditional formatting for visual scanning

Key Features

1. Automated Progress Tracking

Real-time counters on the dashboard automatically calculate:

• Applications This Week – Rollup counting applications where date is within last 7 days

• Total Applications – Count of all non-archived records

• Active Interviews – Count where Status = "Interviewing"

• Offers Received – Count where Status = "Offer"

• Response Rate – Formula: (Interviews + Offers) / Total Applications × 100

How it works: Rollup properties on a linked dashboard database aggregate data from the Jobs database. Formulas calculate percentages and conditional values. Users see updated stats without manual tallying.

Why this matters: Provides tangible evidence of effort. When motivation is low, users can see "You've applied to 47 jobs this month" as proof that work is happening.

2. Status-Driven Views

Views auto-populate based on application state:

• Status = "Applied" → appears in "Waiting for Response" view

• Status = "Interviewing" → appears in "Active Interviews" view

• Status = "Offer" or "Rejected" → moves to "Closed" view

• Days Since Application > 14 + Status = "Waiting" → flags in "Needs Follow-up" view

No manual sorting required. The system organizes itself based on job state.

3. Visual Pipeline (Board View)

Kanban board with columns for each status stage:

Applied → Waiting → Interviewing → Offer

            **↓**

        **Rejected**

Users move cards between columns, providing:

• Visual satisfaction of forward movement

• At-a-glance pipeline health

• Clear sense of where opportunities stand

Design choice: People want to move cards, not just update fields. The kinetic interaction increases engagement.

4. Follow-up Automation

Formula-based flagging system:

Needs Follow-up = TRUE when:

• Days Since Application > 14 AND Status = "Waiting"

• Follow-up Date < Today AND Status ≠ "Rejected" or "Archived"

Flagged applications appear in a dedicated "Action Required" view on the dashboard.

Why this works: External memory. Users don't have to remember who to follow up with—the system surfaces it automatically.

5. Materials Tracking

Multi-select property tracks which materials were submitted:

• Resume (Standard)

• Resume (Technical)

• Resume (Creative)

• Cover Letter

• Portfolio

• Writing Samples

Use case: When preparing for interviews, users can quickly reference which version of their resume the company has.

6. Dashboard Summary Cards

Visual summary cards show:

This Week

• Applications submitted: 12

• Responses received: 3

• Interviews scheduled: 1

All Time

• Total applications: 47

• Active interviews: 2

• Response rate: 23%

Next Actions

• 5 applications need follow-up

• 2 interviews this week

• 3 new postings saved to review

Design principle: Exception-driven dashboard. Show what needs attention NOW, not everything.

Results & Impact

Quantitative Outcomes

• ✅ 6 custom views designed for different use cases and mental states

• ✅ 15 database properties tracking key information and automating calculations

• ✅ 5 automated formulas calculating days elapsed, follow-up flags, and progress metrics

• ✅ 3 rollup properties providing real-time application counters

• ✅ Single source of truth consolidating all job search information in one system

• ✅ Zero manual tallying required—all stats auto-update

Qualitative Impact

For job seekers:

• Visible progress counters "I'm not doing enough" anxiety with tangible evidence

• Reduced cognitive load—system tracks what to do next instead of mental reminders

• Sustained motivation—visual progress provides satisfaction even during slow weeks

• Clear next actions—dashboard surfaces what needs attention without hunting

• Single source of truth—eliminates fragmentation stress

From creator testing:

"I've applied to more jobs while unemployed than I ever have before because this actually feels satisfying to use. I can see exactly how many jobs I applied to today, this week, total. I've never been that girl who keeps track of things, but now I feel like I'm on my p's and q's."

Key insight: When progress becomes visible, behavior changes naturally—not through discipline, but through satisfaction.

For system designers:

• Demonstrates how visibility infrastructure can solve motivation problems

• Shows emotional usability as a technical design consideration

• Proves that automated feedback mechanisms drive sustained engagement

• Models designing for inconsistent use (system works even with gaps)

Technical Highlights

Automated Metrics Without Manual Input

Progress counters use rollup properties linked to a separate Dashboard database:

Structure:

1. Dashboard database has a single record: "Job Search Stats"

2. Jobs database has a relation property linking all records to this stats record

3. Dashboard record uses rollups to aggregate data:

   • Count of related Jobs where Application Date > 7 days ago

   • Count of related Jobs where Status = "Interviewing"

   • Formula: (Count where Status = "Offer" or "Interviewing") / Total × 100

Result: All stats update automatically as jobs are added or statuses change. Zero manual calculation required.

Status-Driven View Filtering

Each view uses filters that match application state:

"Needs Follow-up" view filter logic:

• Status = "Waiting" OR Status = "Applied"

• AND (Days Since Application > 14 OR Follow-up Date < Today)

• AND Status ≠ "Rejected"

"Active Interviews" view filter logic:

• Status = "Interviewing"

• Sorted by Interview Date (ascending)

Views organize themselves automatically based on job state. No manual sorting or remembering which view to check.

Conditional Formatting with Formulas

Days Since Application formula:

dateBetween(now(), prop("Application Date"), "days")

Needs Follow-up flag formula:

if(prop("Status") == "Waiting" and prop("Days Since Application") > 14, true,
   if(prop("Follow-up Date") < now() and prop("Status") != "Rejected", true, false))

Status Color formula (for visual scanning):

if(prop("Status") == "Offer", "🟢",
   if(prop("Status") == "Interviewing", "🔵",
   if(prop("Status") == "Waiting" and prop("Days Since Application") > 14, "🟡",
   if(prop("Status") == "Rejected", "🔴", "⚪"))))

Multiple Views for Different Mental States

Multiple Views for Different Mental States

Board View – Visual satisfaction, kinetic interaction (for high-engagement days)

Table View – Detailed data, sorting, bulk editing (for administrative tasks)

Calendar View – Timeline visualization (for weekly planning)

Dashboard Summary – Quick check-in (for low-motivation days)

Design principle: Same data, different interfaces. Supports variable energy and task types.

Single-Source-of-Truth Architecture

All job information lives in one database with relational links to:

• Dashboard stats (via rollup aggregation)

• Weekly progress pages (via filtered views)

• Interview prep notes (via database templates)

Update once, reflects everywhere. No data duplication or sync issues.

Lessons & Iteration

What Worked

Making progress automatic. Rollup-based counters eliminated the "I should update my stats" friction that kills other trackers.

Status clarity over complexity. Six clear stages (Applied → Waiting → Interviewing → Offer/Rejected/Archived) worked better than elaborate 12-stage pipelines.

Visual movement matters. Board view engagement was significantly higher than table view—the act of dragging cards feels satisfying.

Exception-driven dashboard. Showing "5 applications need follow-up" worked better than showing all 47 applications.

What I'd Do Differently

More granular interview stage tracking. "Interviewing" is too broad—users want to differentiate phone screen vs. panel interview vs. final round.

Built-in templates for common tasks. Could include database page templates for interview prep, thank-you emails, salary negotiation notes.

Integration with job boards. Manual entry is still friction—browser extension or Zapier integration could auto-populate from Indeed/LinkedIn.

Weekly digest automation. Notion doesn't support email digests, but a weekly summary view ("This week you applied to X jobs, heard from Y companies") could be manually reviewed.

Why This Project Matters for Your Business

This project demonstrates my ability to:

✅ Identify invisible problems – Recognized that job search anxiety stems from progress invisibility, not disorganization

✅ Design visibility infrastructure – Built automated tracking that makes effort tangible without manual work

✅ Apply operations principles to personal systems – Exception-driven dashboards, status-driven views, automated metrics

✅ Design for emotional usability – System remains functional during low-motivation periods (realistic user behavior)

✅ Balance automation with simplicity – Sophisticated backend (formulas, rollups, conditionals) with simple frontend (clear views, obvious actions)

✅ Create user-centered solutions – Designed based on actual user behavior and pain points, not ideal productivity conditions

✅ Deliver measurable impact – 6 custom views, 15 properties, 5 automated formulas, zero manual tallying required

Tools & Skills Demonstrated

Platform: Notion (relational databases, formulas, rollups, views, templates)

Skills:

• Database schema design and property architecture

• Formula logic for conditional calculations and flags

• Rollup aggregation for automated metrics

• View design and filter logic

• Information architecture (multiple views for different use cases)

• User psychology and behavioral design

• Emotional usability and accessibility

• Status-driven workflow design

• Progress tracking and visual feedback systems

• System design for variable user engagement