I Tried Building an AI-Powered Google Meet Scheduler

You call, you talk, and it schedules the meeting. Made with Twilio, Gemini, and Google Calendar.

The idea

Booking a meeting is a tiny task that somehow eats up five minutes every time. Open Calendar. Click “new event”. Type a title. Fight the date picker. Click “add Google Meet”. Copy the link. Paste it somewhere.

So I thought: what if I could just call a phone number, say “Schedule a meeting with the team tomorrow at 3 for half an hour,” and it does the rest?

No app. No typing. Just talk, like you’re talking to a friend.

So I built exactly that. You call a number, a friendly robot voice asks what the meeting is about and when, and a few seconds later, a Google Meet event pops up on your calendar — plus a text message with the link. 🎉

And once it worked, something clicked: ‘this is basically what a receptionist does when you call to book a doctor’s appointment or a salon slot.’ Listen, understand, put it on the calendar, confirm. Same job. (I’ll come back to that idea near the end — for now, let’s get the robot talking.)

Here’s how it works,

The big picture

Three services do the heavy lifting, and my little Node.js app is the glue in the middle:

You call a number

— Twilio (handles the phone call + turns your voice into text)

— My Node.js app (“okay, what did they say?”)

— Gemini (reads the messy text: “tomorrow at 3” → an actual date & time)

— Google Calendar (creates the event + a Google Meet link)

— Twilio again (texts you the Meet link)

Think of my app as a waiter. Twilio is the phone at the front desk. Gemini is the smart friend who understands “tomorrow, afternoon...” Google Calendar is the kitchen that actually makes the thing. My app just runs between them shouting orders.

The tools I used

• Node.js + Express — the web server that answers Twilio’s calls.

• Twilio — gives me a real phone number and does speech-to-text on the call. Bonus: it can also send SMS.

• Google Calendar API — creates the event and the Google Meet link (more on that neat trick later).

• Gemini (Google’s AI) — turns “next Monday morning” into 2026–07–06T09:00:00. This is the actual “AI” in the project.

• ngrok — a magic tunnel so Twilio on the internet can reach my app running on my laptop.

That’s it. No database. It’s a proof-of-concept, not a spaceship.

How a call actually flows

The whole conversation is a little back-and-forth. Twilio calls my app after every thing you say, and my app replies with instructions (“say this, then listen again”). Those instructions are written in TwiML — basically HTML but for phone calls.

1. You call. Bot: ”Hi! I can schedule a Google Meet meeting for you. What is the meeting about?”

2. You answer (“Project sync”). Bot: ”Got it. When should I schedule Project sync, and for how long?”

3. You say the time (“tomorrow at 3 PM for 30 minutes”).

4. Behind the scenes, Gemini reads that and figures out the real date, time, and duration.

5. Bot reads it back: ”I have Project sync on Saturday, July 4th at 3 PM for 30 minutes. Say yes to confirm.”

6. You say “yes”, and boom — event created, Meet link texted to you.

The reason it reads the time back before booking is important: phone speech-to-text is mostly great, but sometimes it hears “at 3” as “80.” Better to double-check than to schedule a meeting at a time that doesn’t exist. 😅

The code, one bite at a time

1. Answering the call

When someone calls, Twilio hits my /voice endpoint. I reply with a greeting and tell it to listen for speech:

app.post('/voice', (req, res) => {
    const s = getSession(req);
    s.from = req.body.From; // remember the caller so we can text them later

    const twiml = new VoiceResponse();
    twiml.say({ voice: 'Polly.Joanna' }, 'Hi! I can schedule a Google Meet meeting for you.');

    const gather = twiml.gather({
        input: 'speech',
        speechTimeout: 'auto',
        action: '/voice/collect-title', // send what they said here
    });
    gather.say({ voice: 'Polly.Joanna' }, 'What is the meeting about?');

    res.type('text/xml').send(twiml.toString());
});

gather is the important bit — it means “listen to the human, then POST what they said to the next URL.” I keep a tiny in-memory sessions object keyed by the call ID so I remember the title while I ask for the time.

2. Understanding “tomorrow at 3” with Gemini

This is my favorite part. Instead of writing a mountain of if-statements to parse dates (and crying), I just… ask Gemini nicely and tell it what today is:

Two small tricks that saved me a lot of pain:

• I hand Gemini the current date so words like “tomorrow” actually mean something.

• I ask for JSON only, so I can just JSON.parse() the answer instead of guessing.

Gemini even writes the friendly sentence (spokenConfirmation) that the bot reads back to you. Free labor. 🤖

3. The Google Meet magic

Here’s the thing nobody tells you: there is no separate “Google Meet API.” You don’t create a Meet link. You create a calendar event and politely ask Google to attach a Meet room to it. The secret sauce is one line: conferenceDataVersion: 1.

const event = {
    summary: title,
    start: { dateTime: start.toISOString(), timeZone },
    end:   { dateTime: end.toISOString(), timeZone },
    conferenceData: {
        createRequest: {
            requestId: `meet-${Date.now()}`, // any unique string
            conferenceSolutionKey: { type: 'hangoutsMeet' },
        },
    },
};

const res = await calendar.events.insert({
    calendarId: 'primary',
    conferenceDataVersion: 1, // ← leave this out and you get NO Meet link
    requestBody: event,
});

const meetLink = res.data.hangoutLink; // https://meet.google.com/xxx-xxxx-xxx

I lost a good chunk of time before realizing that without conferenceDataVersion: 1, Google happily creates the event and just… shrugs about the Meet link. Add that one line and the link appears like magic.

4. Texting you the link

Once the event exists, I text the Meet link to the caller using Twilio:

Simple. (On a trial account, US→India texts are hit-or-miss — but the Meet link also prints in the server logs and sits on the calendar, so nothing is lost if the SMS ghosts you.)

— —

Logging in to Google, once, forever

There’s one puzzle with Google: my app needs permission to touch a calendar, but I obviously can’t log in during a phone call.

The fix is a one-time dance called OAuth. I log in once in a browser, Google hands back a refresh token (a long-lived “this app is allowed” pass), and I save it. After that, my app uses that token to create events forever, no human needed.

I wrote a tiny authorize.js helper that opens the login page, catches Google’s redirect, and prints the refresh token. Paste it into .env, done. You never touch it again.

Testing without burning phone credits

Making a real phone call every time I changed one line got old fast. So I wrote a simulate-call.js script that pretends to be Twilio — it POSTs to each endpoint in order with fake “spoken” text, and runs the whole real pipeline (Gemini → Calendar → Meet link → SMS) without dialing anything.

node simulate-call.js "Team standup" "next Monday at 10am for 45 minutes"

Ten seconds later there’s a real event on my calendar. This one script probably saved me an hour of holding a phone to my ear like it’s 2009.

Wait — this could replace a receptionist

Here’s the fun realization I promised. My little “book a Google Meet” toy is doing the exact same steps a human does when you call to book an appointment:

• Listen → understand what you asked → check/put it on a calendar → confirm it back to you.

Swap “Google Meet on my calendar” for “a slot on the clinic’s calendar” and you’ve basically got an after-hours receptionist that never sleeps, never puts you on hold, and never says “can you call back at 10?”

A few places the same idea fits almost unchanged:

• Doctor/ dentist clinics — patients call, pick a free slot, get an SMS confirmation.

• Salons & spas — “haircut on Saturday morning” → booked.

• Sales / demo calls— leads call a number and self-schedule a demo.

• Local services — plumbers, tutors, mechanics who can’t answer every call.

Is it production-ready?

Is this ready for a real clinic? Not yet — but it’s surprisingly close. What started as a weekend project already handles the hardest part: understanding natural human speech and turning it into structured meeting details. Just a few years ago, that would have required a significant amount of custom NLP work. Today, it’s largely handled by an AI model through a single API call.

What’s next

This project was intentionally kept lightweight to focus on the core idea. If I were turning it into a production-ready application, I’d add:

• Inviting participants — Right now, it only schedules meetings on your calendar. Adding guests by voice is challenging (spelling email addresses over a phone call isn’t exactly fun), so I’d map frequently used names to saved contacts.
• Production deployment — Host the application on a cloud server instead of running it locally through ngrok.
• Security hardening — Verify incoming requests from Twilio using webhook signature validation and strengthen authentication.
• Context awareness — Support follow-up requests such as, “Actually, make it 4 PM instead,” without restarting the conversation.
• Availability checking — Check the user’s calendar before scheduling to avoid conflicts and suggest alternative time slots.
• Better conversational flow — Handle interruptions, corrections, cancellations, and ambiguous requests more naturally.

The takeaway

The biggest takeaway from building this project is how powerful today’s AI ecosystem has become. Twilio handles the phone calls, Gemini understands natural language, and Google Calendar creates meetings and Google Meet links. My job was simply to connect these services and orchestrate the workflow.

What would have been a complex research project a few years ago can now be built over a weekend with a few hundred lines of code — and, admittedly, a fair share of debugging along the way.

If you’ve been putting off a side project because it feels too ambitious, give it a shot. You’ll probably discover that most of the work is connecting the right tools together, and the biggest challenge is often finding that one missing line in the documentation.

I hope you found this walkthrough useful. Thanks for reading, and happy building!