Lascari AI

← All writing

How You Can Save 20,000+ Hours a Year with a Secure, GPT-Driven Meeting to Email Workflow

Transform your Zoom meetings into actionable emails with a secure, GPT-driven workflow, saving 20,000+ hours annually.

Your team is wasting thousands of hours manually writing follow-up emails after Zoom meetings.

Every day, they:

Battle with meeting recordings
Miss capturing action items
Triple-check that sensitive data hasn't been exposed

For a mid-sized organization, this adds up to tens of thousands of wasted hours annually.

What if you could transform every Zoom transcript into a perfectly structured follow-up email in under 60 seconds, while keeping your sensitive data completely secure?

This post will show you how to:

Build a GPT-powered system that automatically converts meetings into action-ready emails
Protect sensitive data by keeping everything in your control
Save your organization 20,000+ hours annually on email drafting
Ensure 100% accuracy with domain-specific terminology correction
Create traceable links between action items and meeting timestamps

See It In Action

In this demo, you'll see:

A real meeting transcript being processed in under 60 seconds
The automated extraction of key points and action items
How sensitive data is handled securely
The final formatted email output ready to send

This automated workflow reduces a 30-minute manual process to just a few clicks while maintaining complete data security and accuracy.

The Real Cost of Manual Meeting Follow-ups

For a team of 50 people averaging just two client calls per week, manual follow-up emails waste 12,500 hours annually.

Here's what your team currently spends 30 minutes doing after every call:

Scrubbing through recordings to capture key points
Protecting sensitive client information
Converting raw notes into professional emails
Carefully replacing industry jargon with correct terminology
Formatting content for clarity and professionalism
Double-checking for potential confidentiality issues

The hidden costs go beyond just time:

Delayed action items impact project timelines
Inconsistent formatting creates confusion
Manual processes introduce human error
Critical details get lost in translation

The Solution: A Secure, GPT-Driven Workflow

Your organization can automate this entire process while maintaining complete data control.

Here's how:

1. Secure Transcript Processing

Keep all data within your infrastructure
Process sensitive information privately (Ensuring no PII is exposed)
Store and manage transcripts locally

2. Domain-Specific Accuracy

Custom vocabulary ensures industry terminology is correct
Automatic jargon correction and standardization
Built-in verification for technical terms

3. Intelligent Content Extraction

GPT automatically identifies key discussion points
Pulls action items and assignments
Maps timestamps to important moments

Parsing and Chunking Zoom Transcripts

Before GPT can work its magic, you need to split large Zoom transcripts into manageable chunks.

Zoom provides VTT files that often come with timestamps, speaker tags, and line breaks you’ll have to normalize.

Extract text from VTT format:
Remove timestamps and speaker labels, capturing only essential dialogue.
Chunk content:
Keep each chunk below the token limit to avoid GPT truncation.
A rule of thumb: 1,000–1,500 words per chunk.
Track timestamps:
Retain references to original timestamps so you can link them to summary topics and action items later.

VVT Format

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
1
00:02:49.700 --> 00:02:50.709
Speaker 1: Hello

00:02:52.430 --> 00:02:54.619
Speaker 1: how

00:02:55.520 --> 00:02:56.330
Speaker 1: are you?

00:02:56.774 --> 00:02:59.440
Speaker 2: I'm

00:03:08.040 --> 00:03:12.165
Speaker 2: doing good.

00:03:12.166 --> 00:03:13.000
Speaker 1: Awesome.

ParsedPython Format

python
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
{
    'speaker': 'Speaker 1', 
    'start_time': '00:02:49.700', 
    'end_time': '00:02:56.330', 
    'content': 'Hello how are you?'
},
{
    'speaker': 'Speaker 2', 
    'start_time': '00:02:56.774', 
    'end_time': '00:03:12.165', 
    'content': "I'm doing good."
},
{
    'speaker': 'Speaker 1', 
    'start_time': '00:03:12.166', 
    'end_time': '00:03:13.000', 
    'content': 'Awesome'
}

Domain-Specific Terminology: Teaching GPT Your Industry's Language

The biggest challenge with AI-generated meeting summaries isn't speed, it's accuracy with specialized terminology.

When your business handles terms like "Invisalign" or "malocclusion," even a small spelling error can damage client trust.

Here's how to make GPT speak your industry's language perfectly:

The Core Spell-Check Function

python
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
async def process_chunk(chunk, total_token_usage):
    try:
        spellcheck_response, completion = await async_client.chat.completions.create_with_completion(
            model='gpt-4o-mini',
            messages=[
                {"role": "system", "content": SPELLCHECK_SYSTEM_PROMPT},
                {
                    "role": "user",
                    "content": (
                        "Correct any misspellings in the transcript:\n"
                        + "# Transcript List\n\n"
                        + json.dumps(chunk)
                    ),
                },
            ],
            temperature=0,
            response_model=SpellCheckResponse,
            max_tokens=4096,
        )
        return spellcheck_response.checked_lines
    except Exception:
        return chunk

What makes this powerful:

Processes transcripts in parallel for lightning-fast corrections
Maintains context across large documents
Falls back gracefully if errors occur

Teaching GPT Your Industry's Dictionary

The magic happens in the context dictionary, where you teach GPT the exact terminology of your industry:

python
1
2
3
4
5
6
7
8
def get_spell_check_context():
    return {
        "company": AI_CONTEXT["company"],
        "dentalSpecialities": list(AI_CONTEXT["dentalSpecialities"].keys()),
        "dentalTerms": list(AI_CONTEXT["dentalTerms"].keys()),
        "orthodonticTerms": list(AI_CONTEXT["orthodonticTerms"].keys()),
        ... # Add more term dictionaries as needed
    }

For example, your orthodontic dictionary ensures perfect terminology:

python
1
2
3
4
5
6
"orthodonticTerms": {
    "Malocclusion": "Misalignment of teeth or incorrect relation between the teeth",
    "Brackets": "Small attachments bonded directly to teeth",
    "Archwire": "Metal wire attached to brackets",
    ... # Add more terms as needed
}

Real-world impact:

Zero terminology errors across thousands of emails Consistent professional language in every communication Automatic correction of common misspellings (e.g., "Invisaline" to "Invisalign")

The System Prompt That Ties It All Together

python
1
2
3
4
5
6
7
SPELLCHECK_SYSTEM_PROMPT = f"""# Purpose
You are an AI assistant specialized in spellchecking call transcripts for {company_name}.
Specifically correcting spelling discrepancies based on company terminology.

# Context
{json.dumps(get_spell_check_context())}
"""

Dynamic Topic-Action Linking: A Runtime Pattern for AI-Generated Content

The core challenge: You can't define relationships until the AI generates the topics, but you need strict typing for those relationships. Here's how we solve this chicken-and-egg problem:

The Dynamic Enum Pattern

First, we let the AI generate our summary topics freely:

python
1
2
3
4
# Generate initial topics without any linking
summary, token_usage = generate_summary_topics(
    self.parsed_transcript, self.attendees, self.call_type
)

Then comes the clever part - we dynamically create an enum from those generated topics:

python
1
2
3
4
5
6
7
8
# Create an enum on the fly from AI-generated topics
SummaryTopicKey = Enum(
    "SummaryTopicKey",
    [
        (summary_item.title, summary_item.title)
        for summary_item in summary.summary_topics
    ],
)

This runtime-generated enum becomes the bridge between topics and actions by extending the ActionItem class:

python
1
2
3
4
5
class ActionItemWithSummaryTopic(ActionItem):
    # Use the dynamically created enum as a type
    associated_summary_topic: SummaryTopicKey = Field(
        description="The summary topic this action item is associated with"
    )

Why this pattern is powerful:

Creates type safety for content we don't know until runtime
Ensures every action item links to a real, AI-generated topic
Prevents invalid relationships while keeping flexibility

The Process Flow

AI generates free-form topics
System creates an enum from those topics
New action items must reference valid topics
Everything gets linked with type safety
python
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
# Complete flow showing the dynamic creation and linking
async def execute(self) -> dict:
    # Step 1: Generate initial topics
    summary, token_usage = generate_summary_topics(
        self.parsed_transcript, self.attendees, self.call_type
    )

    # Step 2: Create runtime enum from topics
    SummaryTopicKey = Enum(
        "SummaryTopicKey",
        [(topic.title, topic.title) for topic in summary.summary_topics]
    )

    # Step 3: Define action items that must link to valid topics
    class ActionItemResponse(BaseModel):
        hip_action_items: List[ActionItemWithSummaryTopic]
        partner_action_items: List[ActionItemWithSummaryTopic]

    # Step 4: Generate linked action items with type safety
    action_items, token_usage = generate_action_items(
        self.parsed_transcript, 
        self.attendees, 
        self.call_type, 
        ActionItemResponse
    )

This pattern solves a unique challenge in AI-generated content - how to maintain strict typing and relationships with content that doesn't exist until runtime.

It's the bridge between AI flexibility and system reliability.

Want to stay updated on more content like this? Subscribe to my newsletter below.