JSOS: Building the Job Search System I Actually Needed

There’s something quietly infuriating about modern job search tooling.

You’d think, in an era of hyperconnectivity and SaaS everything, that there’d be a polished, powerful platform tailored for the kind of high-agency, high-context job seeker who treats their career like a product. I didn't feel like I was asking for anything insane, but after testing half a dozen of the usual suspects, I came to a frustrating conclusion: none of them really work, not the way I wanted them to.

So I built my own.

This is the story of JSOS — the Job Search Operating System — and why a custom-built Notion system turned out to be a better job search companion than anything on the market. It's also a case study in systems thinking, rapid prototyping, and building tools that evolve with you.

I. The Problem: Tools for Tourists, Not Builders

Modern job search platforms love to promise clarity. “Track your applications,” they say. “Stay organized.” “Land your dream job faster.”

But for anyone treating the job search like a serious project — not just a casual scroll through LinkedIn — most of these platforms collapse under scrutiny.

I tested them. Extensively.

• Teal had a slick interface, but no real support for nuanced strategy. It felt like a digital checklist — not a workspace. Customization was limited, and its structure too rigid to adapt to my evolving needs.
• Huntr offered a clean pipeline view, but it was overly opinionated. I couldn’t bend the system to match how I thought — it wanted me to adopt its mental model.
• Airtable gave me a flexible schema, sure — but friction crept in fast. Document storage was clunky. Views were cumbersome. It didn’t invite daily use.
• Google Sheets remains undefeated for getting started fast — but it crumbles the moment you need relationships between data, or any sense of scale.
• Other Notion templates? Inconsistent, disorganized, and often abandoned halfway through. It was clear most were built by people optimizing for novelty, not long-term use.

Each tool had features. But none offered a full system.

What I needed wasn’t just a tracker — it was an interconnected framework. A place where my companies, jobs, documents, learnings, and strategy could live together. Where the tools didn’t just reflect my workflow, but support and evolve with it.

Most job search platforms replicate the surface layer of what job seekers have always done — keep a list of roles, log their status, maybe set a reminder or two. But none of them reimagine what modern tooling enables:

• Deep, relational data models
• Multi-layered workflows
• Integrated reflection and growth
• Strategic reuse and insight generation

I wasn’t looking for a to-do list. I was building a career operating system.

What I wanted didn’t exist.
So I built it.

II. A Systems Approach to Job Searching

Most people think of a job search as a linear pipeline.

You apply to jobs. You reach out to recruiters. You wait. Maybe you follow up. Rinse and repeat.

But that’s not how high-agency job seekers operate — and it’s definitely not how I think.

To me, a job search is a dynamic information ecosystem — a constantly evolving network of signals, hypotheses, artifacts, and relationships. And any tool that reduces it to a glorified checklist is missing the point.

It’s not just about jobs.

It’s about:

• The companies you’re targeting — and why. Are they mission-aligned? Do they operate in a domain you care about? What are their red flags?
• The documents you’re submitting — resumes and cover letters, customized per role and organization.
• The contacts you’re building relationships with — internal referrals, external recruiters, hiring managers, all shifting throughout the process.
• The insights you’re collecting — patterns across industries, trends in feedback, reflections on your own positioning.
• The learning you’re doing as you go — new tools, frameworks, or even personal revelations about what you want next.

None of these exist in isolation.

A good system doesn’t silo them — it interlinks them. And once you stop thinking about your job search as “just a spreadsheet, but bigger,” you start to see how much richer the structure can become.

Take a single company, for example. You might:

• Apply to three different roles across two teams
• Create one tailored resume for the company and three role-specific cover letters
• Be in contact with an internal recruiter, an external sourcer, and two hiring managers
• Log a series of insights about their values, culture, and product direction
• Connect that company with broader trends you’re tracking across the sector

All of that belongs together. You want to be able to approach any one of those pieces — the role, the recruiter, the document, the insight — and instantly see how it fits into the larger picture.

That’s what JSOS does differently.

Because it’s built as a relational system, JSOS treats each item — job, document, company, insight — not as an isolated record, but as a node in a network.

Patterns start to emerge:

• You reuse a high-performing resume across multiple applications? That’s a trackable relationship.
• You log the same blocker at three different companies? That’s a trend.
• You gain a new skill during the process? That gets surfaced in your Learning Tracker and potentially tagged across future roles.

JSOS doesn’t just help you track your job search.

It helps you understand it.

By making it effortless to record information and just as easy to reorganize it later, it turns scattered inputs into usable knowledge. You don’t have to pre-structure everything up front — you just need to capture it in the moment. The structure emerges through tagging, linking, and reflection.

In many ways, this was the core theory I wanted to test.

Could I design a system where jotting down a note was as easy as scribbling a digital Post-it — but where those notes didn’t vanish into chaos?

With JSOS, the answer turned out to be yes.

The trick was removing friction from capture, while preserving the ability to resurface, reframe, and repurpose information later. That’s not just a tooling challenge. That’s systems thinking applied to personal productivity.

III. Designing the Operating System

I built JSOS in Notion for one simple reason: it gave me complete creative control.

No lock-in.
No pricing walls.
No forced workflows or bloated integrations.
Just a canvas I could shape exactly how I needed — fast, flexible, and entirely mine.

At first, I approached it like a smarter wiki. Notion’s block-based structure made it easy to create custom layouts, nest contextual notes, and build page hierarchies that mimicked traditional file/folder structures. I thought I was just organizing better.

But then I discovered databases — and everything changed.

What really sold me on Notion wasn’t just the freedom to create content. It was the power to connect content. The moment I realized I could build multiple independent databases — jobs, companies, documents, insights — and then relate them dynamically, I knew I could build something deeper than a tracker.

I could build an operating system.

The Six Core Modules

JSOS 1.1 now consists of six tightly integrated components. Each one handles a specific kind of information — but they only show their full power when used together.

📊 Dashboard
The high-level control panel. Tracks open applications, active interviews, and recent updates. Meant to surface state at a glance.

🏢 Companies
A curated, scored watchlist of 60+ organizations, each tagged for purpose alignment, sector, size, and interest level. This isn't just a list — it’s a strategic map.

📥 Pipeline
The operational heartbeat. Tracks every opportunity I’ve saved, applied to, interviewed for, or networked around. Built around clean statuses, detailed notes, and intentional follow-through.

📄 Documents
Houses both reusable templates and finalized deliverables — resumes, cover letters, outreach messages. Each document is tagged by type, role, and stage of use.

🧬 Backend / Data Layer
The structural core of JSOS. Tags, categories, document types, and metadata fields all live here. It’s invisible in daily use, but everything relies on it.

📚 Learning & Development
Tracks personal growth throughout the search — from new technical tools to strategy frameworks to philosophical insights. It’s my private changelog as a professional in motion.

Together, these aren’t just folders. They’re nodes in a living system.

I think of JSOS as an opportunity-generation engine. It’s not just a tracker. It’s not even just a workspace. It’s a deliberately designed structure that reduces friction around capturing, relating, and ultimately using information. That’s the real difference.

Where most systems ask you to structure everything up front — and punish you when your needs evolve — JSOS flows with me. Need to start tracking new contacts? Add a new relation. Need to reflect on interview themes? Drop in a tag. Need to reuse a successful resume? Link and go.

It’s modular. It’s extensible. And most importantly, it works the way I think.

Guiding Principles

Every design decision inside JSOS is driven by three principles:

• Fast capture
  It should be as easy to log a new opportunity or note as it is to write a sticky note. Low friction = higher usage.
• Ownable structure
  The schema must evolve as my process does — without breaking. That means clean tables, clear relationships, and minimal hardcoded logic.
• Clarity over cleverness
  No automations for their own sake. If it adds complexity without value, it gets cut. The goal is to understand, not just to impress.

JSOS is not trying to be fancy.
It’s trying to be useful — today, and again tomorrow.

IV. Building JSOS the Agile Way

Just because I was building solo didn’t mean I abandoned process. If anything, lean, iterative execution mattered more.

From day one, I treated JSOS like a real product — designed and developed using Agile principles, scoped to deliver value quickly, and intentionally staged for learning and evolution.

MVP First: JSOS 1.0

The first version of JSOS shipped in less than a week.

It wasn’t fancy. It wasn’t polished. But it was functional — and most importantly, usable immediately.

JSOS 1.0 included:

• Static text fields only — no interlinked databases or relational logic
• Minimal views — a few Kanban boards, gallery views, and filtered tables
• No analytics, no CRM, no dashboards — just the bones

But that simplicity was deliberate. I didn’t set out to build the endgame. I set out to build the minimum system that could support real-world use.

So I made cuts. On purpose.

• Relations between Jobs and Companies? Deferred.
• Analytics dashboards? Deferred.
• Document-to-job linking? Deferred.
• Priority scoring, auto-tagging, form automations? Deferred.

Not because they weren’t valuable — but because they weren’t necessary to start generating momentum. Every feature I delayed was a feature that might have slowed me down. And velocity mattered.

MVP wasn’t just a buzzword. It was a discipline.

By removing the need to “finish” the system before using it, I was able to observe how it performed in the wild — and let the gaps surface naturally.

Sprint Cycles and Iterative Expansion

Every day, I would pause to ask: what do I wish I had right now?

That became the next sprint.

• I built the Documents database after realizing how often I was reusing resume variants and cover letters — and how scattered they were.
• I added the Learning & Development tracker once I noticed myself writing down recurring patterns in my notes: frameworks I was adopting, insights from interviews, even skills I was strengthening just by going through the process.
• I restructured the Companies database to support multiple linked job entries — once it became clear that many firms had several roles I was interested in.

These weren’t speculative improvements. They were responsive enhancements driven by real usage pain.

Even as a team of one, I followed a rhythm:

• Define a focused goal
• Build a lightweight solution
• Use it
• Reflect on friction
• Iterate

No ceremony. No burn-down charts. Just real agility — with feedback loops tight enough to ship something meaningful every week.

This wasn’t about building everything.
It was about building the right thing — just in time.

V. Retrospective: What Worked (and What Didn’t)

Looking back, the build-out of JSOS 1.0 and 1.1 offers a clean case study in intentional tradeoffs. I didn’t try to be clever. I tried to be fast, clear, and useful — and that meant making some calls that wouldn't pass a product manager’s fantasy spec sheet.

But that’s also why it worked.

✅ What Worked

• 🚀 Speed of Execution
  JSOS 1.0 shipped in under a week. That wasn’t a fluke — it was the product of aggressively scoped goals and a willingness to defer non-essentials. I didn’t overthink the first version. I shipped it.
• 🧰 Utility-First Design
  From Day 1, the system was usable. Not just “technically functional” — but actually helpful. I was logging jobs while still refining the schema. It became part of my workflow as I was building it, which meant I never fell into the trap of designing for a theoretical user (even myself).
• 📈 Scalable Architecture
  When I added relations, insights, and the Learning Tracker in JSOS 1.1, nothing broke. There was no painful migration or restructuring. The original design assumed things would grow — and made space for that growth without needing to anticipate every detail.

❌ What Didn’t Work (Yet)

• 📊 Analytics Pain
  Notion just isn’t built for deep analytics. You can’t create Top-N lists. There are no native charts or graphs. Rollups are limited in how you can filter or summarize them. You can fake a lot with clever views, but nothing beats real data visualization — and that’s a future feature, not a current one.
• 🧩 Form Friction
  I love using Notion forms to input data quickly, but they’re not relationally smart. If I’m filling out a job entry form and want to link to a new company that doesn’t yet exist, I can’t create it inline. I have to leave the form, create the company record manually, then come back. It’s a small thing — but small things add friction over time.
• 🧱 Kanban Limitations
  The Kanban view looks clean, but lacks depth. You can’t persist collapse state (columns expand every time you open the view), and there’s no way to display summary metrics without awkward workarounds. I’d love to see richer swimlane functionality in a future Notion update, but for now, it’s just good enough.

None of these issues broke the system. They didn’t stop me from using it daily. And more importantly, they didn’t send me down a rabbit hole of premature optimization.

Because I never tried to make JSOS perfect.
I just tried to make it work — and it did.

VI. What’s Next: The JSOS 2.0 Roadmap

JSOS isn’t static — it evolves with my search, my goals, and my systems thinking. Here’s what’s on deck for version 2.0:

🔗 Smarter Relationships

• Fully reintroduce Relations between Jobs, Companies, and Documents
• Add bi-directional linking and rollups to improve context

📇 CRM & Networking

• Build a dedicated Contacts layer for recruiters, referrals, and hiring managers
• Log Info Chats, follow-ups, and outreach history

📊 Analytics & Insights

• Develop an Analytics DB for trends and bottlenecks
• Surface conversion rates, interview velocity, and company hit rates

🔍 Search & Discovery

• Add a lead capture module for exploratory roles and referrals
• Track sourcing channels and passive interest

🧠 Strategy & Reflection

• Embed retrospective prompts directly into workflows
• Build a tagging system for insights, patterns, and personal growth

🗓️ Timeline & Task Views

• Integrate Calendar-style views for key dates and follow-ups
• Add "Next Actions" filters for pipeline visibility

The system will grow — but the goal stays the same: reduce friction, amplify clarity, and support strategic action.

VII. What This Project Says About Me

I built JSOS because I needed it — and nobody else had.

This wasn’t a productivity flex. It was a problem-solving act of necessity.

Most job search tools weren’t made for someone like me — someone who thinks in systems, works iteratively, and needs tools that scale with complexity rather than collapse under it. So I stopped waiting and built what I wished existed.

You can see my working style in every layer of JSOS:

• I value clarity and single sources of truth. I don’t like recording the same data twice — and I design systems that don’t require it.
• I can ship fast — but always with an eye toward long-term scalability. Just because something works today doesn’t mean it shouldn’t evolve tomorrow.
• I take full ownership of my systems — and I build them in public, iterating with intention and reflecting along the way.

If you’re a builder, a strategist, or a high-context generalist trying to navigate a noisy, chaotic hiring landscape — you deserve better tools.

I made mine.
Maybe it’ll help you make yours.

If you'd like to download your own copy of the Job Search OS, you may do so at these links:

• Notion (App Framework)
• Job Search OS (Template link)

Note, the JSOS is optimized for a desktop monitor, although IS functional on a mobile device using the Notion app.