Building a Complete Meeting Processor: From Transcript to Tasks, Notes, and Tickets

I recently built something I’ve been thinking about for months – a system that takes my Plaud meeting transcripts and automatically files them to the right client folder, extracts my action items, creates tasks in Microsoft To-Do, and even generates ConnectWise tickets when work is discussed. (Yes, that’s an affiliate link. Full disclosure: I’m shamelessly trying to fund a Plaud Note Pro upgrade. The AI transcription is that good.)

The best part? It runs in the background after every meeting. No more “I’ll get to that later” followed by forgetting entirely.

Here’s how I put it together.

The Problem

Anyone who runs client meetings knows the drill. You finish a call, maybe jot some quick notes if you’re disciplined, then jump to the next thing. The meeting transcript sits in Plaud. The action items live in your head (briefly). The follow-up that should become a ticket never materializes because you’re already three fires deep.

I needed a system that would take my raw meeting transcript and turn it into something useful without requiring me to do anything after the call ends.

What the Workflow Actually Does

When a new Plaud transcript arrives, the workflow:

1. Pulls attendee information from my Outlook calendar
2. Matches the meeting to the correct client folder in OneDrive
3. Generates formatted meeting notes in HTML
4. Extracts my personal action items
5. Creates tasks in Microsoft To-Do
6. Identifies any work that needs a ConnectWise ticket (or adds notes to existing tickets)
7. Files everything to the appropriate location

All of that happens automatically, usually before I’ve walked back to my desk.

The Building Blocks

Matching Meetings to Calendar Events

The first challenge was identifying which client a meeting was about. Transcript text alone is unreliable – people don’t always say “This is our meeting with ABC Company.” But my calendar knows exactly who I was talking to.

The workflow uses the Plaud timestamp to find the matching calendar event in Outlook. I search within a 30-minute window before and after the recording time to account for meetings that start late or recordings that begin a few minutes in.

From that calendar event, I get the attendee list. That’s the key to client identification.

The Client Database Problem

I keep client files organized in OneDrive folders. The obvious approach was to match attendee email domains against folder names. But reality is messier than that.

Some clients have multiple domains. Some folder names don’t match company names exactly. Internal meetings involve only internal email addresses but still need to be filed somewhere.

The solution was a simple TXT file that acts as a client database. Zapier’s AI actions have a knowledge sources feature, but it only reads TXT files easily – so that’s what I went with. The file contains folder names, aliases (variations of the company name, domains, and other identifiers), and active status.

Here’s what the format looks like with sample data:

CLIENT LIST FOR MEETING MATCHING

Folder_Name: Acme Corporation
Aliases: Acme Corp, Acme Inc, acme.com, acmecorp.com
Active: Yes

Folder_Name: Bright Medical Group
Aliases: Bright Medical, BMG, brightmedical.org, bright-medical.com
Active: Yes

Folder_Name: Central Valley Schools
Aliases: CVS District, Central Valley USD, cvalleyschools.org
Active: Yes

Folder_Name: DataFlow Systems
Aliases: DataFlow, DFS, dataflowsys.com, dataflow.io
Active: Yes

Folder_Name: Eastside Manufacturing
Aliases: Eastside Mfg, ESM, eastsidemfg.com
Active: No

This file gets attached as a knowledge source in the Zapier AI action. The AI can reference it when matching the meeting to the right client using both the transcript content and the attendee email domains.

The AI Analysis Step

Here’s where it gets interesting. Instead of having multiple AI steps doing different things, I consolidated everything into a single prompt that returns structured JSON:

{
  "folder_name": "Client Name or INTERNAL or UNMATCHED",
  "confidence": "high/medium/low",
  "match_reason": "Brief explanation of the match",
  
  "meeting_notes": "Full HTML meeting notes",
  
  "christi_tasks": [
    {
      "task": "Task description",
      "deadline": "Date or TBD",
      "priority": "high/normal/low"
    }
  ],
  
  "connectwise_actions": [
    {
      "action": "create_ticket or add_note",
      "ticket_number": "Existing ticket if mentioned, otherwise null",
      "summary": "Brief ticket summary",
      "description": "Detailed description",
      "priority": "1-Critical/2-High/3-Medium/4-Low"
    }
  ]
}

The AI analyzes the transcript once and extracts everything in a single pass. This is more efficient than chaining multiple AI calls, and it keeps the context together so the AI can make better decisions about what’s important.

The Routing Logic

After the AI returns its JSON, the workflow branches based on what was found:

For filing, paths route based on the folder_name value. Client meetings go to the appropriate client folder. Internal meetings (all attendees from your own domain with no single client focus) go to an internal folder. Unmatched results trigger a Teams notification for manual review.

For tasks, the workflow loops through the christi_tasks array and creates each one in Microsoft To-Do. I set reminders based on the priority – high priority items get a next-day reminder, normal priority gets a week.

For ConnectWise, another loop processes the connectwise_actions array. If the action type is “create_ticket,” it creates a new ticket. If it’s “add_note” and includes an existing ticket number, it adds a note to that ticket instead.

The Prompt That Makes It Work

The system prompt for the AI step is the most important piece. It needs to be specific enough to generate consistent output but flexible enough to handle the variety of meetings I take.

Here’s the full prompt (with sample data in the context fields):

Analyze this meeting transcript and extract all relevant information for filing, notes, tasks, and ticketing.

CONTEXT:
Meeting Attendees: john.smith@acme.com, sarah.jones@yourdomain.com, mike.wilson@yourdomain.com
Meeting Subject: Acme Corporation - Quarterly Review
Meeting Date: 2025-01-07

Use the attached client list to identify the client.

TRANSCRIPT:
{{transcript}}

Return ONLY a JSON object:
{
  "folder_name": "INTERNAL or client Folder_Name or UNMATCHED",
  "confidence": "high/medium/low",
  "match_reason": "Brief explanation",
  
  "meeting_notes": "Full HTML meeting notes (use h2, h3, strong, ul, li, p tags only - no CSS)",
  
  "christi_tasks": [
    {
      "task": "Task description",
      "deadline": "Date or TBD",
      "priority": "high/normal/low"
    }
  ],
  
  "connectwise_actions": [
    {
      "action": "create_ticket or add_note",
      "ticket_number": "Existing ticket number if mentioned, otherwise null",
      "summary": "Brief ticket summary",
      "description": "Detailed description of work discussed",
      "priority": "1-Critical/2-High/3-Medium/4-Low"
    }
  ]
}

RULES:
- folder_name: "INTERNAL" if all attendees are from your domain AND no single client focus. Use exact Folder_Name from client list for client meetings. "UNMATCHED" if unclear.
- christi_tasks: Extract only action items specifically assigned to Christi
- connectwise_actions: 
  - If a ticket number is mentioned (like "ticket 12345" or "SR-12345"), use action "add_note"
  - If new work is discussed that needs tracking, use action "create_ticket"
  - Skip if no ticketable work discussed
- meeting_notes: Be thorough but concise. Include: Meeting Overview, Key Discussion Points, Decisions Made, Action Items, Follow-ups
- Format action items in notes with checkbox symbol

If no tasks for Christi, return empty array for christi_tasks.
If no ConnectWise actions needed, return empty array for connectwise_actions.

The context fields (Attendees, Subject, Date) get populated dynamically from the Outlook calendar lookup. The transcript comes from Plaud. The client list is attached as a knowledge source in Zapier’s AI action.

Key instructions include:

• Use “INTERNAL” for meetings where all attendees are from your own domain AND there’s no single client focus
• Use the exact Folder_Name from the client list when matching
• Use “UNMATCHED” when the client can’t be determined
• Extract only action items specifically assigned to me
• For ticket numbers, look for patterns like “ticket 12345” or “SR-12345”
• For meeting notes, include overview, key discussion points, decisions made, action items, and follow-ups
• Format action items with checkbox symbols

The AI returns empty arrays when there are no tasks or no ConnectWise actions needed, which keeps the downstream routing clean.

What I Learned Building This

The hardest part wasn’t the AI – it was the data matching. Getting consistent client identification required building that alias system and accepting that some meetings would end up in a manual review queue. Trying to force 100% automation would have created more problems than it solved.

Consolidating the AI analysis into a single step with structured JSON output made everything downstream simpler. Instead of parsing multiple different formats or coordinating between AI calls, I just extract the fields I need from one response.

The confidence score is underrated. Low-confidence matches go to manual review automatically. I’d rather spend 30 seconds confirming a folder location than find something misfiled weeks later.

The Tech Stack

For this specific workflow:

• Trigger: Plaud integration (new transcript)
• Calendar lookup: Microsoft Outlook (Find Event)
• Client database: TXT file attached as AI knowledge source
• AI processing: Claude (via Zapier AI action)
• JSON parsing: Zapier’s built-in formatter
• File storage: OneDrive
• Task creation: Microsoft To-Do
• Ticketing: ConnectWise
• Notifications: Microsoft Teams (for unmatched items)

A quick note on platform choice: I built this in Zapier because I already had my Plaud account connected there and had room in my monthly task allocation to slide this workflow in. I run automations across Zapier, Power Automate, and n8n depending on what makes sense for each use case. Sometimes spreading workflows across multiple platforms creates a nice balance – you’re not burning through your allocation on one platform, and each tool has its strengths. Don’t feel locked into picking just one.

The Bigger Picture

This workflow is a good example of what AI actually brings to automation. The underlying plumbing – moving files, creating tasks, posting to APIs – was always possible. What wasn’t possible was the judgment calls: figuring out which client a meeting is about, deciding what’s an action item versus just discussion, determining whether something should become a ticket.

That’s the piece AI adds. Not replacing the automation tools, but making them smart enough to handle the messy reality of how information actually flows through a business.

The meeting processor runs quietly in the background now. I finish a call, and by the time I check my to-do list 20 minutes later, the tasks are already there. The notes are filed. If a ticket needs to be created, it’s either done or queued up for approval. Its not instant of course, but usually pretty quick. 

That’s what useful AI automation looks like – not flashy demos, but systems that handle the repetitive judgment calls so you can focus on the work that actually matters.

Want to read more? Check out: Why IT Automation Isn’t Optional Anymore (and How to Start Now)