How to Build Bookkeeping and CPA Firm Management Software

A bookkeeping firm with 80 clients and 6 staff members has 240 recurring tasks due every month: bank reconciliations, financial statements, payroll reconciliations, sales tax filings. Without a system that assigns these by client and staff member, tracks dependencies, and escalates when clients fail to provide documents, work falls through. Clients discover missed filings themselves. Partners find out when the client calls angry.

Spreadsheets and generic project management tools break at this scale. Tasks don't understand that bank reconciliation for Client A is blocked until Client A uploads their bank statements. No automated reminder goes to Client A on day 5. Staff have no visibility into whether their 12 assigned clients are on track or waiting on documents.

According to CPA.com's 2024 practice management report, accounting firms lose an average of 4-6 billable hours per staff member per week to manual task tracking and client chasing. At 6 staff billing at $100/hour, that's roughly $120K-$180K in recoverable capacity every year. That's what purpose-built accounting firm management software solves.

RaftLabs has built workflow platforms for professional services firms where deadline management is the core product. The pattern below is what we've refined across those builds.

What CPA firm management software does

"The biggest productivity gap in accounting firms isn't technical skill. It's the time spent coordinating: chasing documents, updating status, and manually creating recurring work."

Darren Root, CEO of Rootworks and veteran accounting practice consultant

Client records with engagement scope. Each client record holds entity type (LLC, S-Corp, individual), fiscal year end, assigned staff members, engagement type, and the services in scope (monthly bookkeeping, quarterly reviews, annual tax return, payroll).

Recurring task management. Task templates define what gets created and when. A template for monthly bank reconciliation specifies: frequency (monthly), due day (10 days after month-end), required document checklist (bank statements for all accounts), and assigned staff role (bookkeeper).

Work-in-progress (WIP) tracking. Every task instance for every client is visible on a staff member's queue and on the partner's WIP board. Status moves through a defined state machine. Blocked tasks show why they're blocked.

Document request management with automated reminders. When a task requires client documents, the system sends a request email with an upload link. Automated follow-ups go out on schedule. Escalations notify the partner when clients miss deadlines.

Staff assignment and capacity visibility. Tasks are assigned to specific staff members. The capacity view shows each person's task load by week, flagging anyone overloaded before deadlines arrive.

Client communication portal. Clients access a secure portal to upload documents, view deliverable status, and download completed reports. Messaging stays in the portal, not in staff email inboxes.

Billing by engagement type with time tracking. Fixed-fee engagements bill automatically at the start of each period. Time-and-materials engagements track hours per task and generate invoices from time logs.

Deadline calendar. Tax filing deadlines, sales tax due dates, payroll deposit dates, and extension deadlines populate a firm-wide calendar. Each deadline links to the relevant task instances.

MVP vs. full platform

AICPA's 2023 Private Companies Practice Section benchmarking survey found that firms using dedicated practice management tools average 22% higher realization rates than firms relying on spreadsheets. Realization rate is billable hours collected versus billable hours worked. A 22-point gap at a 6-person firm billing $1M annually is over $200K in recovered revenue.

MVP includes:

• Client records with entity type, fiscal year, assigned staff, and engagement scope

• Recurring task templates with frequency, due day, and document checklist

• Monthly task instance generation via cron

• Task state machine (not_started, waiting_on_client, in_progress, review, complete)

• Document request with client upload link and automated reminder emails

• Staff assignment and WIP queue per staff member

• Basic billing by engagement type

Full platform adds:

• Time tracking per task with invoice generation from time logs

• Capacity planning view by staff member and week

• Client portal for document upload and communication

• QuickBooks and Xero integration for trial balance import

• E-signature for engagement letters (DocuSign or Dropbox Sign)

• Performance analytics: realization rate, utilization rate, on-time delivery rate

Core architecture

Three core records carry the system.

The client record holds: entity type, fiscal year end, assigned staff, engagement scope (list of service types), and billing configuration.

The recurring task template holds: task name, frequency (monthly, quarterly, annual), due_day_offset (days after period end), required document checklist, assigned staff role, and prerequisite template IDs (for dependency ordering within a workflow).

The task instance is created by a cron job at the start of each period. It holds: client ID, template ID, period (e.g., 2026-04), due date (calculated from period end date plus due_day_offset), assigned staff member, current status, and an array of prerequisite_task_instance_ids.

The state machine governs transitions. A task cannot leave not_started until all prerequisite tasks are complete and all required documents are marked received. It moves to waiting_on_client automatically when the period starts if required documents are outstanding. Staff move it to in_progress, then to review. The partner or senior reviewer moves it to complete.

Document requests link directly to task instances. When a bookkeeper marks a document required, the system creates a document_request record and sends the client an email with a signed S3 upload URL. No client login is required. The URL expires in 7 days but the system resends a fresh link with each reminder. When the client uploads, the document_request record updates to received and the linked task instance re-evaluates its prerequisites.

The hardest technical challenge

Most firms underestimate this section. What looks like a simple task-tracking problem is actually a distributed state problem with multiple blocking conditions.

Task dependency chains with client document blocking are the hardest part to model correctly.

A monthly close workflow for one client looks like this: (1) client uploads bank statements, (2) bookkeeper does bank reconciliation, (3) trial balance is generated, (4) financial statements are prepared. Steps 2, 3, and 4 are blocked until the client uploads.

Manage this across 80 clients and you have 80 separate blocking chains running in parallel each month. Most months, 15 to 30 clients are late uploading documents. Tracking which clients are blocking which tasks, and escalating in a structured way, is where firms lose control without software.

Build the dependency model as a directed acyclic graph (DAG) per client per period. Each task instance has an array of prerequisite_task_ids stored in a task_dependencies table (task_id, requires_task_id). The scheduler checks this adjacency list before marking any task available. This makes the dependency logic queryable and auditable.

When a document arrives, the system runs a single query: find all task_instances where this document_request_id appears in the required_documents list and all other prerequisites are also satisfied. Move those instances to available.

The escalation model handles client responsiveness. Document requests trigger three automated emails:

• Day 3: Gentle reminder with the original upload link

• Day 7: Urgency notification noting the deadline impact

• Day 10: Escalation email to both the client and the partner on the account

Store escalation_history as a log on the client record, not just on the document request. This gives partners a running view of how responsive each client is over time. After 12 months of data, patterns emerge: which clients always need three reminders, which consistently upload on day 2. Staff can use this to plan their schedules.

One failure mode to prevent: circular dependencies. If template A requires template B which requires template A, the cron job that generates instances enters an infinite loop. Validate the template dependency graph at creation time using cycle detection (depth-first search). Reject any template configuration that creates a cycle before it can be saved.

Build costs and timeline

This is where most build decisions get made or killed. The numbers below reflect real builds, not estimates from a whitepaper.

MVP (client records, recurring task management, document requests with automated reminders, staff assignment, WIP tracking, basic billing): $100K to $170K over 11 to 15 weeks.

Team: 1 backend engineer, 1 frontend engineer, 1 QA engineer. The DAG dependency engine and cron-based task generation account for roughly 25% of backend development time. The reminder email system, including retry logic and escalation tracking, takes another 15%.

Full platform (adds time tracking, client portal, QuickBooks/Xero integration, e-signature, performance analytics): $200K to $330K over 19 to 26 weeks.

Ongoing infrastructure runs $1K to $3K per month. AWS S3 for document storage is cheap at scale. SendGrid email costs are low. The primary cost driver is third-party integrations: QuickBooks and Xero API usage fees, plus DocuSign or Dropbox Sign per-signature fees if you add e-signature.

Build vs. buy

According to Accounting Today's 2024 technology survey, over 60% of mid-size accounting firms report that their practice management software doesn't fit their workflow without manual workarounds. That gap is where custom builds become defensible.

Karbon is $55 to $75 per user per month. Strong workflow features, good Xero and QuickBooks integrations. Customization is limited. Billing structures must fit their model.

Jetpack Workflow is $36 to $49 per user per month. Simpler than Karbon. Works for firms that primarily need task tracking without complex dependencies or client portals.

Financial Cents is $39 to $59 per user per month. Popular with small firms. Good UI. Client portal is basic.

TaxDome is $25 per user per month. Broad feature set at low cost. Many firms find it rigid when their workflow doesn't match TaxDome's built-in templates.

Build when you have 200 or more clients, need custom workflow automation specific to your service model, require integration with proprietary accounting systems, or have billing structures (retainer plus variable, multi-entity consolidation billing) that standard tools don't support. Also build when you're creating a white-label platform to license to other accounting firms.

Tech stack

Backend: Node.js with PostgreSQL. The DAG for task dependencies is stored as an adjacency list in a task_dependencies table with two columns: task_instance_id and requires_task_instance_id. This is simple to query and index.

Cron jobs: Node.js with node-cron or a managed job scheduler (AWS EventBridge Scheduler). Two critical jobs: monthly task instance generation (runs on the 1st of each month) and daily prerequisite re-evaluation (runs at 8am, picks up any documents received overnight).

Document storage: AWS S3 with folder structure: /{client_id}/{period}/{document_type}/. Signed upload URLs generated with a 7-day expiry. Signed download URLs generated on request for staff and client access.

Client document uploads: Signed S3 PUT URLs sent in reminder emails. No authentication required. The upload URL encodes the document_request_id so the system knows which request to mark received on upload completion (via S3 event notification to a Lambda function).

Email automation: SendGrid with template IDs per email type (initial request, day-3 reminder, day-7 urgency, day-10 escalation). Store send timestamps and open tracking on the document_request record.

Frontend: React. WIP board uses a kanban layout with filters by staff member, client, and period. The deadline calendar uses a standard calendar component with color-coded indicators by urgency.

E-signature (full platform): DocuSign API or Dropbox Sign API. Engagement letters are generated from templates, sent for signature, and stored in S3 with the signed PDF URL on the client record.

QuickBooks/Xero integration (full platform): OAuth 2.0 connection per client. Trial balance import pulls the chart of accounts and period balances into the task instance data, eliminating manual data entry for financial statement preparation.