My Daughter's 15-Page Track Schedule Broke My Calendar Workflow

Mar 27, 2026

My daughter’s school sent home a 15-page PDF for her track and field schedule. Fifty-plus events scattered across multiple pages, each with different dates, times, and locations. I stared at it, then at my Google Calendar, then back at the PDF.

The math wasn’t complicated: 50 events, maybe 30 seconds per entry, that’s 25 minutes of pure data entry if nothing went wrong. But things always go wrong. I’d mistype a time, forget a location, or lose my place in the PDF.

There had to be a better way.

The Old Way: Manual Transcription Hell

Let me show you what I was up against. Each page looked something like this:

TRACK & FIELD SCHEDULE - SPRING 2025
=====================================

APRIL 2025
----------
Sat 04/05 - Varsity Meet @ Central Stadium - 9:00 AM
Mon 04/07 - Practice - School Track - 3:30 PM
Wed 04/09 - JV Meet @ Lincoln High - 4:00 PM
Fri 04/11 - Varsity Meet @ Riverside Complex - 3:30 PM
...

But spread across 15 pages with varying formats. Some events had start and end times. Some just had start times. Locations ranged from simple “School Track” to full addresses.

I tried the usual approaches first:

Copy-paste - Doesn’t work with calendar apps
CSV import - Google Calendar accepts CSV, but I’d have to manually format everything
OCR tools - The PDF was already digital, but still unstructured

Each approach still required me to manually identify and format every single event.

The Reddit Thread That Changed Everything

I was browsing r/OpenClaw when I found this gem from user mike8111:

“I got a 15 page PDF from my daughter’s school about the track and field schedule. I emailed it to Henry, and he sifted through and added all the dates times and locations to my calendar.”

Wait. What?

Another user, dhruvkar, chimed in:

“I did a similar thing with the botanical garden booklet. It had events throughout the year. Scanned it and sent it to openclaw. Created a separate calendar for it.”

This was exactly my problem. Someone else had already solved it.

The Solution: OpenClaw AI Agent

OpenClaw is an AI calendar assistant that can process documents and interact with your calendar. The workflow is stupidly simple:

┌─────────────┐      ┌─────────────┐      ┌─────────────┐
│   PDF File  │ ──▶  │  OpenClaw   │ ──▶  │   Calendar  │
│  (upload)   │      │  (AI parse) │      │  (events)   │
└─────────────┘      └─────────────┘      └─────────────┘

I uploaded the PDF through their interface. The AI parsed all 15 pages, identified every event, extracted the structured data, and asked me which calendar I wanted to use.

Total time: about 3 minutes.

How It Actually Works Under the Hood

Being a developer, I couldn’t just accept the magic. I wanted to understand the pipeline. Here’s what’s happening:

Step 1: Document Understanding

The AI uses vision and text extraction to read the PDF. For scanned documents, OCR kicks in automatically. The key challenge is recognizing that “Sat 04/05 - Varsity Meet @ Central Stadium - 9:00 AM” contains four distinct pieces of information:

Date: April 5th
Event name: Varsity Meet
Location: Central Stadium
Time: 9:00 AM

Step 2: Structured Data Extraction

The AI converts unstructured text into structured JSON. Here’s what the extraction looks like:

import anthropic
import json
import base64

def extract_events_from_pdf(pdf_path: str) -> list[dict]:
    """Extract calendar events from a PDF document using Claude."""

    client = anthropic.Anthropic()

    with open(pdf_path, 'rb') as f:
        pdf_content = f.read()

    message = client.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=4096,
        messages=[
            {
                "role": "user",
                "content": [
                    {
                        "type": "document",
                        "source": {
                            "type": "base64",
                            "media_type": "application/pdf",
                            "data": base64.b64encode(pdf_content).decode()
                        }
                    },
                    {
                        "type": "text",
                        "text": """Extract all events from this document.
                        Return a JSON array with each event containing:
                        - title: event name
                        - date: YYYY-MM-DD format
                        - time: HH:MM format (24-hour)
                        - location: venue or address
                        - description: any additional details

                        Output only valid JSON, no other text."""
                    }
                ]
            }
        ]
    )

    events = json.loads(message.content[0].text)
    return events

Step 3: Calendar API Integration

Once you have structured data, adding to Google Calendar is straightforward:

from google.oauth2.credentials import Credentials
from googleapiclient.discovery import build
from datetime import datetime, timedelta

def create_calendar_events(events: list[dict], calendar_id: str = 'primary'):
    """Add extracted events to Google Calendar."""

    creds = Credentials.from_authorized_user_file('token.json')
    service = build('calendar', 'v3', credentials=creds)

    created_events = []

    for event in events:
        event_body = {
            'summary': event['title'],
            'location': event.get('location', ''),
            'description': event.get('description', ''),
            'start': {
                'dateTime': f"{event['date']}T{event['time']}:00",
                'timeZone': 'America/New_York',
            },
            'end': {
                'dateTime': f"{event['date']}T{event['time']}:00",
                'timeZone': 'America/New_York',
            },
        }

        # Set end time 1 hour after start if not specified
        if 'end_time' not in event:
            start = datetime.fromisoformat(event_body['start']['dateTime'])
            end = start + timedelta(hours=1)
            event_body['end']['dateTime'] = end.isoformat()

        result = service.events().insert(
            calendarId=calendar_id,
            body=event_body
        ).execute()

        created_events.append(result)
        print(f"Created: {event['title']} on {event['date']}")

    return created_events

What I Learned

The whole experience took about 5 minutes from “I have this PDF problem” to “all 50+ events are in my calendar.”

Here’s what surprised me:

1. It handles ambiguity well

When the PDF had “TBD” for a location, the AI asked me about it instead of guessing. When dates were formatted inconsistently (04/05 vs April 5th), it normalized everything.

2. Timezone awareness

School schedules often assume local timezone. The AI correctly inferred my timezone and added it to each event.

3. Dedicated calendars

I created a separate “Track & Field 2025” calendar for these events. This keeps my main calendar clean and lets me share just this schedule with my wife.

4. Scanned PDFs work too

The user dhruvkar mentioned scanning a botanical garden booklet. The OCR handling is built-in.

Why This Matters

I’ve been waiting for this kind of automation for years. The reddit comment that stuck with me:

“This is the EXACT kind of thing that I always wished computers could do but they never could before.”

That’s the real insight here. We’ve had OCR. We’ve had calendar APIs. We’ve had LLMs. But combining them into a pipeline that actually works for a real-world problem like “I have a 15-page PDF and I need these in my calendar” - that’s new.

The technology existed. The integration didn’t.

When to Build vs Buy

If you’re wondering whether to use OpenClaw or build your own:

Use OpenClaw if:

One-off or occasional PDF processing
Want a simple interface
Don’t want to manage API keys and tokens

Build your own if:

Processing PDFs at scale (hundreds/thousands)
Need custom extraction logic
Want to integrate into existing workflows

For my daughter’s track schedule? OpenClaw was perfect. For processing thousands of invoices at work? I’d build a custom pipeline with LangGraph.

The Future Is Already Here

I used to think AI productivity tools were overhyped. This experience changed my mind. The key is finding the right use case - one where the AI’s strengths (document understanding, structured output) match your actual pain points.

A 15-page PDF with 50 events used to mean 30 minutes of tedious work. Now it means 3 minutes and a cup of coffee while the AI does the heavy lifting.

That’s not hype. That’s just useful.

Final Words + More Resources

My intention with this article was to help others share my knowledge and experience. If you want to contact me, you can contact by email: Email me

Here are also the most important links from this article along with some further resources that will help you in this scope:

Oh, and if you found these resources useful, don’t forget to support me by starring the repo on GitHub!