Best Tool for Remote Team Org Directory with Timezone and Availability Information 2026

Notion excels as the best remote team org directory tool, offering timezone tracking, availability status integration, and self-service updates without expensive enterprise tools. A timezone-aware directory transforms coordination across distributed teams—without it, you’re constantly calculating whether it’s 2 AM for your Tokyo teammate. This guide evaluates approaches and tools for building org directories that keep remote teams synchronized.

Why Timezone-Aware Directories Matter

When your team spans San Francisco, London, and Tokyo, sending a quick Slack message becomes a calculation. You need to know who is available, when they work, and whether your message will land at a reasonable hour. A static org chart fails at this—your directory needs to be dynamic, timezone-aware, and ideally integrated with your existing tools.

The core requirements for a modern remote team directory include:

Timezone data per member — stored in a standardized format (IANA timezone names like “America/Los_Angeles” or “Asia/Tokyo”)
Working hours configuration — not just timezone, but actual availability windows
Real-time availability status — integrations with calendars or status tools
Programmatic access — APIs or webhooks for automation
Self-service updates — easy for team members to keep their info current

Building a Custom Org Directory with Notion

Notion provides the most flexible foundation for custom org directories. You can create a database with properties for timezone, working hours, and availability, then surface it through Notion’s API or embedded views.

Here’s a Notion database schema that captures essential timezone data:

// Notion API query for team members with timezone info
const notion = new Client({ auth: process.env.NOTION_API_KEY });

async function getTeamDirectory() {
  const response = await notion.databases.query({
    database_id: process.env.TEAM_DB_ID,
    filter: {
      property: 'Status',
      select: {
        equals: 'Active'
      }
    },
    sorts: [
      { property: 'Name', direction: 'ascending' }
    ]
  });

  return response.results.map(page => ({
    name: page.properties.Name.title[0]?.plain_text,
    timezone: page.properties.Timezone.rich_text[0]?.plain_text,
    workingHoursStart: page.properties.WorkingHoursStart.rich_text[0]?.plain_text,
    workingHoursEnd: page.properties.WorkingHoursEnd.rich_text[0]?.plain_text,
    role: page.properties.Role.rich_text[0]?.plain_text,
    email: page.properties.Email.email
  }));
}

The limitation with Notion is real-time availability. You’d need additional integrations—either polling the Notion database or connecting to calendar APIs—to show who’s actually available right now.

People API Solutions for Enterprise Teams

For teams using Google Workspace or Microsoft 365, the built-in directory APIs provide timezone and out-of-office information directly. This approach works well if your organization already uses these platforms.

Google People API Implementation

import { google } from 'googleapis';

const people = google.people({ version: 'v1', auth: oauth2Client });

async function getTeamAvailability() {
  const teamEmails = [
    'alice@example.com',
    'bob@example.com',
    'carol@example.com'
  ];

  const responses = await Promise.all(
    teamEmails.map(async (email) => {
      const person = await people.people.get({
        resourceName: `people/${email}`,
        personFields: 'names,timeZones,calendarUrls'
      });

      return {
        name: person.data.names?.[0]?.displayName,
        timezone: person.data.timeZones?.[0]?.value,
        calendarUrl: person.data.calendarUrls?.[0]?.url
      };
    })
  );

  return responses;
}

The Google People API returns timezone data from user profiles, though it doesn’t provide real-time availability. For that, you’d query the Calendar API for free/busy status.

Microsoft Graph API Alternative

import { Client } from '@microsoft/microsoft-graph-client';

const graphClient = Client.init({
  authProvider: done => done(null, accessToken)
});

async function getTeamTimezones() {
  const users = await graphClient
    .api('/users')
    .filter("accountEnabled eq true")
    .select('displayName,mail,officeLocation,usageLocation')
    .top(999)
    .get();

  return users.value.map(user => ({
    name: user.displayName,
    email: user.mail,
    location: user.officeLocation,
    country: user.usageLocation
  }));
}

Microsoft Graph includes country information that can map to timezone defaults, though you’d still need explicit timezone storage for accuracy.

Dedicated Directory Tools with Availability Features

Several tools specialize in team directories with timezone awareness:

BambooHR provides employee directories with timezone fields and integrates with its time-off management system. The availability information comes from the scheduling features rather than real-time calendar integration.

Culture Amp includes org charts with timezone data for distributed teams. Its strength lies in combining directory information with engagement surveys and performance reviews.

Bitspinner focuses specifically on timezone awareness for remote teams, offering visual displays of team availability across timezones. The tool emphasizes meeting scheduler integration.

For engineering teams, these tools often fall short on API flexibility. You might find yourself building wrapper scripts to pull directory data into your own dashboards or Slack integrations.

Building a Slack-Centric Availability System

Many remote teams live in Slack, making it practical to surface availability there. You can build a custom integration using Slack’s user API:

import { WebClient } from '@slack/web-api';

const slack = new WebClient(process.env.SLACK_TOKEN);

async function buildTeamAvailabilityMap() {
  // Get all team members
  const users = await slack.users.list();

  // Get custom profile fields for timezone
  const teamInfo = await slack.team.info();
  const profileFields = teamInfo.team.customizableProfiles[0].fields;

  const timezoneFieldId = profileFields.find(f => f.name === 'Timezone')?.fieldId;
  const hoursFieldId = profileFields.find(f => f.name === 'Working Hours')?.fieldId;

  const team = await Promise.all(
    users.members
      .filter(m => !m.is_bot && m.id !== 'USLACKBOT')
      .map(async (member) => {
        const profile = member.profile;
        const customFields = profile.customProperties || {};

        return {
          id: member.id,
          name: profile.real_name,
          timezone: customFields[timezoneFieldId],
          workingHours: customFields[hoursFieldId],
          status: member.presence
        };
      })
  );

  return team;
}

This approach keeps availability visible where the team already works. You could extend this with a Slack app that responds to /availability commands or posts daily availability summaries.

Calculating Overlap Windows Programmatically

Once you have timezone data, you can calculate meeting windows where all participants are available:

function findOverlappingHours(timezones, workingHours = { start: 9, end: 17 }) {
  const results = [];

  // Check each hour of the day in UTC
  for (let utcHour = 0; utcHour < 24; utcHour++) {
    const availableIn = [];

    for (const { name, timezone } of timezones) {
      const localHour = utcToLocalHour(utcHour, timezone);

      if (localHour >= workingHours.start && localHour < workingHours.end) {
        availableIn.push({ name, localHour });
      }
    }

    if (availableIn.length >= 2) {
      results.push({
        utcHour,
        participants: availableIn
      });
    }
  }

  return results;
}

function utcToLocalHour(utcHour, timezone) {
  const now = new Date();
  const formatter = new Intl.DateTimeFormat('en-US', {
    timeZone: timezone,
    hour: 'numeric',
    hour12: false
  });

  // Create a date at the UTC hour
  const utcDate = new Date(Date.UTC(now.getFullYear(), now.getMonth(), now.getDate(), utcHour));

  // Get the local hour
  return parseInt(formatter.format(utcDate));
}

This function returns hours where at least two team members share overlapping work hours. You can filter results to find windows that work for specific participants.

Implementation Recommendations

For most distributed engineering teams, a hybrid approach works best:

Store core directory data in Notion or a dedicated HR tool — maintain timezone, role, and contact information here
Add real-time availability through calendar integrations — query Google Calendar or Outlook for current status
Surface availability in Slack — use custom apps or integrations to show who’s available now
Build automation around the data — scheduled reports, overlap calculators, and timezone converters

The “best” tool depends on your existing stack. Teams already using Notion should extend it. Teams on Google Workspace can use People API. Teams prioritizing Slack integration should build custom apps.

What matters most is that your directory data is accessible programmatically, stays current, and integrates with where your team actually communicates.

Built by theluckystrike — More at zovo.one