Blog

As a freelancer or solo consultant, you need more than a todo app but less than enterprise software. CaseMgr sits in that sweet spot — track clients, log hours, generate invoices, and stay organized.

You’re Not Enterprise. You’re Not a Hobbyist. You Need Something in Between.

As a freelancer or solo consultant, you live in an awkward middle ground. You have real clients, real deliverables, and real invoices to send. But you’re not a 50-person agency that needs Salesforce or Monday.com. You’re one person (or maybe two or three) trying to keep multiple client engagements organized without spending half your week managing your management tools.

Here’s the problem: the tools available to you tend to fall into two camps, and neither one fits.

The Two Extremes

Todo Apps: Too Simple

Todoist, Apple Reminders, Google Tasks — they’re great for personal task lists. But client work isn’t a list of disconnected tasks. A client engagement involves a proposal, a signed contract, deliverables with dependencies, communication logs, time tracking, and eventually an invoice. A todo app treats “Draft brand strategy for Acme Corp” and “Buy groceries” as fundamentally the same kind of thing. They’re not.

Enterprise Platforms: Too Much

Jira, Salesforce, Microsoft Project — these were built for teams of dozens or hundreds. They require configuration, training, and ongoing administration. The overhead of setting up a Jira project for a two-week consulting engagement is absurd. You’ll spend more time configuring the tool than doing the work.

What Solo Professionals Actually Need

Client Case Tracking

Each client engagement needs its own space — a “case” — where everything related to that engagement lives. Not a folder of files, not a list of tasks, but a structured container that holds the full picture: what was agreed, what’s been done, what’s next, and what’s been communicated.

When a client emails asking “Where do we stand?” you should be able to answer in 30 seconds by opening their case, not by searching through your email, your task app, your file system, and your memory.

Billable Time Tracking

If you bill by the hour (or even if you don’t, for estimating future projects), you need time tracking that’s connected to the work. Not a separate timer app where you have to remember which client and task to assign each entry to. Time should be logged against specific tasks within specific client cases so that when invoice day comes, the numbers are already organized.

Invoicing That Flows from the Work

The most painful part of freelancing isn’t the work — it’s the billing. You finish a project, then spend an evening reconstructing what you did, how long it took, and what to charge. If your time entries and deliverables are already tracked in the client’s case, generating an invoice should be a matter of pulling the data together, not forensic archaeology through your calendar and email.

Deliverable Management

Most client work produces deliverables: reports, designs, strategies, code, analyses. These need to be tracked, versioned, and associated with the engagement they belong to. Dropbox gives you file storage. Google Drive gives you file storage. But neither gives you file storage in the context of the client engagement, alongside the tasks, time entries, and communications that produced those files.

A Day in the Life, With Structure

Imagine this: You start your morning by checking your active cases. Three clients, each with their own case showing current stage and outstanding tasks.

• Client A is in the “Delivery” stage. You have two tasks left: finalize the report and schedule the presentation. You start a timer on the report task, work for 90 minutes, and stop the timer. Time is logged automatically.
• Client B is in the “Discovery” stage. You add notes from yesterday’s interview as a journal entry in the case. You create a task for the competitive analysis that the interview revealed is needed — a discretionary task that wasn’t in the original plan.
• Client C just wrapped up. You open their case, review the logged time entries, and generate an invoice. Total billable hours, descriptions of work performed, and the applicable rate are all there. You export the invoice and send it in five minutes.

No digging through apps. No reconstructing your week. The structure does the remembering for you.

Why Case Management (Not Project Management)

Project management tools assume a plan: defined scope, scheduled tasks, a timeline. That works for construction projects and software sprints. But consulting and freelance work is often adaptive. The scope evolves. New tasks emerge from what you learn. Clients change their minds. Stages overlap.

Case management is designed for exactly this kind of work. A case is goal-driven, not plan-driven. You have stages that reflect the natural phases of an engagement, tasks that can be added as needed, and milestones that mark real progress. It’s structured enough to keep you organized, flexible enough to handle the reality of client work.

Staying Lean

The last thing a solo professional needs is another tool that requires a weekend of setup. The right tool should be useful within minutes: create a case for your current client, add a few tasks, start tracking time. Refine the structure as you go, not before you start.

Get Started

If your client work has outgrown sticky notes but doesn’t need an enterprise platform, create a free CaseMgr account and set up your first client case. It takes minutes, not days. CaseMgr also supports AI-powered assistance through its MCP integration, so you can manage cases, log time, and organize deliverables using natural language — perfect for solo professionals who’d rather work than administrate.

When you started tracking clients or projects, Excel was the obvious choice. But as things grew, the spreadsheet became the problem. Here’s how to move to something better without losing what you’ve built.

Your Spreadsheet Worked — Until It Didn’t

There’s no shame in the spreadsheet. When you started tracking clients, projects, or cases, Excel or Google Sheets was the obvious choice. It’s free (or close to it), everyone knows how to use it, and it’s flexible enough to hold whatever you throw at it. For a while, it works beautifully.

Then one day you realize you have 47 tabs, three people are editing the same row simultaneously, someone deleted a formula, nobody remembers what “Status Code 3” means, and your boss wants a report by Friday that would take two days to assemble. That’s the moment you start searching for something better.

Common Spreadsheet Pain Points

Everything Is Flat

A spreadsheet gives you rows and columns. That’s great for simple lists but terrible for complex records. A client case might involve intake information, multiple service sessions, documents, notes from different staff members, and outcome tracking. In a spreadsheet, you either cram all of that into one very wide row or split it across multiple sheets and try to link them together with lookup formulas that break when someone inserts a column.

No Workflow Enforcement

A spreadsheet won’t stop someone from marking a case “closed” before the required review is complete. It won’t remind anyone that a follow-up is overdue. It won’t enforce that documentation must be attached before moving to the next stage. Every rule exists only in people’s heads — and people forget.

Collaboration Gets Messy

Google Sheets improved collaboration over emailing Excel files back and forth, but it’s still a shared canvas where anyone can change anything. There’s no role-based access (short of creating separate sheets for different people). There’s no meaningful audit trail — the version history exists, but good luck using it to answer “who changed Client #847’s status on March 15th and why.”

Reporting Is Manual

Every report requires building a pivot table, writing formulas, or manually counting and categorizing. The data is there, but extracting meaning from it is a project unto itself. And because the data isn’t structured consistently (because there’s nothing enforcing consistency), reports are always slightly suspect.

What Maps from Spreadsheets to CaseMgr

The good news: your spreadsheet already contains the raw material for proper case management. Here’s how your existing data translates:

• Each row becomes a case. If you have one row per client, project, or matter, each one becomes its own case with room for all the detail that was being compressed into cells.
• Column groups become stages. If your spreadsheet has columns for “Intake Info,” “Service Delivery,” and “Outcome” sections, those map to case stages — the phases of your workflow.
• Status columns become task states. Your “Status” dropdown (Open/In Progress/Complete) becomes real task tracking with assignments, due dates, and automatic progress indicators.
• Notes columns become journal entries. Those long text cells where people paste updates become proper dated, attributed case notes.
• Attached files become case documents. Instead of a cell containing a Google Drive link, documents live directly within the case.
• Date columns become milestones. “Date Approved,” “Date Completed,” “Follow-Up Date” — these become real milestones and scheduled tasks with reminders.

A Practical Migration Approach

Don’t try to migrate everything at once. That’s a recipe for frustration and a half-finished migration that leaves you worse off than before. Instead:

Step 1: Map Your Current Structure

Look at your spreadsheet and identify the patterns. What are the columns? Which ones are structured data vs. free text? What’s your actual workflow — the stages that cases move through? Write this down. It becomes your CaseMgr case template.

Step 2: Start New Cases in CaseMgr

From today forward, every new case goes into CaseMgr. Keep the spreadsheet for existing cases you’re still working. This gives your team time to learn the new system without the pressure of migrating historical data.

Step 3: Migrate Active Cases

Once your team is comfortable, move currently active cases from the spreadsheet to CaseMgr. Focus on cases that are in progress and will benefit from the structure. For each one, create the case, set up its current stage, and add the relevant tasks and notes.

Step 4: Archive the Spreadsheet

Keep the old spreadsheet as a read-only reference for historical data. Don’t delete it — you might need to look something up. But stop updating it. The spreadsheet becomes your archive; CaseMgr becomes your system of record.

What You Gain After the Switch

• One source of truth instead of competing spreadsheet versions
• Workflow enforcement that ensures steps aren’t skipped
• Automatic audit trails that record who did what and when
• Real-time visibility into case status across your team
• Reports that build themselves from structured, consistent data
• Scalability — CaseMgr handles 10,000 cases the same way it handles 10

Get Started

Ready to leave the spreadsheet behind? Create your free CaseMgr account and set up your first case template based on your current spreadsheet structure. CaseMgr’s AI-powered MCP integration can even help you organize and structure your data as you migrate, making the transition smoother than you might expect.

Whether you are running experiments, conducting interviews, or doing a deep literature review, your research project is a living collection of sources, notes, data, and tasks. Here is how to keep it all organized.

Research Isn’t Linear — Your Tracking Tool Shouldn’t Be Either

Whether you’re running experiments in a lab, conducting qualitative interviews, or doing a deep literature review for your thesis, research projects share a common trait: they refuse to follow a straight line. You start with a hypothesis, discover three new questions, pivot your methodology, find a contradictory paper, and suddenly your neat project plan looks nothing like reality.

Most project management tools assume work flows from A to B to C. Research doesn’t work that way. Here’s how to track it effectively anyway.

The Core Challenges of Research Tracking

Literature Review Organization

A serious literature review can involve dozens or hundreds of sources. You need to track not just what you’ve read, but what each source contributes to your argument, how sources relate to each other, and which gaps they reveal. Reference managers like Zotero handle citations well, but they don’t connect your reading to your research tasks and findings.

What researchers actually need is a way to link a source to the specific research question it addresses, annotate it with notes, and see it in the context of the broader project — not in a separate app.

Experiment and Data Collection Tracking

If you’re running experiments, you need to track protocols, parameters, results, and iterations. If you’re collecting qualitative data, you need to organize interviews, observations, and field notes alongside your analysis. Each experiment or data collection session generates information that feeds back into your research questions.

Spreadsheets can store this data, but they don’t capture the relationships. Which experiment tested which hypothesis? Which interview contradicted your earlier findings? That context gets lost in a grid of cells.

Multi-Source, Multi-Phase Work

A research project might involve a literature review phase, a data collection phase, an analysis phase, and a writing phase — but these phases overlap. You’re still reading papers while you’re analyzing data. You’re writing sections while you’re still collecting. Tools that force you into a single-track timeline don’t reflect how research actually happens.

Collaboration and Supervision

If you’re working with a research team, advisor, or co-investigators, everyone needs visibility into the project’s status. “Where are we on the IRB approval?” “Has the second round of interviews been coded?” “Which sections of the paper are drafted?” These questions shouldn’t require a meeting to answer.

How Case-Based Tracking Works for Research

Research projects map naturally to case management concepts. Here’s why:

• The project is the case. Everything related to a research project — literature, data, tasks, notes, findings — lives in one place.
• Phases are stages. Literature Review, Data Collection, Analysis, Writing, Peer Review. You move through them, but they can overlap and you can return to earlier stages when findings demand it.
• Individual studies, experiments, or sources are tasks and items. Each gets tracked with its own notes, status, and linked references.
• Key findings are milestones. “Hypothesis 1 supported,” “IRB approved,” “Draft submitted” — these mark meaningful progress beyond just completing tasks.
• New questions trigger new tasks. When an experiment reveals something unexpected, you add a discretionary task to investigate further. The system supports the reality of research: plans change.

Practical Examples

Thesis or Dissertation

Create a case for your thesis. Set up stages for each chapter or research phase. Track every source as a linked item with notes about its relevance. Log advisor feedback as journal entries. When your committee asks about progress, you have a clear, honest picture — not a panicked reconstruction from memory.

Lab Research

Each experiment gets a task with structured notes: protocol, parameters, results, interpretation. Link related experiments together. Use milestones to mark when you’ve achieved sufficient data for a conclusion. When it’s time to write up results, your organized records become your first draft outline.

Qualitative Research

Track each interview or observation as a task. Attach transcripts and field notes as documents. Use the journal to record your evolving interpretations and memos. Link participants to the themes that emerge from their data. The connections between your raw data and your analysis stay visible and traceable.

What You Gain

Compared to managing research with a combination of file folders, spreadsheets, and a task app:

• Everything lives in one system — no more hunting across tools
• The connections between sources, data, and findings are explicit, not just in your head
• Progress is visible to collaborators and supervisors without status meetings
• When you return to a project after a break (as researchers often must), the context is preserved
• Time tracking shows where your research hours actually go — useful for grants and reporting

Get Started

If your research project has outgrown sticky notes and spreadsheets, sign up for CaseMgr and set up your first research case. With its AI-powered MCP integration, CaseMgr can even help you organize sources, draft task descriptions, and identify connections across your research — like having a research assistant built into your project management tool.

Trello and Notion are both excellent products. But when your work requires structured workflows, mixed content types, and time tracking, you might need something different.

Three Great Tools, Three Different Jobs

Let’s be honest upfront: Trello and Notion are both excellent products. Millions of people use them productively every day, and for good reason. This isn’t a hit piece. It’s a guide to help you figure out whether your work has outgrown what they were designed to do — and what to consider if it has.

Where Trello Excels

Trello nails visual simplicity. If your work can be described as “things moving from left to right” — To Do, Doing, Done — Trello is hard to beat. The kanban board metaphor is intuitive, the drag-and-drop experience is smooth, and the learning curve is practically flat.

Trello is ideal for:

• Simple project tracking with clear stages
• Personal task management
• Team workflows where the process is linear and consistent
• Quick, lightweight collaboration

Where it struggles: When a card needs to hold a lot of information — notes, documents, time entries, sub-tasks, linked items — Trello starts to feel cramped. Cards become overloaded. Attachments pile up. And when your workflow isn’t a simple left-to-right progression, the board metaphor breaks down. You find yourself creating workaround boards, labels upon labels, and Power-Ups that patch gaps in the core experience.

Where Notion Excels

Notion is the Swiss Army knife of productivity tools. It combines documents, databases, wikis, and lightweight project management into a single flexible workspace. If you need to build something custom — a client directory, a content calendar, a knowledge base — Notion gives you the building blocks.

Notion is ideal for:

• Documentation and knowledge management
• Custom databases for tracking almost anything
• Team wikis and internal reference materials
• Flexible, self-designed workflows

Where it struggles: Notion’s flexibility is also its weakness. It can be anything, which means it’s nothing out of the box. You have to build your own system, maintain it, and train everyone to use it consistently. There are no enforced workflows — a database view won’t stop someone from skipping a required step. And when you need audit trails, time tracking, or billing alongside your project data, you’re back to integrating external tools or building fragile workarounds.

The Gap Both Leave Open

If your work involves any of the following, you’ve probably felt the limits of both tools:

• Structured workflows with flexibility: You need a defined process (intake, review, approval, delivery) but individual cases may require different tasks or paths. Trello’s boards are too rigid; Notion’s databases have no workflow enforcement.
• Rich, mixed content per item: Each case or project needs tasks, long-form notes, documents, time tracking, and linked references — all in one place, not scattered across tabs and integrations.
• Time tracking and billing: Neither Trello nor Notion has native time tracking that’s suitable for billable work. You’ll need Toggl, Harvest, or another integration, which means your time data lives separately from your project data.
• Audit trails: Who did what, and when? Trello’s activity log is basic. Notion’s page history helps with content changes, but doesn’t give you a compliance-grade record of actions taken on a case.
• Reporting across cases: When you need to see patterns across all your projects or clients — average time to resolution, tasks most often delayed, workload distribution — neither tool gives you that without significant manual effort or third-party analytics.

Where CaseMgr Fits

CaseMgr was built for the kind of work that lives in the gap between simple task boards and full-blown enterprise platforms. It’s a case management system grounded in CMMN (Case Management Model and Notation), which means it understands that real work has stages, milestones, discretionary tasks, and conditions that trigger next steps.

Here’s what that looks like in practice:

• Cases as containers: Each case holds tasks, notes, documents, time entries, and linked items. Everything lives together.
• Stages and milestones: Define your workflow phases and key achievements. The system tracks progress through them.
• Discretionary tasks: Not every case follows the same path. Case workers can add tasks as needed without breaking the overall structure.
• Built-in time tracking: Log time directly against cases and tasks. No external integration required.
• Audit trails: Every action is recorded with timestamps and user attribution. When someone asks “what happened with this case,” the answer is already there.

A Fair Summary

Use Trello if your work is visually simple and moves in a predictable flow. Use Notion if you need flexible documentation and custom databases and you’re willing to build your own system. Consider CaseMgr when your work demands structured workflows, rich case records, time tracking, and accountability — without the overhead of an enterprise platform that takes months to configure.

Get Started

Ready to see what structured case management feels like? Create a free CaseMgr account and try building a case for one of your active projects. You might be surprised how much cleaner things get when your tool actually matches your workflow. And with CaseMgr’s AI-powered MCP integration, you can use natural language to manage cases, surface connections, and automate routine work right from your existing tools.

You started with a spreadsheet. Maybe a shared Google Sheet with client names, intake dates, and a column for “Status.” It worked for a while. But as your caseload grew, the cracks appeared.

Nonprofits Have Unique Tracking Needs — Generic Tools Won’t Cut It

You started with a spreadsheet. Maybe a shared Google Sheet with client names, intake dates, and a column for “Status” that says things like “active” or “pending” or “???” Then someone suggested Trello, so now you have cards. Lots of cards. And somewhere in a filing cabinet (or a Google Drive folder with 47 subfolders), there’s documentation you hope you can find before the next audit.

Sound familiar? If you work at a nonprofit, you’re not alone. Most organizations start with the tools they have, and those tools eventually buckle under the weight of what case management actually requires.

What Nonprofit Case Tracking Actually Involves

Client Intake and Ongoing Records

When a new client walks through your door — whether you’re providing housing assistance, legal aid, counseling, or workforce development — you need to capture structured information. Demographics, needs assessments, referral sources, consent forms. And that’s just day one. Every interaction, service provided, and outcome observed needs to go somewhere retrievable.

Spreadsheets handle this poorly because they’re flat. One row per client means you’re cramming months of history into cells. Trello handles it poorly because cards weren’t designed for rich, evolving records.

Outcome Measurement

Funders want to know: Is your program working? That means tracking outcomes over time. Did the client find stable housing? Did they complete the training program? Are they still employed six months later?

Meaningful outcome measurement requires connecting intake data to milestones to follow-up results. You need to see the trajectory of each case and aggregate those trajectories into program-level reports. A Trello board can’t tell you your program’s success rate.

Compliance and Audit Trails

Whether you’re funded by government grants, foundations, or a mix of both, compliance is non-negotiable. You need to demonstrate:

• Who was served, when, and what services were provided
• That required steps were followed in the correct order
• That staff completed necessary documentation within required timeframes
• That client consent and confidentiality were maintained

An audit trail isn’t a nice-to-have. It’s the difference between keeping your funding and losing it. Spreadsheets have no built-in change tracking. Trello has basic activity logs, but nothing approaching the detail auditors expect.

Donor and Funder Reporting

Every quarter (or month, or year), you need to pull together reports showing how funds were used, how many clients were served, and what outcomes were achieved. If your data lives in five different places, report generation becomes a multi-day ordeal of copying, pasting, cross-referencing, and praying the numbers add up.

Why Generic Tools Break Down

Trello, Notion, Asana, and Google Sheets are excellent tools — for their intended purposes. But nonprofit case management asks them to do things they weren’t built for:

• Mixed content in one place: A case needs tasks, notes, documents, time logs, and structured data. Generic tools force you to pick one or scatter information across integrations.
• Workflow enforcement: When a compliance process requires specific steps in a specific order, you need the system to enforce that — not just suggest it.
• Historical integrity: When an auditor asks “who changed this record and when,” you need a real answer, not a shrug.
• Role-based access: Case workers should see their cases. Supervisors should see their team’s cases. Volunteers might need limited access. Spreadsheets don’t do permissions well.

What Purpose-Built Case Management Looks Like

With CaseMgr, each client gets a case — a single, organized home for everything related to their journey through your program. Inside that case:

• Stages reflect your program’s phases (Intake, Active Services, Follow-Up, Closure)
• Tasks track what needs to happen and who’s responsible
• Milestones mark key outcomes (housing secured, certification earned, employment started)
• Documents and notes live alongside the work, not in a separate system
• Time tracking captures staff hours for grant reporting
• Audit trails record every action automatically

When reporting time comes, the data is already structured. You’re not assembling a report — you’re pulling one from information that was organized from the start.

Making the Switch Without Disrupting Services

The biggest concern nonprofits have about adopting new software is disruption. You can’t pause client services to migrate systems. The practical approach is to start with new cases in CaseMgr while maintaining existing records where they are. As active cases are touched, migrate them over. Within a quarter, most organizations find that the old spreadsheets are only referenced for historical lookups.

Get Started

Your clients deserve better than a spreadsheet row. Sign up for CaseMgr and start tracking client cases with the structure and accountability your program requires. With built-in AI assistance through MCP integration, CaseMgr can also help your team surface patterns across cases and streamline documentation — giving caseworkers more time to focus on the people they serve.

If you’ve ever managed a complex process — onboarding a new client, handling an insurance claim, coordinating a legal matter — you’ve done case management. But you’ve probably done it with a patchwork of spreadsheets, emails, and sticky notes. There’s a better way, and it starts with understanding CMMN.

Case Management Has a Standard — and It’s Not as Scary as It Sounds

If you’ve ever managed a complex process — onboarding a new client, handling an insurance claim, coordinating a legal matter — you’ve done case management. But you’ve probably done it with a patchwork of spreadsheets, emails, and sticky notes. There’s a better way, and it starts with understanding CMMN.

CMMN stands for Case Management Model and Notation. It’s an open standard maintained by the Object Management Group (OMG) that gives us a shared language for describing how cases actually work. Think of it as a blueprint for organizing unpredictable work — the kind where you can’t draw a simple flowchart from start to finish.

Why Cases Aren’t Processes

Traditional workflow tools assume work follows a predictable path: Step A leads to Step B leads to Step C. That works great for manufacturing or order fulfillment. But most knowledge work doesn’t behave that way.

A social worker managing a family’s case might need to schedule a home visit, request school records, and arrange counseling — but the order depends on what they learn along the way. A consultant might need to gather research, interview stakeholders, and draft a report, but new findings change the plan constantly.

That’s what CMMN was designed for: work that’s goal-driven, not sequence-driven.

The Building Blocks, in Plain English

Cases

A case is the container for everything related to a particular situation. It could be a client engagement, a research project, a legal matter, or a support incident. The case holds all the tasks, documents, notes, and history in one place.

Stages

Stages are phases within a case. Think of them as chapters. An insurance claim might have stages like “Initial Review,” “Investigation,” and “Resolution.” You move through stages, but the work inside each stage can be flexible.

Tasks

Tasks are the individual pieces of work. CMMN distinguishes between a few types:

• Human tasks — work that a person does, like “Review application” or “Schedule interview”
• Process tasks — automated steps, like sending a notification or generating a report
• Discretionary tasks — tasks that might be needed, depending on how things unfold. This is where CMMN really shines. Not every case is the same, so case workers can add tasks as the situation requires.

Milestones

Milestones mark significant achievements within a case. “Client approved,” “Funding secured,” “Report submitted.” They don’t represent work themselves — they represent accomplishments that matter for tracking progress.

Sentries

This is the clever part. Sentries are the rules that connect everything. A sentry says “when this condition is met, that thing happens.” For example: “When the initial review task is complete AND the risk score is above 7, activate the investigation stage.” Sentries let you build intelligent, responsive workflows without hardcoding every possible path.

Why Should You Care?

If you’re managing complex work with general-purpose tools, you’re probably experiencing some familiar pain:

• Information scattered across multiple apps and documents
• No clear picture of where a case stands right now
• Difficulty proving what happened and when (audit trails)
• Team members duplicating effort or missing steps
• Reporting that requires hours of manual assembly

CMMN-based tools solve these problems by giving your work structure without rigidity. You get the organization of a formal system with the flexibility that real-world work demands.

How CaseMgr Implements CMMN

CaseMgr is built on CMMN principles from the ground up. When you create a case in CaseMgr, you’re working with real stages, tasks, milestones, and sentries — not just a renamed task list.

Cases hold everything: tasks, documents, notes, time entries, and linked items. Stages let you organize work into meaningful phases. Sentries automate transitions so the right tasks appear at the right time. And because CaseMgr tracks everything with timestamps and user attribution, you get a complete audit trail without extra effort.

The practical result? You spend less time managing your management tool and more time doing the actual work.

Get Started

If you’re ready to bring structure to your case management workflows, create a free CaseMgr account and start building your first case today. CaseMgr also includes AI-powered assistance through its MCP integration, helping you work through cases faster and surface insights you might otherwise miss.

You have a project. Maybe it’s a knitting pattern you’re working through. Maybe it’s a home renovation, a research paper, or a side business you’re launching. Whatever it is, you’ve got stuff — bookmarks, notes, photos, checklists, files, links — scattered across browser tabs, note apps, photo albums, and your kitchen counter.

Sound familiar? You’re not alone. Most project tracking tools assume you’re a software team running sprints. But real projects — the ones real people work on — don’t fit into Kanban boards or sprint cycles. They’re messy, evolving collections of things that need to live together.

What If Your Project Was a Case?

In CaseMgr, a case is just a container for everything related to your project. Think of it like a bin where you toss everything that matters:

• Bookmarks — save that yarn shop URL, the tutorial video, the research paper
• Notes — jot down ideas, measurements, meeting notes, recipes
• Files — attach photos of your progress, PDFs, patterns, documents
• Todos — create checklists for what needs to happen next
• Folders — organize items into groups when things get complex
• Time tracking — log how long you spent on each part

Everything lives in one place, organized the way you think about it — not the way a project management tool thinks you should.

Real Examples

The Knitting Project

You’re making a sweater. Your case might contain:

• A bookmark to the pattern on Ravelry
• A note with your gauge measurements and modifications
• Photos of your yarn haul and progress shots
• A todo list: “Block front panel”, “Seam shoulders”, “Pick up neckline stitches”
• A bookmark to a YouTube tutorial for the stitch pattern
• A file with the PDF pattern you purchased

When the sweater’s done, the case is your record — every decision, every resource, every photo. Start a new one for the next project.

The Home Renovation

You’re remodeling your bathroom. Your case tracks:

• Bookmarks to tile options, fixture specs, and contractor reviews
• Notes from contractor meetings and design decisions
• Photos of inspiration, current state, and progress
• A folder for quotes and invoices
• A todo list for each phase: demo, plumbing, tile, fixtures, paint
• Time entries for tracking labor hours if you’re DIYing

The Research Project

You’re researching a topic — maybe for school, maybe for a blog series, maybe just because you’re curious. Your case collects:

• Bookmarks to papers, articles, and reference material
• Notes summarizing key findings and your own analysis
• Files — downloaded PDFs, exported data, charts
• Todos for what to read next, who to interview, what to write
• A folder grouping sources by subtopic

Why Not Just Use Notion? Or Trello? Or a Folder on Your Desktop?

You absolutely can. But here’s what you’ll run into:

• Notion is powerful but overwhelming. You spend more time designing your system than using it.
• Trello is great for linear workflows but terrible for collecting mixed-type content. A card can’t hold bookmarks, files, notes, and todos naturally.
• Desktop folders hold files but not bookmarks, not notes, not checklists. And searching across folders is painful.

CaseMgr sits in the sweet spot: structured enough to keep things organized, flexible enough to hold anything — and searchable across all your cases with natural language search.

The AI Bonus

Here’s what makes CaseMgr different from every other project tracker: it works with AI too.

CaseMgr is a full MCP (Model Context Protocol) server with 184 tools. That means you can connect Claude, Cursor, or any AI assistant and have it help you manage your cases. Ask your AI to:

• “Add a bookmark for this URL to my kitchen renovation case”
• “Create a todo list for the remaining knitting steps”
• “Search my research case for anything about climate models”
• “How much time have I spent on the bathroom remodel?”

And the best part — you can watch it happen in real time. Open CaseMgr in your browser while your AI works, and you see the case tree update live. Notes appearing, files landing, todos being checked off. You’re not guessing what the AI did; you’re looking at it.

Get Started

Create a free account, make your first case, and start collecting. No credit card, no trial period, no complexity. Just a place to put your stuff.

AI coding agents lose context when their conversation window fills up. Claude Code handles this by compacting — summarizing the conversation to free space. But the summary loses critical details about your active work. We built Context Cases to solve this.

The Approach

Instead of stuffing everything into static CLAUDE.md files (which burn tokens on every message), CaseMgr stores knowledge in cases and loads it dynamically when needed.

Context Cases are regular CaseMgr cases that you link to your working case. After compaction, the system automatically loads your active tasks plus all notes and knowledge from linked context cases.

Example

You’re working on a feature case. You link two context cases:

• System Knowledge — Server configs, SSH access, deployment procedures, architecture decisions
• Client Requirements — Specs, constraints, billing preferences

When compaction happens, Claude automatically recovers all of this — no manual re-explanation needed.

Setting It Up

1. Create Your Context Cases

Create a case for each category of knowledge you want to persist. Add notes with the information Claude needs — environment configs, debugging procedures, test credentials, architecture facts.

2. Link Them

In the case detail view, expand the Context Cases section (below Worktrees), click + Link, and select the cases you want as context.

Or via MCP:

wa mcp graph-link from_id="#1:100" to_id="#1:200" link_type=context

3. Configure the Recovery Hook

Add a PostCompact hook to your project’s .claude/settings.json:

{
  "hooks": {
    "PostCompact": [
      {
        "hooks": [
          {
            "type": "command",
            "command": "echo '{\"hookSpecificOutput\":{\"hookEventName\":\"PostCompact\",\"additionalContext\":\"CONTEXT COMPACTED. Call preferences-get to find current case, then cmmn-get_resume_context to reload work state.\"}}'",
            "timeout": 5
          }
        ]
      }
    ]
  }
}

4. Add Recovery to ~/.claude/CLAUDE.md

## Post-Compaction Recovery (MANDATORY)

After every context compaction, you MUST immediately:
1. Call `preferences-get` to find the current case ID
2. If a current case exists, call `cmmn-get_resume_context` with that case ID
3. Resume work from where you left off

The Principle

CLAUDE.md is the bootstrap. CaseMgr is the knowledge base.

Keep instruction files small and static. Put everything dynamic, detailed, or case-specific into CaseMgr cases and link them as context. The system loads what’s needed, when it’s needed.

Full setup guide: casemgr.systems/context-cases

CaseMgr now supports OAuth 2.0 authorization for MCP connections. This means Claude.ai (and any other OAuth-speaking MCP client) can connect to your CaseMgr instance through a browser-based login flow — no manual token copy-paste needed.

How It Works

1. In Claude.ai, go to Settings → Integrations → Add Integration
2. Enter https://casemgr.systems/mcp
3. Claude.ai discovers the OAuth endpoints automatically
4. A browser window opens — log in to CaseMgr and click Authorize
5. Claude.ai receives an access token and connects

That’s it. All 184 MCP tools are available in your Claude.ai conversation.

Under the Hood

We implemented the full OAuth 2.0 Authorization Code flow with PKCE:

• Discovery — /.well-known/oauth-protected-resource and /.well-known/oauth-authorization-server endpoints tell clients where to authenticate
• Dynamic Client Registration — Clients register automatically via /oauth/register
• PKCE — S256 code challenge prevents authorization code interception
• Consent Page — Users see exactly what they’re authorizing
• Token Exchange — Authorization codes are exchanged for CaseMgr API tokens

The issued tokens are standard CaseMgr API tokens — the same format used by Claude Code and Cursor. They show up in your Tokens page where you can review and revoke them.

Supported Clients

The Tokens page has copy-paste configuration for:

• Claude.ai — OAuth flow (no token needed)
• Claude Code — Bearer token in .mcp.json
• Claude Desktop — Via mcp-remote bridge
• Cursor — Bearer token in .cursor/mcp.json
• VS Code Copilot — Bearer token in .vscode/mcp.json
• Windsurf — Bearer token in mcp_config.json
• Gemini CLI — CLI command or settings.json
• ChatGPT — Manual configuration in Settings

Tool Name Change

One thing we discovered during Claude.ai integration: it validates tool names against ^[a-zA-Z0-9_-]{1,64}$ — no dots allowed. Our tools used dots (cases.list), so we switched to hyphens (cases-list). The change happens at the protocol boundary — all internal code and documentation still works.

CaseMgr now includes a library of 17 public Case Plan Models — reusable workflow templates based on the CMMN standard. Instantiate one to create a fully structured case with stages, tasks, milestones, and sentries already wired together.

What Are Case Plan Models?

Models are templates. Instead of building a workflow from scratch every time, you pick a model and instantiate it. The model creates all the CMMN items (stages, tasks, milestones, sentries, timers) with their relationships already configured.

The Pattern Library

We’ve published six reusable CMMN patterns that serve as building blocks:

• Approval Gate — Decision task routes to approved/rejected branches via conditional sentries
• Decision Tree — Multi-way branching based on a decision task’s outcome
• Escalation Timer — A task with a deadline; if the timer fires first, an escalation path activates
• Multi-Stage Pipeline — Sequential stages gated by sentries
• Parallel Work with Join — Concurrent tasks with a milestone that fires when all complete
• Monitoring Loop — Cron timer drives a webhook, condition sentry auto-resolves when met

Workflow Templates

For end-to-end workflows, we have:

• Bug Triage & Fix — Report → triage (AI decision) → fix → verify
• Project Kickoff — Discovery → planning → execution → closeout
• Research & Report — AI-human collaboration for research and drafting
• Invoice Generation — Client selection → billable items → LaTeX/PDF generation → delivery (our most complex model with 29 definitions)
• AI Work Item Pipeline — Process task creates work for an AI agent
• Recurring API Poll — Timer-driven webhook polling with conditional resolution

Using Models

# List available models (including public ones)
wa mcp models-list include_public=true

# Create a case from a model
wa mcp models-instantiate model_id="#61:37" name="Q1 Budget Approval"

# Or add a workflow to an existing case
wa mcp cmmn-add_model_to_case case_id="#1:123" model_id="#61:40"

In the web UI, click Models in the navigation to browse, or use the Workflow button in any case to add a model’s items.

All models include Mermaid diagrams on the documentation page: casemgr.systems/case-plan-models