Timely

Inspiration

We've all been there: reading emails filled with meeting requests, then manually switching to Google Calendar to add each one. Copy the date. Paste. Fill out the form. Check for conflicts. Repeat. Two minutes per meeting.

During a particularly chaotic week, I received an email with four meeting requests buried in conversational text. As I manually copied each one into my calendar, I thought: "Why am I doing this? The computer can read. Why can't it just... schedule this for me?"

That question became Timely.

What it does

Timely is a Chrome extension that transforms any text containing meeting information into a calendar event in seconds.

Core Features:

Intelligent Text Parsing: Highlight any meeting request from emails, Slack, Google Docs, or any webpage
Dual-Engine Extraction: Uses Chrono for precise date/time parsing and Gemini Nano AI for context understanding
Automatic Conflict Detection: Checks your Google Calendar and warns before double-booking
One-Click Addition: Add events instantly with no forms or context switching

What Timely Handles:

Conversational language: "Let's grab coffee next Thursday at 11am"
Relative dates: "Meeting tomorrow", "next Monday", "in 2 weeks"
Time ranges: "Workshop from 2pm to 5pm"
Vague timing: "Lunch tomorrow" (AI suggests 12:00-13:00)
Tentative plans: "Maybe we can meet Tuesday afternoon?"
Multiple formats: "2pm", "14:00", "afternoon"

Universal Compatibility:

Works everywhere you can select text: Gmail, Slack, WhatsApp Web, LinkedIn, Google Docs, Notion, or any website.

The Impact:

From 2 minutes per meeting to 5 seconds. A 24x speedup that eliminates context switching and preserves your mental flow.

How we built it

Tech Stack:

Framework: TypeScript, React, Plasmo v0.90.5, Chrome Extensions Manifest V3
AI & Parsing: Chrome Prompt API (Gemini Nano), chrono-node
Calendar: Google Calendar API v3, OAuth 2.0 authentication
UI: Tailwind CSS, DaisyUI

System Architecture:

The innovation lies in our hybrid approach combining specialized tools:

1. Chrono Extracts All Dates

Chrono-node provides fast (50ms), deterministic date parsing that handles relative dates, various time formats, and complex expressions like "next Thursday" or "in 3 weeks".

2. AI Identifies Events and Context

Chrome's Prompt API (Gemini Nano) runs locally to understand context, extract event names, determine certainty levels, and map which dates correspond to actual meetings.

3. Event Mapping & Validation

We combine Chrono's precision with AI's understanding. The AI identifies which of Chrono's parsed dates is the actual meeting and provides the event name and details.

4. Conflict Detection

Before displaying any suggestion, we check Google Calendar for existing events in the proposed time window.

5. React UI with Plasmo

A floating overlay displays the parsed event with beautiful components from DaisyUI, making review and addition seamless.

Performance:

The entire flow takes ~300ms:

Chrono parsing: ~50ms
AI inference (local): ~200ms
Calendar API check: ~150ms
UI render: ~50ms

Speed improvement: $T_{\text{speedup}} = \frac{120\text{s}}{5\text{s}} = 24\times$

Why This Architecture Works:

Local AI: Zero network latency, complete privacy, no API costs, works offline
Specialized Tools: Chrono for dates (deterministic), AI for context (understanding)
Parallel Processing: Date parsing and AI analysis happen simultaneously
Smart Caching: Previously parsed events are cached to reduce repeated work

Challenges we ran into

Challenge 1: The Date Parsing Dilemma

Problem: Our initial AI-only approach had critical flaws. The model produced non-deterministic results (same input gave different outputs), took 800-1200ms per parse, and handled time formats inconsistently.

First Attempt: We improved prompts by adding more examples of date formats. This increased accuracy from 75% to 88% but made performance worse (1500ms), creating a noticeable lag for users.

Solution: We realized we were using the wrong tool. Date parsing is algorithmically solvable. We switched to chrono-node for dates (fast, deterministic, 50ms) and used AI only for context understanding (200ms). This hybrid approach was 70% faster overall (1200ms to 300ms) with 100% deterministic results.

Key Learning: Use existing tools specialized in specific tasks rather than forcing AI to do everything. It's better to combine specialized tools than rely on one general solution.

Challenge 2: Chrono's Context Blindness

Problem: Chrono parses every date it finds in text, regardless of relevance. For example, in "Discussing Q2 2024 performance. Let's meet Friday at 3pm for Q3 planning", Chrono returns three dates: Q2 2024, Friday at 3pm, and Q3. It can't distinguish which is the actual meeting.

Solution: We built an AI-powered mapping system. Chrono finds all dates first, then AI identifies which date belongs to the actual event and provides the event name. This combination gave us Chrono's precision plus AI's understanding, achieving ~92% accuracy in real-world testing.

Challenge 3: Time Zone Complexity

Problem: Time zones added complexity. "10am PT" needs conversion to the user's local time. "Next Monday" at 11:59pm Sunday could mean 1 minute away or 7 days. Chrono doesn't handle time zones consistently.

Solution: We anchored Chrono to the user's browser timezone using Intl.DateTimeFormat and configured Chrono with timezone context. For explicit timezone mentions, we use JavaScript's built-in internationalization APIs for conversion.

Challenge 4: OAuth in Chrome Extensions

Problem: Google Calendar API requires OAuth2, which is complex in extensions. Users must authorize, tokens expire and need refresh, and secure storage is critical.

Solution: Chrome's chrome.identity API handles OAuth seamlessly. It manages token storage, automatic refresh, and security automatically. We just request tokens when needed, and Chrome handles the rest.

Challenge 5: Performance on Large Documents

Problem: Parsing every text selection on large documents (like 50-page Google Docs) caused high CPU usage, UI lag, and battery drain.

Solution: We implemented multi-layer smart filtering:

Length validation: Skip selections under 10 or over 500 characters
Debouncing: Wait 300ms for selection stability before processing
Domain allowlist: Only activate on relevant sites (Gmail, Docs, Slack, etc.)
Keyword pre-check: Quick regex test for date-related keywords before full parsing

This reduced CPU usage by ~80% and eliminated user-perceived lag.

Challenge 6: Handling Ambiguous Information

Problem: Users write vague meeting requests like "Let's meet next month" (which day?), "Coffee sometime next week?" (when?), or "Meeting tomorrow" (what time?).

Solution: We built a confidence scoring system:

$C_{\text{total}} = w_1 \cdot C_{\text{date}} + w_2 \cdot C_{\text{time}} + w_3 \cdot C_{\text{name}}$

Where date specificity, time specificity, and event name confidence are weighted (0.4, 0.4, 0.2 respectively). If confidence is below 0.7, we show a warning. Below 0.5, we disable the add button and suggest manual entry.

Accomplishments that we're proud of

1. The Hybrid Architecture Innovation

Our biggest accomplishment is discovering and implementing the Chrono + AI hybrid approach. This wasn't obvious initially. We spent significant time trying to make AI handle everything before realizing specialized tools exist for good reasons.

The insight: AI excels at understanding context and meaning, while algorithmic parsers excel at precision and speed. Combining them creates something better than either alone.

Results: 70% performance improvement (1200ms to 300ms), 92% parsing accuracy, and 100% deterministic date handling.

2. True Local-First AI

Timely runs entirely on-device using Chrome's Prompt API. This means zero server costs, complete privacy (data never leaves your computer), no rate limits or API quotas, and offline functionality after initial load.

Building a production-quality tool with local AI in 2025 feels like glimpsing the future of privacy-respecting software.

3. Real-World Time Savings

The math is compelling. Time saved per meeting: 120s minus 3s equals 117s. For someone with 200 meetings per year, that's about 6.5 hours annually.

But it's not just about speed. It's about preserving mental context. Every switch from email to calendar and back loses focus. Timely eliminates that context switch entirely.

4. Universal Text Parsing

Timely works anywhere you can select text: email clients, messaging apps, documents, social media, or any website. This universality was technically challenging (different DOM structures, selection APIs, security policies) but makes Timely genuinely useful across a user's entire workflow.

5. Intelligent Conflict Detection

Before adding any event, Timely automatically checks your Google Calendar and warns of conflicts. This simple feature prevents double-booking, which happens surprisingly often with manual entry. The conflict detection is fast (~150ms) and happens in the background invisibly.

What we learned

1. AI Isn't Always the Answer (But It's Often Part of the Answer)

Don't use AI for problems that already have deterministic solutions.

Date parsing is algorithmically solvable. Libraries like chrono-node have spent years handling edge cases. Using AI for this was slower (800ms vs 50ms), non-deterministic (same input didn't guarantee same output), and less accurate on edge cases.

But AI is essential for context understanding, something rule-based systems can't do. These tools are complementary, not competitive.

The principle: Use specialized tools for specialized tasks, and AI for connecting the dots between them.

2. Prompt Engineering Has Real Performance Costs

Adding examples to prompts improves accuracy but kills performance. Short prompt: 800ms, 75% accuracy. Long prompt with examples: 1500ms, 88% accuracy.

For user-facing tools, that extra 700ms is unacceptable. The solution wasn't better prompts but better architecture (the Chrono + AI hybrid).

Lesson: When prompt engineering has diminishing returns, step back and rethink your architecture.

3. Local AI Changes the Game

Chrome's Prompt API (Gemini Nano) was revelatory:

Privacy: Data never leaves the device
Speed: No network latency (200ms vs 2000ms+ for cloud APIs)
Cost: Zero API fees, no rate limits
Offline: Works without internet

The trade-off is model capability. Gemini Nano is smaller than GPT-4 or Claude. But for focused tasks (parsing 10-100 word snippets), it's perfect.

Lesson: For many applications, local AI with constrained capabilities beats cloud AI with unlimited capabilities.

4. Context Switching is the Hidden Productivity Killer

The time savings from speed (117s per meeting) are obvious. But the hidden benefit is eliminating context switches.

Research shows it takes ~23 seconds to regain focus after a task switch. Reading email, switching to calendar, then back to email creates two switches: 46 seconds of focus loss per meeting.

Over 200 meetings per year, that's 2.6 hours of recovered focus time.

Lesson: Productivity tools should minimize context switches, not just execution time.

What's next for Timely

1. Automatic Event Detection (Like Grammarly)

The Next Evolution: Move from manual highlighting to automatic parsing. As you read emails or documents, Timely will proactively detect meeting requests and suggest adding them to your calendar, similar to how Grammarly underlines grammar issues.

How it works:

Monitors text content in real-time as you read
Subtly highlights detected meeting requests
Shows inline suggestions for calendar creation
Warns about conflicts before you finish reading
Batch processing for emails with multiple meetings

Smart Detection:

Pre-filters text using regex for meeting and date keywords
Only processes text that likely contains scheduling information
Uses the same Chrono + AI hybrid for parsing
Shows suggestions only for high-confidence events (>70%)

Inline Suggestions: Meeting requests get underlined with floating cards showing:

Parsed event details (name, date, time)
Conflict warnings if applicable
One-click adding or suggesting alternative times
Option to dismiss or disable for specific sites

2. Context-Aware Intelligence

Learn User Patterns:

Analyze calendar gaps to suggest optimal meeting times
Understand preferred meeting slots (learned from history)
Detect frequent attendees and auto-suggest
Warn if meetings fall outside typical working hours

Smart Scheduling:

"You have 30 minutes free before your 3pm meeting. Schedule here instead?"
Auto-suggest times that work best based on calendar patterns
Predict meeting durations based on event type and history

3. Recurring Events Support

Handle patterns like:

"Weekly standup every Monday at 10am"
"Bi-weekly 1:1s starting next Thursday"
"Monthly all-hands, first Friday of each month"

The Ultimate Vision

Imagine reading an email where meeting requests are automatically highlighted, conflicts are immediately flagged, and adding events to your calendar happens with a single click or even automatically.

That's the future of Timely: where scheduling happens automatically, conflicts are caught before they occur, and your calendar stays perfectly organised without you lifting a finger.

The broader impact: Timely isn't just about speed. It's about building a future where computers proactively understand and act on our behalf instead of waiting for explicit commands. Where scheduling is as natural as conversation.