Freelancer Project Management: One Board Per Client | GritShip Blog | GritShip
FreelancingWorkflowClient Management
Freelancer Project Management: One Board Per Client
The simplest system that actually works for freelancers: one kanban board per client. Track deliverables, deadlines, and feedback without drowning in tools or tabs.
By Imtiaz··27 min read
Freelancers don't need a project management tool. They need a system that prevents the 11pm "wait, did I send that deliverable?" panic. That moment where you're brushing your teeth and suddenly remember you promised a client revised mockups by end of day — yesterday.
If you're juggling 3–5 clients, each with different timelines, deliverables, and communication styles, the problem isn't a lack of tools. It's a lack of structure. You've got deliverables tracked in email threads, feedback buried in Slack DMs, timelines living in your head, and one client who only communicates via Google Docs comments.
This guide lays out a system that fixes all of that with a single rule: one kanban board per client. No complex setup. No multi-tool stack. One board per client, four columns, and a weekly ritual that takes 15 minutes.
Why generic PM tools fail freelancers
Most project management tools are built for teams. Specifically, they're built for a product manager coordinating 8–15 engineers inside a single company working on a single product. That's nothing like freelancing.
Freelancing has a fundamentally different structure: one person, multiple clients, each with independent timelines and expectations. No PM tool was designed with this model as the primary use case. Most tools bolt on "multi-project" support as an afterthought — and it shows.
Tired of bloated PM tools?
GritShip is project management for developers who'd rather ship than configure.
Here's why the popular tools break down when you freelance:
Jira assumes you're part of a team
Jira's entire data model — epics, sprints, story points, velocity — presumes multiple people collaborating on one product. As a freelancer, you're one person working across multiple products. Every Jira concept works against you. You don't have sprints; you have rolling deadlines. You don't have story points; you have hours billed. Setting up Jira for freelance work is like using a forklift to move a chair.
Notion is a time sink to configure
Notion can do anything. That's the problem. Every freelancer who tries Notion for project management ends up in the same place: three hours deep into building a "client dashboard" with linked databases, relation properties, and rollup formulas. The dashboard looks beautiful. It never gets used after the first week because opening it feels like work.
Trello gets chaotic at 5 clients
Trello is fine for one or two clients. At five clients, you have five boards, each with its own set of labels, columns, and card conventions. There's no cross-board view that actually helps. You end up opening five tabs every morning, scanning each one, and trying to remember what's urgent across all of them. That's not project management — it's tab management.
"I've tried every PM tool on the market. The problem isn't features — it's that I need to see all my clients at a glance without context-switching between five different boards." — Freelance developer, r/freelance
Tool switching eats your best hours
The average freelancer checks 4–6 different apps to get a picture of their workload: email for client requests, Slack for quick messages, a PM tool for tasks, a calendar for deadlines, a spreadsheet for invoicing, and whatever file-sharing tool each client prefers. Every switch costs 2–3 minutes of reorientation. Across a day, that's 30–45 minutes lost to navigating between apps — not doing work, not thinking about work, just finding where the work lives.
The real freelancer workflow problem
The core issue isn't task tracking. It's client boundary management. Each client is a separate universe with its own priorities, feedback cycles, and definition of "urgent." When you mix all clients into one board or one tool view, you lose the boundaries. When you use separate tools per client, you lose the overview.
The one-board-per-client system solves both.
The one-board-per-client system
The system is dead simple. For every active client, you create one project with one board. Every board has the same four columns. Every task on the board is a deliverable or a sub-deliverable — never an internal to-do like "update my invoice template."
Why one board per client and not one board per project? Because clients are the constant in freelancing — projects come and go, scope changes, new work gets added. A client named "Acme Corp" might start as a website redesign and evolve into ongoing development retainer work. The client relationship is the organizing principle, not the project scope.
Step 1: Create one project per active client. Name it after the client, not the project. "Acme Corp" not "Acme Website Redesign." Why? Because clients often add scope, spin up new projects, or change direction. The client relationship is the stable unit, not the project.
Step 2: Set up four columns. Every board gets the same four columns: Backlog → In Progress → Review → Done. No customization. No extra columns for "QA" or "Staging" or "Waiting for Assets." Four columns. Always.
Step 3: Add tasks as deliverables. Each task is something the client will see or receive: "Homepage mockup v2," "API integration — user auth," "Monthly analytics report." If a deliverable is large, break it into sub-tasks. But keep the parent task visible on the board — that's what the client cares about.
Step 4: Set priorities and due dates. Every task gets a priority (P1–P4) and a due date. The due date is the client's deadline, not your internal target. Your internal target should be 2 days before the client deadline. This buffer is non-negotiable.
That's the setup. Under 10 minutes per client. No configuration rabbit holes. No watching YouTube tutorials. No "getting organized" as a substitute for doing the work.
The beauty of this system is that every client board looks identical. When you open any client's project, you instantly know where things stand because the structure is always the same. Your brain doesn't waste cycles adapting to different layouts, label systems, or organizational schemes.
Column meanings for client work
The four columns aren't arbitrary. Each one maps to a specific stage in the freelancer-client workflow, and the meaning is slightly different from how a product team would use them.
Backlog — scoped but not started
This is work you've agreed to do but haven't started yet. Every item here has a clear deliverable and an estimated timeline. If something is vague — "we should probably update the branding" — it doesn't go in Backlog. It goes in a conversation with the client to get it scoped.
Keep Backlog under 10 items per client. If it grows past 10, you're either not doing the work or the client is adding scope faster than you're delivering. Both need a conversation, not a longer list.
A healthy Backlog is a queue, not a wishlist. Every item should have a clear deliverable and an estimated effort. "Explore new design direction" is not a Backlog item — it's a conversation topic. "Design 3 homepage layout options" is a Backlog item. The difference matters because vague items create anxiety. You look at "explore new design direction" and feel the weight of undefined work. Specific items feel manageable.
In Progress — actively working on it
You're spending hours on this today or this week. Strict limit: 3 items maximum across all clients combined, not per client. This is the critical rule. If you have 5 items In Progress across 3 clients, you're context-switching so much that every deliverable takes 40% longer than it should.
Three items In Progress, total. One primary task getting deep focus, and two secondary tasks you can switch to when the primary is blocked or when you need a mental break.
Why 3 and not 5 or 2? Two is too restrictive when you have multiple clients — you might have one task blocked on client feedback and need flexibility. Five is too many — at five concurrent tasks, you're not really making progress on any of them. Three is the minimum number that allows flexibility and the maximum that allows focus. It's a constraint that forces prioritization without creating bottlenecks.
Review — ball is in their court
This column is the most important one for freelancers, and it's the one most PM systems lack. Review means: you've delivered something and you're waiting for the client to respond. A mockup sent for approval. A staging link shared for feedback. A document submitted for sign-off.
💡 Why the Review column changes everything
Without a Review column, you lose track of what's waiting on clients vs. what's waiting on you. Items sit in limbo. You forget to follow up. The client assumes you're still working on it. Three weeks later, someone asks "where's that deliverable?" and neither of you can remember the last status. The Review column makes the handoff visible. If something sits in Review for more than 5 business days, you follow up. No exceptions.
Done — approved and delivered
Done doesn't mean "I finished coding it." Done means the client has approved, accepted, or signed off on the deliverable. Moving a task to Done is an explicit act that says: this item is closed, paid for (or will be on the next invoice), and no longer needs attention.
Review your Done column at the end of each month. It's your invoice backup, your portfolio evidence, and your proof of value when a client asks "what have you been working on?"
Don't underestimate the psychological value of Done. Freelancing can feel like running on a treadmill — work comes in, work goes out, and it's hard to see progress. A Done column full of completed deliverables is tangible proof that you're moving forward. It's also useful during rate negotiation: "Here are the 14 deliverables I completed for you last quarter" is a stronger argument than "I've been really busy."
Managing the client feedback loop
Feedback is where freelancer project management falls apart. A client emails you revisions at 4pm. You drop everything to address them. Three hours later, you've lost your momentum on another client's deliverable, and neither task is further along than it was at 3pm.
This pattern is so common that most freelancers consider it normal. It isn't. It's a system failure — specifically, a failure to separate receiving feedback from acting on feedback. Those are two different activities, and treating them as one is what causes the constant context-switching that makes freelancing feel chaotic.
The fix is simple: treat client feedback as a new task, not an interrupt.
When feedback comes in — email, Slack, a comment in Figma, a voicemail — do this:
Create a task in the relevant client's Backlog. Title it clearly: "Homepage — address client feedback round 2." Paste or link the actual feedback in the task description.
Assign a priority. Not everything is urgent, even if the client's tone suggests otherwise.
Don't context-switch immediately. Finish what you're working on first. Then pull the feedback task into In Progress when you're ready.
The P1–P4 priority system for freelancers
Priority labels mean different things for freelancers than for product teams. If you've never used a formal priority framework before, the P1–P4 prioritization system for indie hackers goes deeper on the two-question filter that drives the definitions below:
P1 — Blocking launch or payment. The client can't launch, go live, or approve the final invoice until this is resolved. Drop everything. Handle it today.
P2 — This week's work. Important, deadline-bound, but not blocking anything right now. This is your bread and butter — most tasks should be P2.
P3 — Nice to have. The client mentioned it, you agreed it's worth doing, but there's no hard deadline. Do it when P1 and P2 are clear. Warning: if a P3 sits for more than 2 weeks, either promote it to P2 or ask the client if it's still relevant.
P4 — Someday. "It would be cool if..." ideas that the client floated but hasn't committed to. Review P4s monthly. Most of them die natural deaths. That's fine.
The key discipline here is assigning the priority before you act on the feedback. Your instinct — especially early in a client relationship — is to jump on everything immediately to seem responsive. But responsiveness and reactivity are different things. A quick acknowledgment ("Got it, I'll prioritize this and get back to you") is responsive. Dropping your current task mid-flow to address a P3 request is reactive. The first builds trust. The second burns hours.
ℹ️ The 'everything is urgent' client
Some clients mark everything as urgent. When this happens, don't push back in the moment. Instead, ask: "I have three items from you this week — the homepage revisions, the API fix, and the new landing page. Which one should I finish first?" Forcing a rank order exposes what's actually urgent vs. what just feels urgent. Do this consistently and most clients self-correct within a month.
The Friday client status ritual
Every Friday, block 15 minutes. No calls. No Slack. Just you and your boards. This is the highest-leverage 15 minutes in your freelance week.
Here's the protocol:
For each client board, count the items in each column.
Check the Review column first. If items have been in Review for more than 5 business days, send a follow-up. Keep it short: "Hi [name], just checking in on [deliverable] — any feedback, or are we good to mark this as approved?" Don't apologize. Don't over-explain. Just prompt a response.
Check In Progress next. If you have more than 3 items In Progress across all clients, something is wrong. Either you're taking on too much, or tasks are stalling. Identify the stalled ones and decide: finish them Monday, or move them back to Backlog and be honest about the delay.
Check Backlog last. Are the priorities still accurate? Did a client's timeline shift this week? Does anything need to move up or down? Reorder as needed.
Update your client status notes. For each client, write one sentence summarizing where things stand. "Acme: homepage in review, API work starts Monday." "Widget Co: all deliverables on track, nothing in review." These one-liners are gold when a client calls unexpectedly on Monday morning asking for a status update.
💡 The Friday checklist
☐ Review column: anything older than 5 days? Follow up.
☐ In Progress: more than 3 items total? Reprioritize.
☐ Backlog: priorities still accurate?
☐ Any deadlines next week? Flag them now.
☐ One-sentence status per client — write it down.
☐ Any invoices to send based on Done column?
Total time: 15 minutes. You walk into the weekend knowing exactly where every client stands. Monday morning, you open your boards and start working — no 30-minute "where was I?" ramp-up.
This ritual pays for itself in one less missed follow-up per month. A single missed follow-up can delay a project by weeks and cost you a client's trust. Fifteen minutes of structured review is cheap insurance against that.
When to invite the client to your board
This is the question that splits freelancers into two camps. Some swear by full transparency — "the client can see everything I'm working on." Others treat their board as an internal tool and share status via email updates. Both approaches work. The right choice depends on the client.
Invite them when...
They ask "where are we?" more than once a week. If a client needs frequent status updates, a shared board eliminates the back-and-forth. They can check the board whenever they want. You stop writing status emails.
The project has many moving pieces. A 6-month website build with 40+ deliverables benefits from shared visibility. The client can see what's in progress, what's in review, and what's coming next without scheduling a call.
They're technical or PM-savvy. Clients who understand kanban boards intuitively — product managers, CTOs, other developers — will actually use the board. They'll move items, add comments, and flag priorities directly. This saves everyone time.
Don't invite them when...
They'll micromanage. Some clients see a board and start rearranging priorities daily, questioning why something is still "In Progress," or adding tasks without discussion. If a client has control tendencies, the board becomes a source of friction, not clarity.
The project is small and short. A 2-week logo design doesn't need a shared board. An email thread is fine. Don't add process overhead to simple projects.
They don't want it. Some clients hire you precisely because they don't want to manage the work. They want to send you requirements and receive deliverables. Forcing a board on them creates obligation where they wanted delegation.
The rule of thumb: start without sharing. If the client asks for more visibility — or if you find yourself writing more than two status emails per week — offer board access. Let the need pull the tool, not the other way around.
When you do share, set expectations upfront: "This board shows where every deliverable stands. The Review column means I've delivered and I'm waiting for your feedback. You're welcome to add comments on tasks, but let's discuss priority changes in our weekly call." Clear boundaries prevent the board from becoming a chat channel.
Choosing the right tool
The one-board-per-client system works in any tool that supports multiple projects with kanban views. But some tools make it easier than others. The deciding factor isn't features — it's friction. You want the tool where creating a task takes fewer seconds than writing down a sticky note. Anything slower than that, and you'll stop logging tasks when you're busy (which is when logging matters most).
GritShip — one project per client, zero setup
GritShip is built for exactly this workflow. Create a project for each client, set up your four columns, and start adding tasks. It's keyboard-first, loads instantly, and doesn't ask you to configure anything before you start working. The free plan covers everything a freelancer needs to get started — up to 3 projects, unlimited tasks, and all the core features like boards, labels, comments, and real-time sync. Need more projects? The Pro plan ($8/month flat) unlocks unlimited projects, recurring tasks, and more. If you want a tool that gets out of your way and lets you focus on client work, this is the straightforward choice.
Notion — if you need docs and tasks in one place
If you already store client briefs, meeting notes, and contracts in Notion, adding a kanban view makes sense. The advantage is everything lives in one workspace. The disadvantage is Notion's flexibility — you'll be tempted to build a complex client portal when a simple board would suffice. If you go this route, timebox your setup to 20 minutes and resist the urge to add database relations.
Trello — familiar but limited
Trello works for the board-per-client model, and most freelancers already know how to use it. The free tier (10 boards per workspace) is enough for up to 10 clients. The limitations — no native subtasks, weak reporting, no cross-board views — become painful around the 4–5 client mark. Fine for getting started, but you'll likely outgrow it.
ℹ️ The tool matters less than the system
Whichever tool you pick, commit to it for at least 3 months. The productivity gains from mastering one tool's shortcuts, patterns, and quirks far outweigh the marginal differences between tools. The system — one board per client, four columns, Friday ritual — is what does the work. The tool just holds it.
Common freelancer PM mistakes
Even with a solid system, there are patterns that quietly sabotage freelancer productivity. Recognizing them early saves weeks of accumulated friction.
Mixing personal tasks with client work
Your "redesign my portfolio" task does not belong on a client board. Keep personal and business development tasks in a separate board or tool entirely. When personal tasks live alongside client deliverables, client work always wins the priority battle, and your own projects never move forward.
This is also true for meta-tasks like "find a better invoicing tool" or "write blog post for my site." These are important for your freelance business — but they're not client deliverables. Give them their own space where they won't compete with paying work for attention.
Not tracking the Review handoff
You send a deliverable to the client. You don't log it anywhere. Two weeks later, you've both forgotten about it. The project stalls, and neither party knows why. Every time you deliver something for client review, move the task to the Review column immediately. Not later. Not "when you get a chance." Immediately. This takes 5 seconds and prevents weeks of lost time.
Bonus: the Review column also protects you in disputes. "I delivered the first draft on March 3rd — it moved to Review that day, and I followed up on March 10th when I hadn't heard back." That's a documented timeline, not a he-said-she-said argument.
Over-committing because Backlog looks manageable
A Backlog of 8 items per client looks fine. Across 4 clients, that's 32 pending deliverables. If you're doing the work of one person (you are), that's likely 6–8 weeks of work sitting in your pipeline. Freelancers routinely overcommit because each client's board looks reasonable in isolation.
During your Friday ritual, count total items across all boards. If your total Backlog exceeds what you can deliver in 4 weeks, you need to renegotiate timelines or stop taking new work. This is the single most important cross-board check. No individual board will tell you you're overcommitted — only the aggregate view will.
Treating every client message as a task
Not every email is a deliverable. "Can we hop on a call next week?" is not a task. "What's your availability in April?" is not a task. Only create tasks for items that result in a deliverable or a change to a deliverable. Everything else is communication — handle it in your inbox, not on your board.
A good filter: if you can't describe the task's output in physical terms — a file, a deployed page, a document, a component — it's probably not a board task. "Discuss Q2 roadmap" is a calendar event. "Build Q2 roadmap presentation" is a task. The distinction keeps your board focused on work that moves projects forward, not administrative overhead.
How many clients can you actually manage?
The honest answer depends on the type of work. But there are practical limits that most freelancers discover through painful experience.
Deep work clients (development, design, writing): 3–4 max. These clients require focused, multi-hour blocks. Context-switching between deep work projects is expensive — research shows it takes 15–25 minutes to fully re-engage after switching. At 4 deep-work clients, you're spending roughly 20% of your day just getting back into context. That's an entire day per week lost to mental transitions.
Light-touch clients (maintenance, consulting, advisory): 6–8. These clients need a few hours per week each. The context-switch cost is lower because the work is shallower and more repetitive. But even here, communication overhead scales linearly — each client means another inbox to monitor, another set of expectations to manage, and another relationship to maintain.
Mixed portfolios: 4–5 total. Most freelancers run a mix. Two or three deep-work clients plus one or two light-touch clients is the sweet spot. Beyond 5 total, quality drops and deadlines start slipping — not because you lack skill, but because you lack hours. The same context-switching math applies to managing multiple projects as a solo developer — the numbers are unforgiving whether your "projects" are clients or products.
Here's a practical test: if you can't write one sentence describing each client's current status without looking at your board, you have too many clients. The one-board-per-client system makes this test easy — but it can't change the underlying math of available hours.
3–4
Deep work clients
maximum for quality output
15–25 min
Context-switch penalty
per client transition
5
Total client cap
for mixed freelance portfolios
If you're consistently at capacity and turning away work, that's a signal to raise your rates — not to take on client number 6.
The one-board-per-client system makes capacity visible in a way that mental tracking never does. When you see 32 items across 4 client boards during your Friday review, the math is undeniable. No guessing, no "I think I can squeeze it in." Just clear numbers that inform clear decisions.
Making it stick
The hardest part of any freelancer project management system isn't the setup. It's week 3, when you're deep in a client deadline and the Friday ritual feels like a luxury you can't afford. You skip it. Then you skip the next week. Then you're back to managing projects in your head and email.
The irony is that the weeks when you feel too busy for the ritual are the weeks when you need it most. That's when deliverables slip through the cracks, follow-ups get forgotten, and the 11pm panic returns. Consistency during busy periods is what separates freelancers who scale to premium rates from those who stay overwhelmed at the same income level.
Three things prevent the system from dying:
Keep the system visible. Make your project boards your browser homepage or your first pinned tab. If you have to navigate to your PM tool, you won't. If it's already open, you'll glance at it reflexively.
Protect the Friday ritual. Block it on your calendar. Treat it like a client call — something you don't skip because "things are busy." Things are always busy. That's exactly when the ritual is most valuable.
Don't over-engineer. If you catch yourself adding custom fields, color-coding labels, or building automations, stop. The system works because it's simple. Every layer of complexity you add is a layer that needs maintenance. And maintenance is the thing freelancers quit first.
Review Done for invoicing. At the end of each month, scan the Done columns across all client boards. That's your invoice line items right there — no digging through email threads or toggling between time trackers and spreadsheets. If you bill per deliverable, the Done column is your invoice. If you bill hourly, it's at least a complete record of what you produced.
One board per client. Four columns. Fifteen minutes on Friday. That's the system. It won't win any productivity awards. It won't make for interesting tweets about your "workflow." But it'll prevent the 11pm panic, and that's worth more than any tool.
Frequently asked questions
How do freelancers manage multiple client projects?
The most effective approach is the one-board-per-client system: create a separate kanban board for each active client with four columns (Backlog, In Progress, Review, Done). Keep a strict WIP limit of 3 items In Progress across all clients combined. Run a 15-minute Friday review to check status across all boards. This prevents the two biggest freelancer problems — losing track of deliverables and missing follow-ups on client feedback.
What's the best project management tool for freelancers?
The best tool is the simplest one you'll actually use. GritShip works well for the one-board-per-client workflow — it's fast, keyboard-driven, and free for freelancers. Notion is a good choice if you already store client docs and notes there. Trello is familiar but limited at 5+ clients. The tool matters less than the system: one board per client, consistent columns, and a weekly review ritual.
How do you track client deliverables?
Every deliverable or sub-deliverable becomes a task on the client's board. Use the four-column system: Backlog (scoped but not started), In Progress (actively working), Review (delivered, awaiting client feedback), Done (approved by client). The Review column is the most critical — it tracks what's waiting on the client, so nothing falls through the cracks. Set due dates based on client deadlines with a 2-day internal buffer.
Should freelancers use Jira?
No. Jira is designed for teams of 10–50+ engineers working on a single product. Its core concepts — sprints, story points, epics, velocity tracking — assume multiple people coordinating within one organization. As a freelancer managing several clients, you need client-separated boards with simple deliverable tracking. Tools like GritShip, Trello, or even Notion are better fits. Jira's configuration overhead alone can consume hours that freelancers can't afford.
How do you handle client feedback on projects?
Treat client feedback as a new task, not an interrupt. When feedback arrives (email, Slack, Figma comment), create a task in the client's Backlog, assign a priority (P1 if it blocks launch, P2 for this-week work, P3 for nice-to-have, P4 for someday), and don't context-switch immediately. Finish your current In Progress task first. This prevents the reactive mode that kills freelancer productivity — constantly dropping what you're doing to address the latest client message.
How many client projects can a freelancer manage at once?
For deep work (development, design, writing): 3–4 clients maximum. For light-touch work (consulting, maintenance): 6–8 clients. For mixed portfolios: 4–5 total. The bottleneck isn't hours — it's context-switching. Research shows 15–25 minutes of lost productivity per client transition. Beyond these limits, quality drops and deadlines start slipping. If you're consistently at capacity, raise your rates rather than taking on more clients.
Should you share your project board with clients?
Start without sharing, and offer access only when the need is clear. Invite clients who ask 'where are we?' more than once a week, clients on complex multi-month projects, or technically savvy clients who'll use the board productively. Don't share with clients who tend to micromanage, on small short-term projects where email suffices, or with clients who prefer delegation over visibility. Let the client's behavior guide the decision — not a policy.
What columns should a freelancer use on a kanban board?
Four columns: Backlog (scoped work not yet started, max 10 items), In Progress (actively working on it, max 3 across all clients), Review (delivered to client, awaiting their feedback or approval), and Done (client approved and deliverable is complete). The Review column is what separates freelancer boards from team boards — it tracks the handoff point where responsibility shifts to the client, preventing forgotten follow-ups and stalled projects.