TaskFlow - Team Task Management for Small Agencies

The Problem

I noticed a pattern while talking to friends running small creative agencies: they all complained about the same thing. Their project management setup was broken, but not in the way you’d expect.

They weren’t lacking tools. They had too many.

A typical agency workflow looked like this:

• Tasks in Trello
• Client communication in email
• Internal discussion in Slack
• Files in Google Drive
• Meeting notes in Notion
• Invoices in QuickBooks

When someone asked “what did the client say about the logo revisions?”, the answer was scattered across three tools. When a project manager went on vacation, no one else could pick up the context.

The problem wasn’t missing features. It was fragmented context.

Existing tools failed in predictable ways:

• Trello/ClickUp — Great for tasks, terrible for context. Where do client constraints live? What did the client actually say in that call?
• Asana/Monday — Built for 50+ person teams. Small agencies drowned in features they’d never use.
• Notion — Flexible but requires constant curation. Agencies wanted structure, not a blank canvas.
• Slack/Email — Perfect for communication, useless for decisions. Everything disappears into threads.

The gap: A tool that combined tasks with the context needed to execute them, designed for teams of 3-8 people.

Research & Validation

I didn’t want to build another project management tool on a hunch. I talked to people first.

15 agency interviews:

• 8 creative agencies (design, branding)
• 4 marketing agencies
• 3 dev shops

Key findings:

1. Context switching was the #1 pain point (mentioned by 14/15)

   • “I spend 30 minutes every morning just remembering where things are”
   • “We lose client feedback because it’s buried in email”

2. They didn’t want customization (12/15)

   • Surprising: they wanted opinionated software
   • “We just want it to work, we don’t want to configure it”
   • They’d tried Notion, built complex systems, then abandoned them

3. Time tracking was irrelevant (13/15)

   • Most worked on retainers or fixed-price
   • Tracking felt like surveillance

4. Client communication lived in email (15/15)

   • They wanted to pull clients into the tool, but clients resisted
   • Alternative: built-in client portal where clients can check status

Validation signal: When I described the concept (“tasks + client context in one lightweight tool”), 11/15 said “I’d pay for that today.”

Key Decisions

Decision 1: Web-First, Not Mobile

Context: Every productivity tool ships mobile apps. Users expect it.

Options considered:

• Full mobile app (React Native)
• Mobile-responsive web
• Desktop-only

What we chose: Mobile-responsive web, no native app.

Reasoning:

• Agencies work on desktop 90% of the time
• Mobile app would double development time
• Mobile use case = checking status, reading comments (works fine in mobile browser)
• No one was going to create tasks or write briefs on their phone

Outcome: Zero complaints about mobile. Saved 200+ hours of development. Correct call.

---

Decision 2: No Time Tracking

Context: Almost every PM tool has time tracking. It’s expected.

Options considered:

• Full time tracking (clock in/out, timers)
• Simple time estimates
• Nothing

What we chose: Nothing. No time tracking at all.

Reasoning:

• 13/15 agencies didn’t bill hourly
• Time tracking adds cognitive overhead (“did I start the timer?”)
• Felt like surveillance to team members
• Would require entire tracking UI, reports, exports

Outcome: Not a single user has asked for it. Agencies that need it use Harvest separately. Removing it kept the product focused.

---

Decision 3: Built-In Client Communication

Context: Client questions arrive via email. Should clients live in the tool?

Options considered:

• Client accounts (full access)
• Read-only client portal
• Email integration only
• Nothing (keep clients in email)

What we chose: Read-only client portal with status updates and comment threads.

Reasoning:

• Full client accounts = permission system, user management complexity
• Email integration = unreliable, breaks when email providers change
• Portal = clients see project status, can leave comments, but can’t edit

Outcome: 8/12 agencies actually use the client portal. Clients appreciate transparency. Agency teams appreciate having client feedback in context.

---

Decision 4: Opinionated Workflow

Context: Should we be flexible like Notion or structured like Basecamp?

Options considered:

• Full customization (custom fields, workflows, views)
• Template library
• One opinionated way

What we chose: One opinionated structure: Projects → Phases → Tasks.

Reasoning:

• Customization = analysis paralysis
• Templates = users still need to make decisions
• Opinionated = works immediately, no setup

Outcome: Best decision we made. Users sign up and start working in 5 minutes. No “getting started” tutorial needed. No setup fatigue.

Scope & Features

What we built (v1 launch scope):

• Projects — One project per client engagement
• Phases — Discovery, Design, Development, Launch (customizable)
• Tasks — Assignee, due date, description, attachments
• Client context — Notes section per project for constraints, feedback, decisions
• Comments — Per-task threaded discussions
• Client portal — Read-only view for clients to see progress
• File uploads — Direct upload, no Drive integration needed
• Notifications — Email + in-app

What we deliberately excluded:

• ❌ Time tracking — Agencies didn’t need it, would add complexity
• ❌ Invoicing — They already have tools for this (QuickBooks, Wave)
• ❌ Resource allocation — Agencies this small know who’s working on what
• ❌ Gantt charts — Overkill for 2-month projects
• ❌ Custom fields — Adds configuration overhead
• ❌ Integrations — Focused on being self-contained first
• ❌ Mobile app — Responsive web sufficient

The exclusions were as important as the inclusions. Every feature we cut reduced complexity and shortened time-to-launch.

What We Built

Dashboard

The home screen shows all active projects at a glance. Each card displays:

• Project name + client
• Current phase
• Overdue tasks (if any)
• Last activity timestamp

No configuration needed. This is what you see when you log in.

---

Task Detail View

Tasks are the atomic unit. Each task includes:

• Description (markdown supported)
• Assignee (single person, not “team”)
• Due date (optional)
• Phase (where it fits in project timeline)
• Comments (threaded discussions)
• Attachments (drag-and-drop uploads)

Design principle: Everything needed to execute a task should be on this screen. No hunting across tools.

---

Client Portal

Clients get a unique link per project. They see:

• Project status (% complete)
• Current phase
• Completed tasks (recent)
• Ability to leave comments
• File downloads

Key insight: Transparency builds trust. Clients who can see progress ask fewer status update questions.

---

Client Context Section

Every project has a “Context” section (visible to team, not client). This is where you dump:

• Client preferences (“hates purple”)
• Constraints (“needs to launch before Black Friday”)
• Meeting notes (“CEO wants video on homepage”)
• Decisions (“went with Option B for logo”)

Why this matters: When someone asks “why did we do it this way?”, the answer is right there. No Slack archaeology.

Tech Stack Deep Dive

Frontend:

• Next.js 14 (App Router) — Server components for speed, client components for interactivity
• TypeScript — Caught bugs at compile time, improved DX
• Tailwind CSS — Rapid UI iteration, consistent design system

Backend:

• Supabase — PostgreSQL + auth + real-time subscriptions
• Supabase Storage — File uploads without S3 complexity

Infrastructure:

• Vercel — Deploy on push, zero config, global CDN
• Resend — Transactional emails (task notifications, invites)

Why these choices:

1. Next.js + Supabase — Fastest path to production. Real-time updates (task assigned → instant notification) came free with Supabase subscriptions.

2. Vercel — Deploy previews on every PR. Clients could test features on preview URLs before production.

3. Tailwind — Built entire UI in 3 weeks. No context switching to CSS files. Consistent spacing/colors via design tokens.

What we avoided:

• ❌ Microservices — Monolith was sufficient
• ❌ Custom auth — Supabase Auth worked perfectly
• ❌ Redis/caching — Postgres fast enough for this scale
• ❌ GraphQL — REST was simpler

Development Process

Timeline:

• Month 1: User research, wireframes, database schema
• Months 2-3: Core build (projects, tasks, auth)
• Month 4: Beta with 5 agencies, iteration based on feedback
• Month 5: Polish, client portal, onboarding flow
• Month 6: Public launch

Team:

• Me: Full-stack (Next.js + Supabase), product, design
• Contract designer: 2 weeks for final UI polish

Development approach:

• Weekly releases to beta users
• Feature flags for risky changes
• Direct Slack channel with beta testers for fast feedback

Key milestone: Beta users started paying before public launch. Signal that we’d built something people actually wanted.

Launch Strategy

Pre-launch:

• Beta program — 5 agencies, 3 months free

  • Caught 12 critical bugs
  • Learned client portal was essential (wasn’t in v1 plan)
  • Refined onboarding flow

• Positioning — “Task management for small agencies” (not “project management for teams”)

  • Narrow positioning = easier to explain
  • “Small agencies” filtered out enterprise buyers who’d never fit

Launch day (June 20, 2024):

• Posted on X (Twitter) with demo video
• Submitted to Product Hunt
• Emailed the 15 agencies I’d interviewed

Results:

• 47 signups first day
• #4 Product of the Day on Product Hunt
• 12 agencies started trials

Post-launch:

• Onboarded each trial agency personally (15-min call)
• Asked: “What’s confusing? What’s missing?”
• Iterated weekly based on feedback

Key learning: Personal onboarding calls converted 8/12 trial agencies to paid. DIY onboarding converted 4/35. High-touch worked at this scale.

Results & Metrics

Quantitative (after 6 months):

• Users: 200+ across 12 agencies
• Revenue: $2,400 MRR (growing 15% monthly)
• Retention: 85% weekly active rate
• Pricing: $25/user/month (agencies average 8 users = $200/mo)
• Churn: 1 agency churned (went back to Notion)

Qualitative:

• User feedback themes:

  • “Finally, one place for everything”
  • “Clients love the portal”
  • “Setup took 10 minutes, not 10 hours”

• Client satisfaction:

  • Agencies report fewer “where are we?” emails from clients
  • Client portal gets 60% adoption (clients actually use it)

• Unexpected outcomes:

  • Agencies started winning more clients by sharing portal in proposals
  • “We show prospects the portal before we’ve started. It makes us look professional.”

What Worked

1. Talking to users first — 15 interviews saved months of building wrong features. The “no time tracking” decision came directly from research.

2. Opinionated design — Removing customization made the product easier to build and easier to use. Setup time: under 10 minutes.

3. Personal onboarding — High-touch onboarding at 12 agencies converted 8. Scalable? No. Effective? Absolutely.

4. Client portal — Wasn’t in v1 plan. Beta users asked for it. Built it in 2 weeks. Became the #1 differentiator.

What Didn’t Work

1. Launched without integrations — Users kept asking for Slack/Google Drive integration. Not critical but would’ve been nice for launch.

2. Underpriced initially — Started at $15/user. Raised to $25/user after 3 months. Should’ve started higher.

3. No self-serve onboarding — Personal calls worked for 12 agencies. Doesn’t scale past 50. Should’ve built onboarding flow earlier.

What I’d Do Differently

Technical:

• Use Prisma instead of raw SQL from day 1 (migrations were painful)
• Set up feature flags earlier (deployed broken features to production twice)
• Add integration hooks from v1 (Slack integration took 3 weeks to retrofit)

Product:

• Ship beta 1 month earlier with fewer features (we delayed for polish that didn’t matter)
• Build onboarding flow alongside product (not after launch)
• Record demo video before launch (scrambled to make one after Product Hunt submission)

Process:

• Charge beta users from day 1 (we gave 3 months free, should’ve been 1 month)
• Write more during development (case study was hard to write 6 months later)

Key Learnings

1. Small agencies are underserved — Enterprise tools dominate. Huge opportunity in “too complex for Trello, too simple for Asana” space.

2. Context matters more than features — Users didn’t want more capabilities. They wanted their existing work consolidated in one place.

3. Opinionated software wins for this segment — Small agencies don’t have time to configure tools. They want it to work immediately.

4. High-touch onboarding converts — Personal onboarding calls = 67% conversion. Self-serve = 11% conversion. At small scale, do things that don’t scale.

5. Charge earlier than comfortable — Waiting 3 months to charge meant training users that it’s free. Starting paid trains users to expect value.

Current Status

As of December 2024:

• Status: Live and actively maintained
• Users: 200+ users, 12 paying agencies
• Revenue: $2.4K MRR, growing 15% monthly
• Roadmap:
  • Slack integration (most requested)
  • Recurring project templates
  • API for custom integrations
  • Self-serve onboarding flow

Next milestone: $10K MRR (need ~40 agencies)

---

Links:

• Live Product (demo account available)
• Demo Video
• Product Hunt Launch

---

Built as an internal tool for Credes, then spun out as standalone product. Currently serving 12 agencies, with plans to scale to 50+ in 2025.