Implementation Guide: Trigger reminder workflows for upcoming filing deadlines across all clients

Hardware Procurement

No dedicated hardware required

This project is entirely cloud-hosted. All automation, storage, and notification delivery are handled by SaaS platforms (Karbon, Microsoft 365, Twilio). The client's existing business workstations with web browsers and reliable internet (25+ Mbps) are sufficient. Confirm the client has a business-class firewall (e.g., Fortinet FortiGate 40F or SonicWall TZ270) and endpoint detection/response (e.g., SentinelOne or CrowdStrike Falcon Go) already deployed as part of baseline MSP services — these are compliance prerequisites, not project-specific procurements.

Software Procurement

Prerequisites

• Reliable business-class internet connection with minimum 25 Mbps download/upload speed at all office locations
• Microsoft 365 Business Premium (or higher) deployed for all staff with Azure AD/Entra ID configured — this is the identity backbone for SSO and MFA
• Multi-factor authentication (MFA) enforced on ALL user accounts that access client information — mandatory under FTC Safeguards Rule / GLBA. Verify via Azure AD Conditional Access policies
• BitLocker (Windows) or FileVault (macOS) full-disk encryption enabled on all endpoints that access the practice management system — AES-256 encryption at rest required under GLBA
• Business-grade firewall with active threat protection subscriptions (e.g., Fortinet FortiGate with FortiGuard, SonicWall TZ with security services) deployed at the network perimeter
• Endpoint Detection and Response (EDR) solution deployed on all workstations (e.g., SentinelOne Complete, CrowdStrike Falcon Go, or Microsoft Defender for Business via M365 Business Premium)
• Complete client roster with the following data for each client: legal entity name, entity type (individual/S-Corp/C-Corp/partnership/non-profit/trust), EIN or SSN (last 4 only for system reference), fiscal year end date, state(s) of filing obligation, applicable filing types (1040, 1120, 1120-S, 1065, 990, 941, 940, state equivalents)
• Written Information Security Plan (WISP) document — either existing or to be created as part of this engagement. Must be updated to include the new automation platform as a covered system
• Designated Security Coordinator at the firm (required by FTC Safeguards Rule) — typically a partner or office manager
• Firm's current IRS e-file PTIN and EFIN numbers documented (for reference in workflow configuration, not for system access)
• DNS access for email authentication: ability to add SPF, DKIM, and DMARC records to the firm's domain (required for SendGrid email deliverability and anti-spoofing)
• Client consent documentation: template consent form compliant with IRS Section 7216 for any automated communications that reference specific tax return types or filing statuses

Installation Steps

Step 1: Discovery & Client Data Audit

Conduct a thorough discovery session with the accounting firm to inventory their current technology stack, client base, and filing obligations. This is the foundation for the entire project — incomplete data here means missed deadlines later.

• Meet with the managing partner and office manager for 2–3 hours.
• Document every software tool currently in use (accounting, tax prep, email, calendar, document management).
• Export or compile the complete client roster with entity types and filing obligations.
• Identify all federal, state, and local filing deadlines applicable to their client base.
• Determine the firm's preferred reminder schedule (e.g., 30/14/7/3/1 days before each deadline).
• Identify who receives reminders: staff only, clients only, or both.

Step 2: Build Master Deadline Calendar

Create a comprehensive master deadline calendar that maps every applicable filing deadline for the current and next tax year. This calendar is the data backbone of the entire automation system. Start with the IRS annual tax calendar (Publication 509) for federal deadlines. Add state-specific deadlines for every state where the firm's clients have filing obligations. Include quarterly deadlines (941 payroll tax, estimated payments), annual deadlines (1040, 1120, 1065, etc.), and informational return deadlines (1099, W-2). Note extension deadlines separately. Account for weekends and holidays (when a deadline falls on a weekend/holiday, the due date shifts to the next business day).

deadline_name,entity_types,due_date,extended_due_date,frequency,federal_or_state,notes
"Form 1040 - Individual Income Tax Return","Individual","2025-04-15","2025-10-15","Annual","Federal",""
"Form 1120 - Corporate Income Tax Return","C-Corp","2025-04-15","2025-10-15","Annual","Federal","Calendar year filers"
"Form 1120-S - S Corp Income Tax Return","S-Corp","2025-03-15","2025-09-15","Annual","Federal","Calendar year filers"
"Form 1065 - Partnership Return","Partnership","2025-03-15","2025-09-15","Annual","Federal","Calendar year filers"
"Form 990 - Exempt Organization Return","Non-Profit","2025-05-15","2025-11-15","Annual","Federal","Calendar year filers"
"Form 941 - Quarterly Payroll Tax","All with employees","2025-04-30","","Quarterly","Federal","Q1 due date"
"Form 940 - Annual FUTA Tax","All with employees","2025-01-31","","Annual","Federal",""

Step 3: Provision Karbon Business Plan Licenses

Set up the Karbon account with Business plan licenses for all staff members. The Business plan (not Team) is required because it includes automatic client reminders and task automation features that are essential for this project.

Step 4: Configure Identity, SSO, and MFA in Karbon

Set up secure authentication for all Karbon users using Azure AD/Entra ID SSO and enforce multi-factor authentication. This is a compliance requirement under the FTC Safeguards Rule.

# Create Conditional Access Policy requiring MFA for Karbon

Install-Module -Name Microsoft.Graph -Force -Scope CurrentUser
Connect-MgGraph -Scopes 'Policy.ReadWrite.ConditionalAccess,Application.Read.All'

# Get the Karbon Enterprise Application Object ID after registering it:
$karbonApp = Get-MgServicePrincipal -Filter "displayName eq 'Karbon'"

# Create Conditional Access Policy requiring MFA for Karbon:
$params = @{
    displayName = 'Require MFA for Karbon Access'
    state = 'enabled'
    conditions = @{
        applications = @{
            includeApplications = @($karbonApp.AppId)
        }
        users = @{
            includeUsers = @('All')
        }
    }
    grantControls = @{
        operator = 'OR'
        builtInControls = @('mfa')
    }
}
New-MgIdentityConditionalAccessPolicy -BodyParameter $params

Step 5: Import Client Roster into Karbon

Import the complete client roster into Karbon as Contacts and Organizations. Each client record must include entity type, filing obligations, fiscal year end, and state(s) of filing — this data drives the automation rules. Prepare a CSV file matching Karbon's import template. Map columns: Organization Name, Primary Contact Name, Email, Phone, Entity Type (use a custom field), Fiscal Year End (custom field), Filing Types (custom field, comma-separated), States (custom field).

org_name,contact_first,contact_last,email,phone,entity_type,fiscal_year_end,filing_types,states
"Acme Corp","John","Smith","john@acmecorp.com","555-0100","S-Corp","12/31","1120-S,941,940,CA-100S","CA,NV"
"Jane Doe","Jane","Doe","jane.doe@email.com","555-0200","Individual","12/31","1040,CA-540","CA"
"Smith Family Trust","Bob","Smith","bob@smith.com","555-0300","Trust","12/31","1041,CA-541","CA"

Step 6: Create Work Templates for Each Filing Type

In Karbon, create reusable Work (project) templates for each type of filing the firm handles. Each template defines the workflow stages, task checklists, assigned roles, and — critically — the reminder schedule. For example, create a '1040 Individual Tax Return' template with stages: Collect Documents > Prepare Return > Review > Client Approval > E-File > Confirmation. Each stage has tasks with relative due dates (e.g., 'Send document request list' = deadline minus 60 days).

Step 7: Configure Automated Client Reminders in Karbon

Set up Karbon's built-in automated client reminder system. This is the core of the deadline reminder workflow. Karbon Business plan allows you to configure automatic email reminders that are sent to clients when they have outstanding client tasks (e.g., 'Please upload your W-2s').

Step 8: Set Up Twilio Account for SMS Reminders

Create and configure a Twilio account for sending SMS deadline reminders to clients. SMS has significantly higher open rates than email (98% vs 20%), making it ideal for critical deadline reminders at the 7-day and 3-day marks.

After account creation, note these values from the Twilio Console: Account SID, Auth Token, and Phone Number.

# Test SMS delivery using Twilio CLI:
npm install -g twilio-cli
twilio login
twilio api:core:messages:create \
  --from '+1XXXXXXXXXX' \
  --to '+1YYYYYYYYYY' \
  --body 'Test reminder: This is a filing deadline test message from [Firm Name].'

curl -X POST https://api.twilio.com/2010-04-01/Accounts/ACxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx/Messages.json \
  --data-urlencode 'From=+1XXXXXXXXXX' \
  --data-urlencode 'To=+1YYYYYYYYYY' \
  --data-urlencode 'Body=Test: Your upcoming filing deadline is approaching. Please contact [Firm Name] at (555) 555-0100.' \
  -u ACxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:your_auth_token

Step 9: Build Twilio SMS Integration with Karbon via Zapier or Make.com

Connect Karbon's workflow events to Twilio SMS delivery. When a client task reaches specific reminder thresholds (7 days, 3 days, 1 day before deadline), trigger an SMS to the client's mobile number. Since Karbon does not have a native Twilio integration, use Zapier or Make.com as the middleware. In Zapier: Create a new Zap with trigger 'Karbon — Work Status Changed' or use Karbon's webhook/API to detect upcoming deadlines. Set the action to 'Twilio — Send SMS'. Map the client's phone number and a templated reminder message. Alternatively, use Make.com for higher volume at lower cost.

Zapier Configuration

To: {{client_phone_number}}
From: +1XXXXXXXXXX
Body: 'Reminder from [Firm Name]: Your {{filing_type}} filing deadline is {{due_date}}. Please ensure all documents are submitted. Questions? Call us at (555) 555-0100.'

Make.com Configuration

Power Automate Configuration

Step 10: Configure Microsoft Teams Notifications for Internal Staff

Set up automated Microsoft Teams notifications to alert firm staff about upcoming deadlines and overdue tasks. This provides an internal awareness layer separate from client-facing reminders. In Karbon, enable the Microsoft Teams integration (Settings > Integrations > Microsoft Teams). Configure channel notifications: create a dedicated Teams channel called '#deadline-alerts' in the firm's primary Team. Map Karbon work status changes and upcoming deadlines to post notifications in this channel. Configure @mentions for the assigned staff member on each work item.

Install-Module -Name MicrosoftTeams -Force -Scope CurrentUser
Connect-MicrosoftTeams

$team = Get-Team -DisplayName 'Firm Operations'

New-TeamChannel -GroupId $team.GroupId -DisplayName 'Deadline Alerts' -Description 'Automated filing deadline reminders and alerts' -MembershipType Standard

Step 11: Configure Email Authentication (SPF, DKIM, DMARC)

Ensure all automated reminder emails pass email authentication checks and are not flagged as spam. This is critical for client-facing reminder deliverability. Add SPF, DKIM, and DMARC DNS records for the firm's domain to authorize both Microsoft 365 and SendGrid (if used) as legitimate senders.

# SPF Record (TXT record on firmname.com):
# If using M365 only:
v=spf1 include:spf.protection.outlook.com -all

# If using M365 + SendGrid:
v=spf1 include:spf.protection.outlook.com include:sendgrid.net -all

# DMARC Record (TXT record on _dmarc.firmname.com):
v=DMARC1; p=quarantine; rua=mailto:dmarc-reports@firmname.com; pct=100

Step 12: Build and Import the Annual Work Schedule

Using the master deadline calendar (Step 2) and client roster (Step 5), create the actual work items in Karbon for the current tax year. This is where deadline dates are assigned to specific clients using the work templates created in Step 6. For each client, create recurring Work items based on their entity type and filing obligations. Apply the appropriate work template (e.g., '1040 Individual Tax Return' template for individual clients). Set the work due date to the actual filing deadline. Assign the responsible staff member (preparer and reviewer). This can be done via Karbon's bulk work creation feature or via API for large client bases.

curl -X POST https://api.karbonhq.com/v3/Works \
  -H 'Authorization: Bearer YOUR_KARBON_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{
    "Title": "2024 Form 1040 - John Smith",
    "WorkTemplateKey": "TEMPLATE_KEY_HERE",
    "ClientKey": "CLIENT_KEY_HERE",
    "DueDate": "2025-04-15",
    "AssigneeKey": "STAFF_KEY_HERE",
    "Description": "Individual income tax return for John Smith, filing year 2024"
  }'

Step 13: Create Escalation Workflow for Overdue Items

Configure an escalation path for deadlines that are approaching without completion. If a client has not responded to reminders and the deadline is imminent, the system should escalate to a partner or manager for personal outreach. In Karbon, create an automation rule: if a work item is within 3 days of its due date and client tasks are still outstanding, automatically reassign or add a partner as a collaborator and send an internal notification. Configure a separate urgent SMS via Twilio for the partner's mobile. Create a final escalation at 1 day before deadline that triggers a phone call task for the assigned staff member.

Step 14: Update the Firm's WISP (Written Information Security Plan)

Update the accounting firm's Written Information Security Plan to document the new automation system, its data flows, vendor relationships, and security controls. This is a legal requirement under both the FTC Safeguards Rule and IRS guidelines.

Step 15: Pilot Testing with Subset of Clients

Before full rollout, run a 1–2 week pilot with a small subset of clients (10–20) to validate that reminders are firing correctly, emails are being delivered, SMS messages are arriving, and the timing logic is accurate.

• Select a diverse test group: include at least one of each entity type (individual, S-Corp, C-Corp, partnership, non-profit).
• Include clients in different states to test state-specific deadlines.
• Monitor the automation engine daily during the pilot.
• Check email delivery logs in Karbon and SendGrid.
• Check SMS delivery receipts in Twilio.
• Verify Teams notifications are posting to the correct channel.
• Collect feedback from firm staff on workflow usability.

curl -X GET 'https://api.twilio.com/2010-04-01/Accounts/ACxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx/Messages.json?DateSent>=2025-01-01&To=+1YYYYYYYYYY' \
  -u ACxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx:your_auth_token

curl -X GET 'https://api.sendgrid.com/v3/stats?start_date=2025-01-01' \
  -H 'Authorization: Bearer YOUR_SENDGRID_API_KEY'

Step 16: Full Rollout and Staff Training

After successful pilot, roll out the system to all clients and conduct formal training for all firm staff. Create all remaining work items for the full client roster. Conduct a 90-minute training session covering: how to view and manage the deadline dashboard in Karbon, how to handle client responses to reminders, how to manually send additional reminders, how to mark tasks as complete, how to use the escalation workflow, how to add new clients and their deadlines, and how to handle mid-year changes (new client onboarding, entity type changes, fiscal year changes).

Custom AI Components

Master Deadline Calendar Engine

Type: workflow A structured data model and annual refresh process for maintaining the comprehensive filing deadline calendar across all federal and state jurisdictions. This is the core data source that drives all reminder triggers. It maps entity types to filing obligations and calculates actual due dates accounting for weekends, holidays, and fiscal year variations.

Data Structure (SharePoint List or Karbon Custom Fields)

Core Federal Deadlines (Partial — Top 15)

Annual Refresh Process

Weekend/Holiday Adjustment Logic

import datetime
from pandas.tseries.holiday import USFederalHolidayCalendar

def adjust_deadline(base_date: datetime.date) -> datetime.date:
    cal = USFederalHolidayCalendar()
    holidays = cal.holidays(start=base_date - datetime.timedelta(days=7), 
                            end=base_date + datetime.timedelta(days=7)).to_pydatetime()
    holiday_dates = [h.date() for h in holidays]
    
    adjusted = base_date
    while adjusted.weekday() >= 5 or adjusted in holiday_dates:  # 5=Sat, 6=Sun
        adjusted += datetime.timedelta(days=1)
    return adjusted

# Example:
# If April 15, 2028 falls on a Saturday:
# adjust_deadline(datetime.date(2028, 4, 15)) returns April 17, 2028 (Monday)

Fiscal Year Client Handling

For clients with non-calendar fiscal year ends, calculate deadlines as:

• S-Corp/Partnership: 15th day of 3rd month after fiscal year end
• C-Corp: 15th day of 4th month after fiscal year end
• Non-Profit: 15th day of 5th month after fiscal year end

from dateutil.relativedelta import relativedelta

def calculate_filing_deadline(fiscal_year_end: datetime.date, entity_type: str) -> datetime.date:
    offsets = {
        'S-Corp': 3,
        'Partnership': 3,
        'C-Corp': 4,
        'Individual': 4,  # Always calendar year (12/31)
        'Non-Profit': 5,
        'Trust': 4,
    }
    months = offsets.get(entity_type, 4)
    deadline = fiscal_year_end + relativedelta(months=months)
    deadline = deadline.replace(day=15)
    return adjust_deadline(deadline)

Multi-Stage Reminder Workflow Template

Type: workflow Defines the complete multi-stage, multi-channel reminder workflow that triggers at 30, 14, 7, 3, and 1 days before each filing deadline. Each stage has different messaging tone, delivery channels, and escalation behavior. This is implemented as Karbon work templates with automated client tasks, supplemented by Zapier/Make.com triggers for SMS delivery.

Multi-Stage Reminder Workflow — Complete Specification

Stage 1: 30 Days Before Deadline (Informational)

• Channel: Email only
• Recipient: Client primary contact
• Tone: Friendly, informational
• Internal Action: Create Karbon work item from template; assign to preparer
• Escalation: None

Upcoming Filing Deadline — {{filing_type}} due {{due_date}}

Dear {{client_first_name}},

This is a friendly reminder that your {{filing_type}} filing deadline is {{due_date}}, which is approximately 30 days away.

To ensure timely filing, please begin gathering the following documents:
{{document_checklist}}

You can upload documents securely through your client portal or email them directly to {{staff_email}}.

If you have any questions, please don't hesitate to reach out.

Best regards,
{{staff_name}}
{{firm_name}}
{{firm_phone}}

Stage 2: 14 Days Before Deadline (Action Required)

• Channel: Email
• Recipient: Client primary contact
• Tone: Professional, action-oriented
• Internal Action: Karbon automated reminder fires; Teams notification to preparer
• Escalation: None

Action Required — {{filing_type}} due in 14 days ({{due_date}})

Dear {{client_first_name}},

Your {{filing_type}} filing deadline is {{due_date}} — just two weeks away.

{{#if outstanding_documents}}
We are still waiting for the following items:
{{outstanding_documents_list}}

Please submit these at your earliest convenience so we can complete your filing on time.
{{else}}
Thank you for submitting your documents. We are actively working on your filing and will be in touch if we need anything additional.
{{/if}}

Best regards,
{{staff_name}}
{{firm_name}}
{{firm_phone}}

Stage 3: 7 Days Before Deadline (Urgent)

• Channel: Email + SMS
• Recipient: Client primary contact + client secondary contact (if on file)
• Tone: Urgent
• Internal Action: Teams notification to preparer AND reviewer; work item flagged as "At Risk"
• Escalation: Add manager/partner as collaborator on Karbon work item

URGENT — {{filing_type}} due in 7 days ({{due_date}})

[Firm Name] REMINDER: Your {{filing_type}} is due {{due_date}}. Outstanding items needed. Please call us at {{firm_phone}} or upload docs to your portal.

Stage 4: 3 Days Before Deadline (Critical)

• Channel: Email + SMS + Teams (internal)
• Recipient: Client primary contact + all client contacts on file
• Tone: Critical/Formal
• Internal Action: Partner notified via Teams @mention; phone call task created for assigned staff
• Escalation: Partner review required; decision to file extension if needed

CRITICAL — {{filing_type}} filing deadline in 3 days ({{due_date}})

CRITICAL from [Firm Name]: Your {{filing_type}} is due {{due_date}}. Immediate action required. Call {{firm_phone}} today.

Stage 5: 1 Day Before Deadline (Final Warning)

• Channel: Email + SMS + Phone call (manual)
• Recipient: Client primary contact
• Tone: Final notice
• Internal Action: Mandatory partner sign-off; decision: file return, file extension, or document non-response in client file
• Escalation: Full escalation — partner takes over client communication

FINAL NOTICE — {{filing_type}} due TOMORROW ({{due_date}})

FINAL NOTICE [Firm Name]: {{filing_type}} due TOMORROW {{due_date}}. Call {{firm_phone}} IMMEDIATELY to avoid penalties.

Post-Deadline (if unfiled)

Karbon Implementation

Zapier Zap Configuration for SMS (Stage 3, 4, 5)

• Trigger: Schedule by Zapier (Every Day at 8:00 AM firm local time)
• Action 1: Karbon — Find Work Items (filter: due date within 7 days AND status != Complete)
• Action 2: Filter — only proceed if days until due = 7 OR 3 OR 1
• Action 3: Twilio — Send SMS (map client phone, compose message per stage template)
• Action 4: Karbon — Add Note to Work (log that SMS was sent)

Bulk Work Item Creator Script

Type: integration

A Python script that reads the client roster CSV and master deadline calendar, then bulk-creates work items in Karbon via API. This eliminates hours of manual data entry for firms with 100+ clients and ensures consistent, error-free work item creation.

Implementation:

#!/usr/bin/env python3
"""
Bulk Work Item Creator for Karbon
Reads client roster CSV and creates work items for each client's filing obligations.
Designed for MSP technicians deploying deadline reminder systems.

Prerequisites:
  pip install requests python-dateutil pandas

Usage:
  python bulk_create_works.py --clients clients.csv --api-key YOUR_API_KEY
"""

import argparse
import csv
import datetime
import json
import sys
import time
from dateutil.relativedelta import relativedelta
import requests

# Karbon API base URL
KARBON_API_BASE = "https://api.karbonhq.com/v3"

# Mapping of filing types to Karbon Work Template Keys
# UPDATE THESE with actual template keys from the client's Karbon instance
TEMPLATE_KEYS = {
    "1040": "TEMPLATE_KEY_1040",
    "1120": "TEMPLATE_KEY_1120",
    "1120-S": "TEMPLATE_KEY_1120S",
    "1065": "TEMPLATE_KEY_1065",
    "990": "TEMPLATE_KEY_990",
    "1041": "TEMPLATE_KEY_1041",
    "941": "TEMPLATE_KEY_941",
    "940": "TEMPLATE_KEY_940",
}

# Federal deadline rules: entity_type -> (months_after_fye, day_of_month)
DEADLINE_RULES = {
    "1040": {"months_offset": 4, "day": 15},       # April 15 for calendar year
    "1120": {"months_offset": 4, "day": 15},       # April 15 for calendar year
    "1120-S": {"months_offset": 3, "day": 15},     # March 15 for calendar year
    "1065": {"months_offset": 3, "day": 15},       # March 15 for calendar year
    "990": {"months_offset": 5, "day": 15},        # May 15 for calendar year
    "1041": {"months_offset": 4, "day": 15},       # April 15 for calendar year
    "941": {"quarterly_dates": ["04-30", "07-31", "10-31", "01-31"]},
    "940": {"months_offset": 1, "day": 31},        # January 31
}


def adjust_for_weekends_holidays(date_obj):
    """Adjust deadline to next business day if it falls on weekend.
    Note: For production, add federal holiday checking."""
    while date_obj.weekday() >= 5:  # Saturday = 5, Sunday = 6
        date_obj += datetime.timedelta(days=1)
    return date_obj


def calculate_due_date(filing_type, fiscal_year_end_str, tax_year):
    """Calculate the filing due date based on entity type and fiscal year end."""
    fye_month, fye_day = map(int, fiscal_year_end_str.split('/'))
    fiscal_year_end = datetime.date(tax_year, fye_month, fye_day)
    
    rule = DEADLINE_RULES.get(filing_type)
    if not rule:
        return None
    
    if "quarterly_dates" in rule:
        # Return list of quarterly dates for the tax year
        dates = []
        for qd in rule["quarterly_dates"]:
            month, day = map(int, qd.split('-'))
            year = tax_year if month > 1 else tax_year + 1
            dates.append(adjust_for_weekends_holidays(datetime.date(year, month, day)))
        return dates
    
    due_date = fiscal_year_end + relativedelta(months=rule["months_offset"])
    due_date = due_date.replace(day=rule["day"])
    return [adjust_for_weekends_holidays(due_date)]


def create_work_item(api_key, title, template_key, client_key, due_date, assignee_key, description):
    """Create a single work item in Karbon via API."""
    headers = {
        "Authorization": f"Bearer {api_key}",
        "Content-Type": "application/json",
    }
    payload = {
        "Title": title,
        "WorkTemplateKey": template_key,
        "ClientKey": client_key,
        "DueDate": due_date.isoformat(),
        "AssigneeKey": assignee_key,
        "Description": description,
    }
    
    response = requests.post(f"{KARBON_API_BASE}/Works", headers=headers, json=payload)
    
    if response.status_code in (200, 201):
        work = response.json()
        print(f"  ✓ Created: {title} (Due: {due_date}) [ID: {work.get('Key', 'N/A')}]")
        return True
    else:
        print(f"  ✗ FAILED: {title} — {response.status_code}: {response.text}")
        return False


def main():
    parser = argparse.ArgumentParser(description='Bulk create Karbon work items for filing deadlines')
    parser.add_argument('--clients', required=True, help='Path to clients CSV file')
    parser.add_argument('--api-key', required=True, help='Karbon API key')
    parser.add_argument('--tax-year', type=int, default=datetime.date.today().year - 1,
                        help='Tax year (default: previous calendar year)')
    parser.add_argument('--dry-run', action='store_true', help='Print what would be created without calling API')
    args = parser.parse_args()

    print(f"\n{'='*60}")
    print(f"Karbon Bulk Work Creator — Tax Year {args.tax_year}")
    print(f"{'='*60}\n")

    created = 0
    failed = 0
    skipped = 0

    with open(args.clients, 'r', encoding='utf-8-sig') as f:
        reader = csv.DictReader(f)
        for row in reader:
            org_name = row['org_name'].strip()
            client_key = row.get('karbon_client_key', '').strip()
            assignee_key = row.get('karbon_assignee_key', '').strip()
            fiscal_year_end = row.get('fiscal_year_end', '12/31').strip()
            filing_types = [ft.strip() for ft in row.get('filing_types', '').split(',')]

            print(f"\nProcessing: {org_name}")
            
            if not client_key:
                print(f"  ⚠ Skipping — no Karbon client key")
                skipped += 1
                continue

            for filing_type in filing_types:
                template_key = TEMPLATE_KEYS.get(filing_type)
                if not template_key:
                    print(f"  ⚠ No template for filing type: {filing_type}")
                    skipped += 1
                    continue

                due_dates = calculate_due_date(filing_type, fiscal_year_end, args.tax_year)
                if not due_dates:
                    print(f"  ⚠ Could not calculate due date for {filing_type}")
                    skipped += 1
                    continue

                for i, due_date in enumerate(due_dates):
                    quarter_label = f" Q{i+1}" if len(due_dates) > 1 else ""
                    title = f"{args.tax_year} {filing_type}{quarter_label} — {org_name}"
                    description = f"{filing_type} filing for {org_name}, tax year {args.tax_year}"

                    if args.dry_run:
                        print(f"  [DRY RUN] Would create: {title} (Due: {due_date})")
                        created += 1
                    else:
                        if create_work_item(args.api_key, title, template_key,
                                           client_key, due_date, assignee_key, description):
                            created += 1
                        else:
                            failed += 1
                        time.sleep(0.5)  # Rate limiting: 2 requests/second

    print(f"\n{'='*60}")
    print(f"Summary: {created} created, {failed} failed, {skipped} skipped")
    print(f"{'='*60}\n")


if __name__ == '__main__':
    main()

Daily Deadline Monitor & SMS Dispatcher

Type: integration A Make.com (or Zapier) scenario that runs daily at 8:00 AM, queries Karbon for work items approaching their deadlines, and dispatches SMS reminders via Twilio for items at the 7-day, 3-day, and 1-day thresholds. This bridges the gap between Karbon's email-based reminders and SMS delivery.

Make.com Scenario: Daily Deadline SMS Dispatcher

Scenario Overview

• Trigger: Schedule (Every day at 8:00 AM Eastern)
• Module 1: HTTP — GET Karbon API for active work items
• Module 2: Iterator — Loop through work items
• Module 3: Router — Branch based on days until deadline - Route A: 7 days → Send informational SMS - Route B: 3 days → Send urgent SMS - Route C: 1 day → Send critical SMS
• Module 4: Twilio — Send SMS
• Module 5: HTTP — POST note to Karbon work item (log SMS sent)

Module 1: HTTP Request (GET active works from Karbon)

• URL: https://api.karbonhq.com/v3/Works
• Method: GET
• Headers: - Authorization: Bearer {{KARBON_API_KEY}} - Content-Type: application/json

$filter: Status ne 'Completed' and DueDate ge '{{formatDate(now; "YYYY-MM-DD")}}' and DueDate le '{{formatDate(addDays(now; 30); "YYYY-MM-DD")}}'

Module 2: Iterator

• Array: {{Module1.body.value}}

Module 3: Router with 3 Routes

• Route A Filter (7 days): Condition: {{formatDate(parseDate(iterator.DueDate); "YYYY-MM-DD")}} equals {{formatDate(addDays(now; 7); "YYYY-MM-DD")}}
• Route B Filter (3 days): Condition: {{formatDate(parseDate(iterator.DueDate); "YYYY-MM-DD")}} equals {{formatDate(addDays(now; 3); "YYYY-MM-DD")}}
• Route C Filter (1 day): Condition: {{formatDate(parseDate(iterator.DueDate); "YYYY-MM-DD")}} equals {{formatDate(addDays(now; 1); "YYYY-MM-DD")}}

Module 4: Twilio Send SMS (per route)

Route A (7-day): Reminder from [FIRM NAME]: Your {{iterator.Title}} filing is due {{formatDate(parseDate(iterator.DueDate); "MMM D, YYYY")}}. Please submit outstanding documents. Call (555) 555-0100 with questions.

Route B (3-day): URGENT [FIRM NAME]: Your {{iterator.Title}} is due in 3 DAYS on {{formatDate(parseDate(iterator.DueDate); "MMM D, YYYY")}}. Immediate action needed. Call (555) 555-0100 TODAY.

Route C (1-day): FINAL NOTICE [FIRM NAME]: {{iterator.Title}} due TOMORROW. Call (555) 555-0100 IMMEDIATELY to avoid penalties.

• Account SID: {{TWILIO_ACCOUNT_SID}}
• Auth Token: {{TWILIO_AUTH_TOKEN}}
• From: {{TWILIO_PHONE_NUMBER}}
• To: {{iterator.ClientPhoneNumber}} (mapped from Karbon client contact)

Module 5: HTTP Request (Log SMS in Karbon)

• URL: https://api.karbonhq.com/v3/Works/{{iterator.Key}}/Notes
• Method: POST
• Headers: Authorization: Bearer {{KARBON_API_KEY}}

# log SMS sent as a note on the Karbon work item

{
  "Body": "SMS reminder sent to client ({{iterator.ClientPhoneNumber}}) - {{now}} - Stage: {{route_label}}",
  "NoteType": "Comment"
}

Zapier Implementation Steps

Power Automate Implementation Steps

Deadline Compliance Dashboard

Type: workflow A weekly summary report delivered to firm partners showing deadline compliance metrics: how many deadlines are upcoming, how many are at risk, how many reminders have been sent, and client response rates. Implemented as a Power Automate flow that queries Karbon and generates an email digest.

Weekly Deadline Compliance Dashboard — Power Automate Flow

Flow Overview

• Trigger: Recurrence — Every Monday at 7:00 AM
• Purpose: Generate and email a weekly summary of filing deadline status to firm partners

Power Automate Flow Steps

Step 2: HTTP — Get Active Work Items

GET https://api.karbonhq.com/v3/Works?$filter=Status ne 'Completed'&$orderby=DueDate asc
Authorization: Bearer (Karbon API key)

Step 4: Initialize Variables

var_total_active = 0
var_due_this_week = 0
var_due_next_week = 0
var_overdue = 0
var_at_risk = 0
var_report_html = ""

Step 5: Apply to Each — Loop Logic

days_until_due = dateDifference(utcNow(), item.DueDate)

If days_until_due < 0:                          → increment var_overdue
If days_until_due >= 0 AND <= 7:               → increment var_due_this_week
If days_until_due > 7 AND <= 14:              → increment var_due_next_week
If days_until_due <= 7 AND status != 'In Progress': → increment var_at_risk
Increment var_total_active

Step 6: Compose HTML Report

<html>
<body style="font-family: Arial, sans-serif; max-width: 600px;">
  <h2 style="color: #2c3e50;">📊 Weekly Filing Deadline Report</h2>
  <p>Generated: @{formatDateTime(utcNow(), 'MMMM d, yyyy')}</p>
  
  <table style="border-collapse: collapse; width: 100%;">
    <tr style="background-color: #e74c3c; color: white;">
      <td style="padding: 10px;">⚠️ OVERDUE</td>
      <td style="padding: 10px; text-align: right; font-size: 24px;">@{variables('var_overdue')}</td>
    </tr>
    <tr style="background-color: #f39c12; color: white;">
      <td style="padding: 10px;">🔥 Due This Week</td>
      <td style="padding: 10px; text-align: right; font-size: 24px;">@{variables('var_due_this_week')}</td>
    </tr>
    <tr style="background-color: #3498db; color: white;">
      <td style="padding: 10px;">📅 Due Next Week</td>
      <td style="padding: 10px; text-align: right; font-size: 24px;">@{variables('var_due_next_week')}</td>
    </tr>
    <tr style="background-color: #e67e22; color: white;">
      <td style="padding: 10px;">🚨 At Risk (not started)</td>
      <td style="padding: 10px; text-align: right; font-size: 24px;">@{variables('var_at_risk')}</td>
    </tr>
    <tr style="background-color: #2ecc71; color: white;">
      <td style="padding: 10px;">📋 Total Active</td>
      <td style="padding: 10px; text-align: right; font-size: 24px;">@{variables('var_total_active')}</td>
    </tr>
  </table>
  
  <h3>Items Due This Week:</h3>
  <ul>
    @{variables('var_report_html')}
  </ul>
  
  <p style="color: #7f8c8d; font-size: 12px;">This report is automatically generated by your managed deadline reminder system. Contact [MSP Name] at [MSP Phone] for support.</p>
</body>
</html>

Step 7: Send Email (Office 365 Outlook)

• To: partner1@firmname.com; partner2@firmname.com
• Subject: "📊 Weekly Filing Deadline Report — @{formatDateTime(utcNow(), 'MMM d, yyyy')}"
• Body: HTML composed in Step 6
• Importance: High (if var_overdue > 0 or var_at_risk > 3)

Metrics to Track Over Time

Testing & Validation

Client Handoff

Client Handoff Checklist

Training Session (90 minutes, in-person or video call with recording)

Attendees: All firm staff who will interact with the system (preparers, reviewers, admin, partners)

Topics to Cover:

Documentation to Deliver

Success Criteria to Review Together:

Post-Handoff Support Period:

• Weeks 1–4: MSP available for daily check-ins (15 minutes) via Teams or phone
• Weeks 5–8: MSP available for twice-weekly check-ins
• Week 9+: Transition to standard monthly management retainer

Maintenance

Ongoing Maintenance Responsibilities

...

Daily (Automated — MSP monitors alerts)

• Monitor Make.com/Zapier scenario execution logs for failures. Set up error notifications to MSP ticketing system (e.g., ConnectWise, Autotask). If SMS delivery fails, investigate Twilio delivery status and carrier filtering.
• Monitor Karbon system health via status page (https://status.karbonhq.com/). Subscribe to incident notifications.
• Monitor Twilio account balance. Set up auto-recharge at $20 minimum balance with $50 recharge amount to prevent SMS delivery interruption.

Weekly

• Review the automated compliance dashboard report (sent to firm partners). Flag any anomalies (e.g., sudden spike in at-risk items, delivery failures).
• Check Zapier/Make.com task/operation usage against plan limits. If approaching 80% of monthly quota, alert MSP account manager to discuss plan upgrade.
• Spot-check 2–3 recent reminder emails for deliverability (review SendGrid bounce/complaint reports if using SendGrid).

Monthly

• Review and reconcile Twilio SMS costs against budget. Report to client on message volume and costs.
• Review Karbon license utilization — are all licensed users active? Are additional licenses needed?
• Check for Karbon platform updates and new features that could enhance the workflow.
• Review Azure AD sign-in logs for the Karbon enterprise application — look for failed sign-ins, unusual access patterns, or MFA bypass attempts.
• Backup the master deadline calendar data (export from Karbon or SharePoint to secure MSP-managed storage).

Quarterly

• Review and update quarterly filing deadlines (941, estimated payments). Confirm dates for the upcoming quarter accounting for holidays.
• Conduct a brief (30-minute) review meeting with the firm's office manager to gather feedback on reminder effectiveness, client complaints, and suggested improvements.
• Review and rotate Karbon API keys and Twilio auth tokens. Update stored credentials in Zapier/Make.com/Power Automate.
• Test the full reminder pipeline end-to-end by creating a test work item and verifying all channels deliver correctly.

Annually (November–December)

• Critical: Annual Deadline Calendar Refresh. Download IRS Publication 509 for the new year. Update all federal deadlines. Check each applicable state's revenue department for updated state deadlines. This is a billable service item ($500–$1,000).
• Bulk-create work items for the new tax year using the Python script or Karbon's recurring work feature.
• Review and renew Karbon annual licenses (coordinate with client for budget approval).
• Update the WISP with any changes to systems, vendors, or security controls made during the year. Conduct annual security risk assessment as required by FTC Safeguards Rule.
• Review IRS and state announcements for any regulatory changes affecting filing requirements (new forms, changed deadlines, new states of obligation for growing clients).
• Archive completed work items from the prior year per the firm's document retention policy.

Ad-Hoc / Event-Driven

• Disaster deadline extensions: Monitor IRS disaster relief announcements (https://www.irs.gov/newsroom/tax-relief-in-disaster-situations). When extensions are declared, immediately update affected deadlines in Karbon and notify firm staff.
• New client onboarding: When the firm adds a new client, create their filing work items within 48 hours of receiving entity information from the firm.
• Client departure: When a client leaves the firm, archive their work items and remove them from active reminder workflows.
• Platform incidents: If Karbon, Twilio, or the automation platform experiences an outage, notify the firm immediately and activate the manual reminder backup process (documented in the Emergency Procedures handoff document).

SLA Considerations

• Response time for system issues: 4-hour response during business hours (M-F 8AM–6PM firm local time)
• Critical deadline period support (Jan 15 – Apr 15, Sep 15 – Oct 15): Enhanced response — 2-hour response, weekend availability
• Annual calendar refresh: Completed by December 15 each year
• New client work item creation: Within 2 business days of receiving client information

Escalation Path

Alternatives

Replace Karbon with TaxDome Pro as the primary platform. TaxDome is an all-in-one practice management solution that includes CRM, workflow automation, client portal, e-signatures, invoicing, and automated reminders (email, SMS, and portal notifications) built into a single platform. TaxDome's automated messaging system can send emails, texts, and portal notifications when documents are due, deadlines approach, payments are late, or approvals are needed — eliminating the need for separate Twilio and Zapier/Make.com integrations for basic SMS.

Microsoft Power Automate + SharePoint — No Practice Management Platform

For firms that refuse to adopt a new practice management platform, build the entire deadline reminder system using Microsoft Power Automate with SharePoint as the deadline database and Outlook/Teams as the notification channels. Create a SharePoint list containing all clients, their filing types, and deadline dates. Build Power Automate flows that run daily, compare dates, and send Outlook emails and Teams messages at each reminder threshold. Add Twilio connector for SMS.

Canopy with Workflow Module — Modular Approach

Use Canopy's modular platform, purchasing only the Workflow module ($45/user for firms with 1-3 users, $66/user for larger firms). Canopy is specifically designed for tax professionals and includes task management, workflow automation with conditions and actions, and client communication. The firm only pays for the modules they need rather than a full practice management suite.

Financial Cents Scale Plan — Budget-Friendly Option

Use Financial Cents Scale plan ($49/user/month annual or $69/month monthly) which includes workflow automation, auto-follow-ups for client tasks, and Zapier integration. Financial Cents is the most budget-friendly dedicated practice management tool with automation capabilities, serving over 5,000 accountants globally.

Jetpack Workflow — Pure Task/Deadline Management

Use Jetpack Workflow Organize plan ($36/user/month annual) as a lightweight deadline tracking and task management tool. Jetpack Workflow focuses exclusively on workflow and project management without the overhead of full practice management (no CRM, no billing, no portal). It provides recurring task automation, deadline tracking, and a central project hub.