TLDR (Summary)
The best project management software for developers is Plutio ($19/month).
Plutio connects project boards to time tracking, client portals, file sharing, and invoicing, so tasks link directly to billing, client communication happens in context, and projects generate invoices automatically when milestones complete. Most project management tools organize work but leave developers switching between separate apps for time tracking (Toggl, Harvest), invoicing (QuickBooks, FreshBooks), client communication (email, Slack), and file sharing (Dropbox, GitHub alone). Plutio replaces that 5-tool stack with one platform where project status, billable hours, client updates, and payment tracking connect automatically.
According to project management research, 60% admin rather than actual development, context switching between disconnected tools for updates, billing reconciliation, and client questions about project status.
For additional strategies, read our freelance project management guide.
What is project management software for developers?
Project management software for developers is software that organizes development tasks with complete visibility into timelines, deliverables, and billing, not just task lists disconnected from revenue.
The distinction matters: generic task boards track what gets done but don't connect completed work to invoicing, client communication to project context, or file sharing to deliverable organization. Developer-focused project management connects to time tracking for accurate billing, client portals for scoped communication, and invoicing for revenue tracking tied directly to sprint completion or milestone delivery.
What developer project management actually does
Core functions include task organization across sprints or milestones, time tracking per task for billable hour calculation, file attachment to specific deliverables so clients access work without email exchanges, and client communication that references project status rather than living in separate email threads. Project boards show work progress while connected systems handle billing, file delivery, and client updates automatically.
Task management vs revenue-connected project management
Pure task management tools like Asana or Monday.com organize work beautifully. They show who's doing what and when it's due. But when a client asks "Where's the staging link?" or "What do I owe for last sprint?", answers require switching to email archives, file storage systems, time tracking apps, and invoicing software. Developer-focused project management answers those questions from the same screen showing task completion, because deliverables, billing, and client access connect to the project board rather than living in separate tools that require manual reconciliation.
What makes developer project management different
Developers balance technical work with client relationships, code reviews happen alongside scope discussions, bug fixes trigger billing adjustments, and deployments require client sign-off before invoicing. Without project management that connects tasks to contracts (what was agreed), time tracking (what's billable), file sharing (what's delivered), and invoicing (what's owed), context scatters. A task marked "Done" in Asana doesn't automatically share the staging link with the client, log billable hours, or generate the invoice for that milestone. Manual steps fill the gap between task completion and business workflow.
When project management connects to client portals, time tracking, and invoicing, developers ship work and handle business operations from one platform, task completion triggers file sharing, hour logging, and payment collection without switching tools or duplicating data entry.
Why developers need project management software
Developers who grow beyond 3-5 active clients face a compounding problem: project boards organize development work, but client questions, file delivery, time tracking, and invoicing still require switching between 4-6 separate tools for every update.
One client asks "What's the status?" in email while the project board shows 70% complete in Asana. Another client needs access to the staging environment, file links live in Google Drive or a private GitHub repo, but sharing requires finding the URL, checking permissions, and sending via separate communication. Invoicing for the completed sprint means exporting hours from Toggl or Harvest, matching them to project tasks manually, then creating the invoice in QuickBooks or FreshBooks. Each tool works, but none share data automatically.
The context-switching problem
According to project management research, 60% meta-work, administrative coordination rather than actual development. For developers specifically, that means updating project status in one tool, then manually updating the client via email, copying time entries from the tracking app to the invoice, and searching file storage for the work when clients ask "Where's that design mockup you mentioned?". Projects get completed on time, but answering basic client questions requires reconstructing context from 5+ disconnected sources.
The fragmentation problem
You stack 5-8 disconnected tools: project management (Asana, ClickUp, Monday.com for $10-25 per user), time tracking (Toggl, Harvest for $9-12 per user), file sharing (Dropbox, Google Drive with varying costs), invoicing (QuickBooks, FreshBooks for $15-30 per month), contracts (DocuSign, PandaDoc for $20-40 per month), and client communication scattered across email and Slack. Each tool handles one function, but none share data automatically. When a milestone completes in the project board, developers still manually create the invoice, attach the deliverable files, notify the client, and log the hours, because the tools don't talk to each other.
The billing reconciliation problem
Project management tools track task completion. Time tracking tools log billable hours. But connecting "tasks completed" to "hours invoiced" requires manual reconciliation. Developers export time entries, match them to project milestones, calculate totals, then manually create invoices. If a client disputes billing, proving which hours map to which the work means cross-referencing the project board, time tracking exports, and email threads where scope was discussed. The data exists in three separate systems that don't connect.
The scaling tipping point
You hit a threshold around 5-7 active projects where the manual approach breaks down. One project uses Asana, another uses Trello because the client requested it, time tracking happens in Toggl, invoicing happens in QuickBooks, and files scatter between Google Drive, Dropbox, and direct email attachments. Answering "How much time did I bill Client X last month?" requires opening four apps and matching records manually. Project boards show work progress, but business operations, billing, file delivery, client updates, still demand tool-switching and data duplication.
Connected project management software absorbs the admin work that would otherwise scale linearly with each new client, task completion automatically triggers time logging, file sharing, and invoice generation instead of requiring manual steps across separate tools.
Project management features developers need
The essential project management features for developers connect task organization with time tracking, client communication, file sharing, and invoicing while handling the unique patterns that development work requires, sprint planning, code review cycles, and milestone-based billing.
Core project management features
- Task boards with sprint/milestone organization: Developers work in iterations, two-week sprints, monthly milestones, or phase-based delivery. Project boards need to group tasks by sprint or milestone, not just generic lists, because billing and client updates align with delivery cycles rather than individual task completion.
- Time tracking per task: Billable hour tracking links directly to individual tasks so invoice generation pulls actual logged time rather than requiring manual time entry reconciliation from separate tracking apps. Developers see exactly which features consumed which hours.
- File attachment to the work: Staging links, design mockups, documentation, and deployment credentials attach to specific tasks or milestones so clients access the work from the project board rather than searching email threads or requesting files repeatedly.
- Client visibility controls: Some tasks show internal development details ("Refactor authentication logic") while others communicate client-facing progress ("Login feature complete"). Developers need granular control over what clients see in portals versus what stays internal to the development team.
- Milestone-based invoicing: Invoice generation triggers when milestones complete rather than requiring manual invoice creation at arbitrary intervals. Sprint 1 completion automatically creates an invoice with logged hours and deliverable descriptions pulled from completed tasks.
Developer-specific features
- Scope change tracking: Client requests often expand beyond original project scope. Developer project management tracks which tasks fall within contracted scope versus additional billable work, letting accurate invoicing for scope changes. Industry research shows 80% rework when scope tracking lacks clarity.
- Client portal access to project status: Clients log into branded portals showing their project board, completed milestones, deliverable files, and upcoming tasks, reducing "What's the status?" emails because clients see real-time progress themselves rather than waiting for manual updates.
- Integrated proposals and contracts: Development projects start with proposals outlining scope, timeline, and cost. When clients accept proposals, the project board, milestone structure, and invoicing schedule generate automatically rather than requiring manual setup across separate tools.
Platform features that multiply value
- White-label branding: Custom domain, logo, colors. All client-facing communications show your brand, not a third-party tool's branding.
- Unified inbox: All client messages arrive in one place, questions about project status, file requests, and payment confirmations appear in a single inbox rather than scattering across email, Slack, and project board comments.
- Permissions: Control who sees what, clients view their projects only, team members access internal tasks and billing details, and contractors see assigned work without accessing client communication or financial data.
- Automations: Create rules that trigger actions without your involvement, milestone completion sends client notifications, invoice reminders go out 3 days before due dates, and project status updates post to client portals automatically when tasks move to "Done".
The deciding factor for developers is integration depth. Project management software that connects tasks to time tracking, client portals, file sharing, and invoicing eliminates duplicate data entry, log time on a task once and it appears in project reports, client invoices, and revenue dashboards automatically.
Project management software pricing for developers
Project management software for developers typically costs $40-100 per month when stacking separate tools for tasks, time tracking, invoicing, and client communication, with integrated platforms providing complete functionality at lower total cost.
What developers typically pay for project management tools
- Asana: $10.99-24.99 per user per month for task management only, add Toggl ($9/user) for time tracking and QuickBooks ($15-30/month) for invoicing
- ClickUp: $7-12 per user per month plus $9 per user for AI features, still requires separate invoicing and client portal tools
- Monday.com: $9-19 per user per month for project boards, lacks integrated time tracking for billable hours and requires external invoicing
- Basecamp: $15 per user per month with flat pricing but no time tracking or invoicing features built in
The comparison reveals the hidden cost: task management alone costs $10-25 per month per user, but developers still need time tracking ($9-12 per user), invoicing ($15-30 total), client portals (often another $20-40 per month), and file storage (varies). Total stack cost reaches $50-100+ monthly when adding all necessary tools, plus the time cost of managing data across disconnected systems.
Plutio pricing (January 2026)
- Core: $19/month: Unlimited project management plus time tracking, invoicing, proposals, contracts, client portals, and file storage for up to 9 active clients.
- Pro: $49/month: Unlimited clients, 30 team members, advanced permissions for contractors and client access controls.
- Max: $199/month: Unlimited team, white-label with custom domain, single sign-on for client portals and team access.
The ROI calculation for developers
- Tool consolidation: Replacing 5 separate subscriptions (project management, time tracking, invoicing, contracts, client communication) with one platform saves $30-80 per month in direct costs.
- Time saved on billing reconciliation: Automatic invoice generation from logged hours eliminates 2-4 hours per month spent exporting time entries, matching to projects, and creating invoices manually.
- Faster client communication: Client portal access to project status, files, and invoices reduces "Where's the staging link?" and "What do I owe?" emails by 60-80%, saving 3-5 hours monthly on status update emails.
Project management software ROI comes through eliminating tool-switching overhead. Plutio pays for itself when developers save 3-4 hours monthly on billing reconciliation and client communication, time that goes back to billable development work instead of administrative coordination across disconnected tools.
Why Plutio is the best project management for developers
Plutio handles project management as part of a complete platform where task boards, time tracking, client portals, file sharing, and invoicing work together rather than as separate tools that need manual connection.
Projects connect to complete client workflow
When a new client signs a development contract, Plutio creates the project board, milestone structure, and invoicing schedule automatically from the accepted proposal. Task boards organize sprints or milestones, but unlike standalone project tools, each task connects to time tracking (for billing), file attachments (for the work), and client visibility controls (for portal access). Developers create a task like "Build user authentication", log 8 hours against it, attach the staging URL when complete, and mark it visible to the client, the client sees the completed feature in their portal, logged hours appear on the next milestone invoice, and the staging link delivers without separate email.
Time tracking that actually connects to invoicing
You use separate time tracking apps (Toggl, Harvest) that export data to spreadsheets for manual invoice creation. Plutio's time tracking links directly to project tasks and invoices. Start a timer on "Homepage redesign", work for 6.5 hours, stop the timer, those hours appear on that task's time log, the project's billable hours total, and the client's next invoice automatically. When milestone 1 completes, clicking "Create Invoice" pulls all logged hours for that milestone with task descriptions as line items. No export, no reconciliation, no manual data entry.
Client portals replace status update emails
Clients log into branded portals showing their project board with completed tasks, in-progress work, and upcoming milestones. When a developer marks "Homepage redesign" as complete and adds the staging URL, the client sees the update in real-time through the portal. File attachments appear under the work, invoices show payment status, and project timelines display progress without requiring manual email updates. The "What's the status?" email volume drops because clients access current information themselves rather than interrupting development work for updates.
Proposals that generate projects automatically
Development work starts with scoping: Client describes needs, developer writes proposal outlining the work, timeline, and cost. In Plutio, creating a proposal includes defining milestones with deliverable descriptions and estimated hours. When the client accepts the proposal through their portal (with digital signature), Plutio automatically creates the project board with milestones as task groups, schedules milestone invoices based on proposal payment terms, and grants client portal access to project status. Manual project setup across tools disappears, proposal acceptance triggers complete project creation.
File delivery through project context
Developers deliver staging links, design files, documentation, credentials, and deployment guides throughout projects. In disconnected tool stacks, files scatter between email attachments, Google Drive folders, Dropbox shares, and GitHub repository links. Plutio attaches files directly to project tasks and milestones. "Homepage redesign" task includes the staging URL and mockup files. "Database migration" task attaches the migration script and documentation. Clients access all the work through their portal organized by milestone rather than searching email threads or requesting links repeatedly.
Scope change documentation for accurate billing
Client requests often expand beyond original contracted scope. Plutio tracks which tasks fall within the original proposal versus additional scope. When a client requests "Can we add a blog section?", developers create a new task, mark it as out-of-scope, log time against it, and include it on the next invoice with clear scope change documentation. Billing disputes reduce because clients see exactly which work was contracted versus which features were requested additions, all documented within the project board rather than reconstructed from email archives.
White-label everything
Use your own domain. Upload your logo, set your brand colors and typography. Every client-facing touchpoint, proposals, contracts, project portals, invoices, file sharing, shows your brand, not Plutio's branding. Clients interact with your business, not a third-party tool.
Unified inbox for all client communication
When a client asks a question through the portal, requests a file, or comments on a task, the message appears in one inbox. Reply directly without opening email. All communication history stays attached to the project context, questions about milestone 2 appear in milestone 2's activity feed, making it easy to reference previous decisions when scope discussions arise.
Granular permissions
Control exactly who sees what at the level that makes sense for your development business. Clients see their projects, the work, and invoices only. Team members access all projects and internal notes. Contractors see assigned tasks without accessing billing information or other clients' work. Permissions adjust per project when specific clients need restricted access to sensitive development details.
No-code automations
Create rules that trigger actions without your involvement. Common developer automations include: send client notification when milestone completes, create invoice 3 days before milestone due date, post staging link to client portal when task marked complete, send payment reminder 2 days before invoice due date, assign code review task when feature task completes. Automations handle routine communication and workflow steps that previously required manual checking and email sending.
Native integrations for developer workflows
Connect Stripe and PayPal for payment processing on invoices. Sync Google Calendar or Outlook for client meeting scheduling. Use Zapier to connect GitHub (commit notifications to project activity), Slack (task updates to team channels), and 3,000+ other apps. Integrations extend functionality while keeping project data, client communication, and billing centralized in one platform.
Everything runs from one app with your branding, your project structure, and your workflow logic, tasks link to time tracking and invoices, client communication references project context, and the work organize by milestone rather than scattering across email, file storage, and task boards that don't share data.
How to set up project management in Plutio
Setting up project management in Plutio takes 2-4 hours for initial configuration, then 5-15 minutes per new project after your templates and integrations are in place.
Step 1: Configure default settings (30 mins)
Set your business details (logo, brand colors, timezone), configure default time tracking settings (billable rate, rounding rules), and establish invoice defaults (payment terms, late fee policy, tax rates). These defaults apply to all new projects unless overridden for specific clients. Developers typically set hourly rates by project type (new development vs maintenance, frontend vs backend) and configure automatic invoice generation when milestones complete.
Step 2: Create project templates (1-2 hours)
Build 3-5 templates covering your common development patterns. For developers, recommended templates include:
- Website Development: Milestones for discovery, design approval, development, client review, deployment. Tasks include wireframe creation, homepage build, responsive testing, staging deployment, production launch. Pre-set time estimates help with proposal creation.
- Feature Development: Sprint-based template with planning, development, testing, deployment milestones. Includes standard tasks for spec review, code setup, unit tests, integration testing, and production deployment.
- Maintenance Contract: Monthly recurring structure with task categories for bug fixes, feature requests, and support. Time tracking per category enables accurate reporting of how maintenance hours distribute across work types.
- Mobile App Development: Platform-specific milestones (iOS development, Android development, backend API, testing, app store submission). Separate client review cycles for each platform.
Step 3: Connect integrations (20 mins)
Link Stripe and/or PayPal for invoice payment processing. Connect your calendar (Google Calendar or Outlook) for client meeting scheduling. Test each integration before using with actual clients, send yourself a test invoice, process a $1 payment, confirm calendar sync creates events correctly. Integration testing during setup prevents payment processing issues when real client invoices go out.
Step 4: Import existing project data (30 mins)
Upload existing client information via CSV export from your current CRM or contact system. Import active project details manually. Plutio doesn't auto-import from other project management tools, but copying task lists from Asana or Trello into new Plutio projects takes 10-15 minutes per project. Focus on active projects rather than historical archives.
Step 5: Test with one real project
Run through the complete workflow with an actual client rather than a test account. Create a project from template, log time on tasks, generate an invoice from logged hours, and have the client access their portal to review project status. Testing with real workflow reveals integration issues and template improvements before rolling out to all clients.
Common setup mistakes to avoid
- Over-customizing too early: Start minimal and refine based on actual use. Developers often create elaborate task taxonomies during setup, then realize simpler structures work better after using Plutio for 2-3 projects.
- Ignoring mobile: Download the mobile apps during setup and test key workflows, logging time from mobile, checking project status, reviewing client messages. Many developer workflows happen away from desk, and mobile access matters.
- Skipping automation setup: Configure milestone completion notifications and invoice reminders during initial setup. Adding automations later requires remembering to do it, but setting them up during configuration means all new projects benefit from automated client communication immediately.
Build templates for the 80% cases that cover most of your development work, website builds, feature development, maintenance contracts. Edge cases can use custom project structures, but templates accelerate project creation for typical client engagements.
Project management organization for developers
Organizing project management creates clarity for clients and enables efficient workflow tracking across multiple concurrent development projects.
Project structure approaches for developers
- Milestone-based organization: Large projects divide into milestones representing deliverable phases (Discovery & Planning, Design, Development, Testing, Launch). Each milestone contains tasks, time tracking, and deliverable files. Invoicing triggers at milestone completion rather than arbitrary billing cycles.
- Sprint-based organization: Agile developers organize work in 1-2 week sprints. Each sprint functions as a mini-milestone with planning, development, and review tasks. Sprint completion generates status reports showing completed features, logged hours, and next sprint planning.
- Retainer/maintenance organization: Ongoing support contracts organize by work category (bug fixes, feature requests, support) rather than chronological milestones. Time tracking per category enables reporting how monthly retainer hours distribute across work types.
Task organization stages
- Backlog: Requested features or reported bugs not yet scheduled for active development. Client requests accumulate here for prioritization.
- Sprint Planning/This Milestone: Work scheduled for current development cycle. Tasks have assigned developers and time estimates.
- In Progress: Active development work. Tasks in this stage have time logged against them and may include staging links or work-in-progress files.
- Client Review: Completed development pending client feedback. Tasks include staging URLs or preview builds for client testing.
- Complete: Approved work deployed to production. Tasks in this stage appear on invoices and client portal as completed deliverables.
Information to track per project
- Client contact information and communication preferences
- Project scope from accepted proposal, what's included versus what's additional billable work
- Technology stack and credentials (hosting, domains, third-party services, API keys)
- Time logged per task with billable/non-billable designation
- Deliverable files organized by milestone (designs, staging links, documentation, source code)
- Scope change requests with date, description, and client approval status
- Payment schedule and invoice status (paid, pending, overdue)
Proven methods for developer project organization
- Use consistent task naming that clearly communicates what gets delivered,"Build user authentication with email/password and OAuth" versus vague "Auth feature"
- Attach staging URLs and credentials to tasks when marking complete so clients access preview work without requesting links via email
- Mark tasks as client-visible or internal-only so client portals show meaningful progress without exposing technical setup details that don't communicate client value
- Log time daily rather than reconstructing hours at week's end, timer accuracy degrades when trying to remember "How long did that refactoring take on Tuesday?"
- Document scope changes in task descriptions when client requests expand beyond original proposal, enabling clear billing communication when invoices include out-of-scope work
Organized project management enables accurate billing and clear client communication. Structure serves both developer workflow (what to build next) and client understanding (what's done, what's in progress, what it costs).
Client portals for developers: project management connection
Client portals connect project management data to client-facing access, creating smooth communication without constant email updates about status, deliverables, and billing.
Portal as project visibility hub
Clients access their complete project status through branded portals. Current sprint tasks, completed milestones, in-progress features, and upcoming work appear in one place. Project management data powers what clients see, when a developer marks "Homepage redesign" as complete and attaches the staging URL, the client sees that update in their portal immediately. Deliverable files, feature descriptions, and timeline progress synchronize from project boards to client view automatically.
Consistent client experience across projects
Portal presentation reflects the organized project data in project management. Milestones show completion percentages, deliverable files organize by phase, and task descriptions communicate progress in client-friendly language. Professional, consistent client experience across all interactions, clients don't see messy internal task names like "Refactor DB queries", they see client-facing descriptions like "Improve site load speed" because developers control task visibility to portals.
Self-service access to deliverables and status
Clients find their own staging links, design mockups, documentation, and deployment credentials. Project management organization enables client self-service without administrative burden, staging URL attached to "Homepage" milestone means clients access preview work themselves rather than emailing "Can you send me the link again?". Invoices show payment status and download options. Timeline displays what's complete, what's in progress, what's upcoming. Complete project picture from client perspective.
Two-way visibility into progress and feedback
Portal interactions feed back into project management. Client comments on milestone deliverables appear in the project activity feed. Client approval of staging work triggers automatic task status updates. Client questions about specific features attach to those task threads rather than arriving as disconnected email. Complete picture from both perspectives, developers see client feedback in project context, clients see development progress in portal access.
Project continuity across engagements
Portals maintain project history across development phases. Returning clients find their previous project deliverables, source code repositories, and communication history. Connection maintained between initial website build and subsequent feature additions six months later, all project data accessible through the same portal rather than starting fresh or searching email archives for previous work context.
Portals make project management client-facing. Internal task organization translates to external client experience, developers organize work in project boards, clients see that organization as progress updates, deliverable access, and billing transparency without requiring manual status report creation.
How to migrate project management to Plutio
Migration from another project management tool typically takes 3-5 hours of active work spread over a weekend, with the best time to switch being between projects rather than mid-sprint when active development work needs continuity.
Step 1: Export from your current tool
Most project management software provides CSV export. Here's what to export from common tools:
- Asana: Export projects as CSV from project menu → Export → CSV. Includes task names, assignees, due dates, and descriptions. File attachments require manual download.
- Trello: Board menu → More → Print and Export → Export as JSON. Convert to CSV using online converters if needed. Card attachments download separately.
- Monday.com: Board menu → Export → Excel or CSV. Choose which columns to include in export.
- ClickUp: Space settings → Export → CSV format. Select tasks, subtasks, and custom fields for export.
Step 2: Build templates in Plutio (2-3 hours)
Use your exported project data as reference to create new project templates. Focus on forward-looking workflows, not historical archives, how you want projects structured moving forward, not how they were organized in the old system. Create templates for common development patterns (website builds, feature development, maintenance contracts) with typical milestones, task categories, and time estimates. Templates accelerate new project creation while allowing customization for specific client needs.
Step 3: Set up integrations (30 mins)
Connect payment processing (Stripe, PayPal), calendar sync (Google Calendar, Outlook), and accounting software (QuickBooks, Xero) before migrating active projects. Test each integration, send yourself a test invoice, process a $1 payment, confirm calendar events sync correctly. Integration issues discovered during active client work create payment delays and meeting scheduling conflicts, so verify integrations work during migration setup.
Step 4: Import active project data (30 mins)
Upload your CSV to Plutio's import tool. Map exported fields (task name, description, assignee, due date) to Plutio fields appropriately. Start with one test project to verify field mapping before importing all projects. Note that file attachments from old systems typically require manual re-upload, exported CSVs contain task metadata but not attached files or staging URLs, so reference original projects when rebuilding active work in Plutio.
Step 5: Run parallel for new projects
Use Plutio for all new client engagements while keeping the old system active for work already in progress. When a new client signs a development contract, create their project in Plutio, proposal, project board, invoicing schedule all set up in the new system. Existing projects in your old tool continue there until completion. Parallel operation avoids migrating active mid-sprint work which risks losing context or disrupting client communication during critical development phases.
Step 6: Phase out the old tool
Once all active projects on your old system complete (typically 30-60 days for most developers), cancel that subscription. Archive old project data for reference, export final project reports, download all client the work and communication history, save as PDF or local backup. Old system becomes read-only archive while all active work runs in Plutio.
Common migration pitfalls to avoid
- Trying to migrate everything: Focus on active projects and forward-looking workflows. Historical project archives from 2 years ago provide reference value but don't need full migration, export as PDF for archive, don't rebuild every old project in the new system.
- Switching mid-sprint: Finish in-progress development work on the old system. Migrating a sprint halfway through risks losing task context, client communication history, and time tracking continuity. Better to complete current sprint in original tool, then start next sprint in Plutio.
- Not testing integrations: Verify payment processing works before relying on it for client invoices. Test invoice sends test email to confirm client receives payment links correctly. Integration failures discovered when real client invoice goes out create awkward client communication and payment delays.
The investment in migration pays back in time saved on every future project, no more exporting time entries to create invoices, no more emailing staging links because file delivery connects to project tasks, no more answering "What's the status?" emails because clients access project progress through portals.
