---
title: "How to Build Interview Scheduling Across Greenhouse, Outlook and Google Calendar with"
img: https://s3.us-east-2.amazonaws.com/unified-article-images/how_to_build_interview_scheduling_across_greenhouse_outlook_and_google_calendar_with-icon.png
date: 2026-03-04T15:55:00.000Z
updated: 2026-10-21T12:06:01.436Z
readingTime: 4
tag: Product
description: "To build interview scheduling across Greenhouse, Outlook and Google Calendar with Unified.to, read the candidate, application and interview from the ATS,..."
url: "https://unified.to/blog/how_to_build_interview_scheduling_across_greenhouse_outlook_and_google_calendar_with"
---

# How to Build Interview Scheduling Across Greenhouse, Outlook and Google Calendar with

To build interview scheduling across Greenhouse, Outlook and Google Calendar with [Unified.to](http://unified.to/), read the candidate, application and interview from the ATS, create the meeting through [Unified.to](http://unified.to/)'s [Calendar & Meetings API](/calendar), and, on ATS integrations that support it such as Greenhouse, write the calendar event's ID back to the interview. This guide is for recruiting and scheduling products that book interviews in their customers' own systems.


For example, a recruiting platform may let hiring teams schedule interviews for candidates in Greenhouse while automatically creating calendar events in Outlook or Google Calendar.


The challenge is that interview data and calendar scheduling live in different systems. Applicant tracking systems store candidate and application data; calendars manage availability and meetings. Each platform has its own API and schema.


[Unified.to](http://unified.to/) maps ATS and calendar platforms to one schema per category. You read candidates, applications and interviews from the ATS and create events on the calendar through the same connection model. [Unified.to](http://unified.to/) reads and writes each system at request time and keeps no customer records at rest; connection credentials and operational metadata are encrypted at rest.


## Why do SaaS products build interview scheduling?


Many recruiting and hiring platforms provide scheduling for their customers — recruiting tools, interview coordination products, candidate scheduling assistants, hiring analytics platforms, and AI recruiting assistants.


Typical features include recruiters scheduling interviews with candidates, candidate self-scheduling links, panel interviews with multiple interviewers, and automated rescheduling and cancellations. Connecting ATS and calendar data lets these run automatically.


## Which [Unified.to](http://unified.to/) categories does interview scheduling use?


| Category            | Description                                                                        | Key objects                             |
| ------------------- | ---------------------------------------------------------------------------------- | --------------------------------------- |
| ATS                 | Candidate, application, and interview data from platforms like Greenhouse or Lever | `candidate`, `application`, `interview` |
| Calendar & Meetings | Calendar events used to schedule interviews                                        | `calendar_event`                        |
One schema per category lets a SaaS platform coordinate interviews without building a separate integration per system.


## Which ATS fields does scheduling need?


### Candidate


The person being interviewed.


| Field                       | Purpose                                                                |
| --------------------------- | ---------------------------------------------------------------------- |
| `id`                        | Unique identifier                                                      |
| `first_name` / `last_name`  | Candidate name                                                         |
| `emails`                    | Used for calendar invitations (each entry has `name`, `email`, `type`) |
| `telephones`                | Contact information                                                    |
| `created_at` / `updated_at` | Record timestamps                                                      |
### Application


Connects a candidate to a job.


| Field             | Purpose                                   |
| ----------------- | ----------------------------------------- |
| `id`              | Unique identifier                         |
| `candidate_id`    | Candidate associated with the application |
| `job_id`          | Job being applied for                     |
| `status`          | Current normalized stage                  |
| `original_status` | Raw stage label from the ATS              |
| `applied_at`      | Date the candidate applied                |
Application stage often determines when an interview should be scheduled. The normalized `status` enum includes `FIRST_INTERVIEW`, `SECOND_INTERVIEW`, and `THIRD_INTERVIEW` — so you might trigger scheduling when a candidate reaches `FIRST_INTERVIEW`, for example.


### Interview


Holds the scheduling information.


| Field                       | Purpose                                                                                          |
| --------------------------- | ------------------------------------------------------------------------------------------------ |
| `id`                        | Unique interview identifier                                                                      |
| `candidate_id`              | Candidate being interviewed                                                                      |
| `job_id`                    | Associated job                                                                                   |
| `application_id`            | Application context                                                                              |
| `user_ids`                  | Interviewers participating                                                                       |
| `status`                    | Interview state: `SCHEDULED`, `AWAITING_FEEDBACK`, `COMPLETE`, `CANCELED`, or `NEEDS_SCHEDULING` |
| `start_at` / `end_at`       | Interview time window                                                                            |
| `location`                  | Meeting location or remote link                                                                  |
| `external_event_xref`       | Reference to the linked calendar event                                                           |
| `created_at` / `updated_at` | Timestamps                                                                                       |
The `external_event_xref` field ties an ATS interview to its calendar event. As of 19 October 2026 it's readable on 12 ATS integrations and writable on three (Greenhouse, Carerix and Gem); elsewhere, keep the interview-to-event mapping in your own database. Interviews themselves come back on 44 ATS integrations.


### Job (context)


Provides context for the interview — job name, group/department, location, and hiring managers — useful detail to include in calendar invitations and candidate communications.


## Connecting customer ATS and calendar systems


Customers authorize their ATS and calendar integrations through Unified.to's embedded authorization flow:

1. Your application launches the authorization flow.
2. The user selects integrations such as Greenhouse, Outlook, or Google Calendar.
3. The user authorizes access.
4. Unified.to returns a `connection_id`.

Store the mapping `user_id → connection_id`, and reference that identifier in all subsequent API calls.


## How do you read the candidate and interview?


Scheduling begins by reading candidate and application data from the ATS:


```plain text
GET /ats/{connection_id}/candidate
GET /ats/{connection_id}/application
GET /ats/{connection_id}/interview
GET /ats/{connection_id}/job
```


This lets a scheduling tool retrieve candidate contact details, identify the associated job, determine the current application stage, and list existing interviews.


## How do you create the interview on the calendar?


Once candidate and interview details are known, the scheduling system creates a calendar event through Unified.to's Calendar & Meetings API:


```plain text
POST /calendar/{connection_id}/event
```


The normalized `CalendarEvent` carries the fields you need for an interview:


| Field                 | Purpose                                                                                                                         |
| --------------------- | ------------------------------------------------------------------------------------------------------------------------------- |
| `subject`             | The event title shown on the calendar                                                                                           |
| `start_at` / `end_at` | Interview time window                                                                                                           |
| `attendees`           | Candidate and interviewers (each with `email`, `name`, optional `user_id`, and a `status` of `ACCEPTED`/`REJECTED`/`TENTATIVE`) |
| `conference`          | Video meeting details (`url`, `label`, access codes); writable on Google Calendar, Microsoft Outlook and Microsoft Teams        |
| `location`            | Physical location for in-person interviews                                                                                      |
| `notes`               | Interview agenda or instructions                                                                                                |
| `send_notifications`  | Whether the calendar emails invitations; writable on Google Calendar, not on Microsoft Outlook (as of 19 October 2026)          |
Node SDK:


```typescript
const event = await sdk.calendar.createCalendarEvent({
  connectionId,
  calendarEvent: {
    subject: 'Frontend Engineer Interview – Round 2',
    startAt: '2026-07-01T15:00:00Z',
    endAt: '2026-07-01T16:00:00Z',
    attendees: [
      { email: 'jane@example.com', name: 'Jane Doe' },
      { email: 'interviewer@yourco.com', name: 'Sam Lee', required: true },
    ],
    notes: 'Technical round. Focus on system design.',
    sendNotifications: true,
  },
});
```


The `attendees` array adds the candidate and interviewers to the event; whether the calendar emails them depends on the calendar (set `send_notifications` on Google Calendar). Store the returned event `id`: write it to the interview's `external_event_xref` on Greenhouse, Carerix or Gem, or keep the mapping in your database elsewhere.


## How do you write the meeting back to the ATS interview?


On ATS integrations that write interviews, create or update the interview so the ATS shows the meeting. As of 19 October 2026, interviews can be created on 15 ATS integrations and updated on 13, including Greenhouse, SAP SuccessFactors, Zoho Recruit and Workday (Legacy) (Bullhorn updates only). Writable fields differ: on Greenhouse they are application_id, job_id, user_ids, status, start_at, end_at, location, meeting_url and external_event_xref. Set `external_event_xref` to the calendar event's `id` where it's writable (Greenhouse, Carerix, Gem).


Write support varies by integration, so confirm field-level support for each ATS on its [Supported Integrations](https://docs.unified.to/ats/integrations) page.


## How do you handle rescheduling and cancellations?


Scheduling systems need to react when meetings change. Calendar event changes arrive as created, updated and deleted events on supported integrations, including Google Calendar and Microsoft Outlook (as of 20 October 2026). A cancellation arrives either as an update with `status` `CANCELED` (the enum is `CONFIRMED`, `TENTATIVE` or `CANCELED`) or as a deleted event, so handle both.


## Which ATS and calendars are supported?


Unified.to covers a wide range of hiring and scheduling platforms.


**ATS (162 integrations; interviews on 44 of them as of 19 October 2026)**: interviews read from [Greenhouse](https://unified.to/integrations/greenhouse), [Lever](https://unified.to/integrations/lever), [Ashby](https://unified.to/integrations/ashby), [SmartRecruiters](https://unified.to/integrations/smartrecruiters), [iCIMS](https://unified.to/integrations/icims), [Jobvite](https://unified.to/integrations/jobvite), [Workable](https://unified.to/integrations/workable) and [Workday](https://unified.to/integrations/workday); created and updated on Greenhouse, SAP SuccessFactors, Zoho Recruit and Workday (Legacy), among others.


**Calendar & Meetings**: [Google Calendar](https://unified.to/integrations/googlecalendar), [Microsoft Outlook](https://unified.to/integrations/microsoftoutlook), [Zoom Calendar](https://unified.to/integrations/zoomcalendar), [Calendly](https://unified.to/integrations/calendly) and [Webex](https://unified.to/integrations/webex) (beta), among others.


## Why build interview scheduling on [Unified.to](http://unified.to/)?


Without a [unified API](/technology) you build and maintain one integration per ATS and per calendar. With [Unified.to](http://unified.to/) you call one ATS schema and one calendar schema, authorize customers through one embedded flow, and receive change events on supported integrations, so your team works on scheduling logic instead of per-vendor code.


Related: [How to Build Scheduling Into Your Product Across Google Calendar, Outlook and Zoom](https://unified.to/blog/how_to_build_scheduling_into_your_product_across_google_calendar_outlook_and_zoom) (availability and free/busy) · [Calendar API Integration](https://unified.to/blog/calendar_api_integration_real_time_events_free_busy_scheduling_links_and_meeting_recordings_across_platforms) · [How to Build a Candidate Portal](https://unified.to/blog/how_to_build_a_candidate_portal_showing_real_time_interview_stages_using_unified_ats_api)


Start building interview scheduling across Greenhouse, Outlook, Google Calendar, and dozens of other platforms today. [Start a free 30-day trial](https://app.unified.to/) or [book a demo](https://calendly.com/d/cph9-g8n-jzg/connect-with-unified).