Timeful: Why Teams Are Ditching Doodle for This Free Calendar Tool

What if scheduling a simple team meeting didn't require 47 emails, three Slack threads, and a small sacrifice to the calendar gods?

We've all been there. You need to find one hour where five people can meet. You send a Doodle poll. Three people forget to respond. Two more "think they might be free but need to check." By the time you've corralled everyone's availability, the project deadline has passed and you've aged approximately four years.

Here's the dirty secret nobody talks about: most scheduling tools are broken by design. They're either paid walls disguised as productivity apps, or they're so clunky that using them feels like a part-time job. Your calendar already knows when you're busy. Your colleagues' calendars know when they're busy. So why are we still manually typing "Tuesday 2pm?" into group chats like it's 2003?

Enter Timeful—the open-source scheduling platform that's making waves across GitHub and developer communities. Formerly known as Schej, this isn't just another poll tool. It's a calendar-native availability engine that reads your actual Google, Outlook, or Apple calendar and surfaces real availability without the guesswork. And the kicker? It's completely free, self-hostable, and built on a modern stack that developers actually respect.

If you're tired of scheduling hell, keep reading. This might be the last scheduling tool you'll ever need to evaluate.

What is Timeful?

Timeful is an open-source scheduling platform designed to eliminate the friction of finding mutually available meeting times for groups. Originally launched as Schej, the project rebranded to Timeful while maintaining its core mission: making group scheduling effortless through intelligent calendar integration.

The project lives at github.com/schej-it/timeful.app and has been quietly building a devoted following among developers, remote teams, and open-source enthusiasts who refuse to pay premium prices for basic functionality.

The Technical Foundation

What separates Timeful from typical SaaS scheduling tools is its transparent, developer-friendly architecture. The platform is built on a deliberately modern stack:

• Vue 2 for the reactive frontend—battle-tested, performant, and approachable for contributors
• Go for the backend API—delivering the concurrency and efficiency needed for real-time calendar operations
• MongoDB for flexible data persistence, handling everything from poll structures to user availability patterns
• TailwindCSS for utility-first styling that keeps the UI snappy and maintainable

This isn't a monolithic black box. It's a real open-source project with AGPL v3 licensing, meaning you can inspect every line of code, contribute improvements, or fork it entirely for your organization's needs.

Why It's Trending Now

The remote work revolution created a scheduling crisis. Teams are distributed across time zones, calendars are more fragmented than ever, and the "simple" act of finding meeting times consumes disproportionate cognitive load. Timeful addresses this with calendar-native intelligence rather than manual polling. The hosted version at timeful.app offers immediate gratification, while the self-hosting options give privacy-conscious organizations complete control.

The project's active Discord community, PayPal donation infrastructure, and growing Reddit presence (r/schej) signal healthy organic growth—not venture-funded artificial hype.

Key Features That Actually Matter

Let's dissect what makes Timeful genuinely useful versus feature-bloated competitors:

True Calendar Integration

This isn't "connect your calendar" as a marketing checkbox. Timeful reads actual calendar events from Google Calendar, Outlook, and Apple Calendar to determine real availability. No more "I think I'm free"—the system knows when you're in another meeting, traveling, or marked as busy.

Availability Overlap Detection

The core algorithm surfaces when everybody's availability actually overlaps. This sounds obvious, but most tools force participants to manually mark slots without cross-referencing existing commitments. Timeful does the computational heavy lifting.

"Available" vs. "If Needed" Distinction

Here's a subtle but brilliant feature: participants can mark times as firmly available versus available if absolutely necessary. This nuanced signaling prevents the "everything looks equally good" problem that plagues basic polls. Meeting organizers can prioritize truly convenient slots.

Subset Availability & Time Zone Intelligence

Need to find when three of five people can meet? Timeful handles partial group optimization. Combined with automatic time zone conversion, this eliminates the "wait, what time is that for you?" dance that destroys cross-functional team coordination.

Availability Groups (The Secret Weapon)

This is where Timeful transcends simple polling. Availability groups maintain persistent, real-time connections to participants' calendars. Instead of creating a new poll for every meeting, you have living groups that reflect current availability. For recurring team syncs or project pods, this is transformative.

Operational Conveniences

• Email notifications and reminders reduce the "oh I forgot to respond" problem
• Poll duplication saves setup time for similar meetings
• CSV export enables analysis and record-keeping
• Response privacy controls let organizers hide individual responses—crucial for sensitive scheduling (interviews, executive meetings, etc.)

Real-World Use Cases Where Timeful Dominates

1. Distributed Engineering Teams

Your backend team spans San Francisco, Berlin, and Tokyo. Standup scheduling shouldn't require a PhD in chronology. Timeful's time zone handling and calendar integration mean you create one poll, and the system automatically presents localized times to each participant while finding genuine overlap windows.

2. Open Source Project Governance

Maintaining an open-source project means coordinating contributors with day jobs, different employers, and unpredictable availability. Timeful's free tier without arbitrary limits and self-hosting option means project governance meetings don't depend on someone's corporate Zoom account.

3. University Research Collaborations

Academic schedules are nightmares—teaching loads, committee meetings, lab time, and conference travel create complex constraints. The "if needed" availability feature lets professors signal flexibility without committing to suboptimal times. CSV export helps administrators document meeting coordination efforts.

4. Client-Facing Consultancies

When scheduling with external clients, response privacy prevents exposing internal team conflicts. The professional presentation and calendar integration signal operational competence—no more "let me get back to you after I check with the team."

5. Interview Coordination

Hiring loops involve candidates, hiring managers, and multiple interviewers with packed calendars. Availability groups for hiring committees, combined with privacy controls, streamline this notoriously painful process.

Step-by-Step Installation & Setup Guide

Hosted Option (Fastest Path)

For immediate usage without infrastructure concerns:

# Simply navigate to the hosted instance
open https://timeful.app

# Create account, connect calendar, start scheduling

Self-Hosting with Docker Compose

Timeful provides containerized deployment for teams requiring data sovereignty. The Deployment Guide contains authoritative instructions, but the general pattern follows standard practices:

# Clone the repository
git clone https://github.com/schej-it/timeful.app.git
cd timeful.app

# Review the Docker Compose configuration
cat docker-compose.yml

# Configure environment variables
cp .env.example .env
# Edit .env with your MongoDB URI, OAuth credentials, and domain settings

# Build and launch services
docker-compose up --build -d

# Verify health
docker-compose ps
curl -f http://localhost:8080/health || echo "Check logs: docker-compose logs"

NixOS Deployment

For NixOS enthusiasts, the deployment guide includes declarative configuration:

# Reference the NixOS module from the repository
# Typical configuration includes:
# - Systemd service definitions
# - Nginx reverse proxy with SSL
# - MongoDB service dependency
# - OCI container runtime configuration

# Apply configuration
sudo nixos-rebuild switch --flake .#timeful-host

Calendar OAuth Configuration

Critical for functionality: you must configure OAuth credentials for your chosen calendar providers:

# Google Calendar OAuth
# 1. Create project at https://console.cloud.google.com/
# 2. Enable Google Calendar API
# 3. Configure OAuth consent screen
# 4. Create credentials (OAuth 2.0 Client ID)
# 5. Add authorized redirect URI: https://your-domain.com/auth/google/callback

# Microsoft Outlook OAuth
# 1. Register application at https://portal.azure.com/
# 2. Add Microsoft Graph API permissions: Calendars.Read
# 3. Configure redirect URI matching your deployment

# Apple Calendar
# Requires Apple Developer Program membership
# Configure Sign in with Apple and Calendar access

Store these credentials securely in your .env file—never commit them to version control.

REAL Code Examples: Plugin API in Action

Timeful exposes a Plugin API for programmatic availability manipulation. This is where the platform shifts from "useful app" to extensible infrastructure.

Reading the Plugin API Documentation

The repository includes dedicated documentation:

# Access the Plugin API specification
cat PLUGIN_API_README.md

This document defines how browser extensions and automation tools can interact with Timeful events programmatically.

Basic Plugin Structure

While the full API specification requires reading the dedicated docs, here's the conceptual pattern for plugin development:

// Example: Browser extension content script pattern
// This runs in context of timeful.app pages

// Wait for Timeful's global API object to initialize
function waitForTimefulAPI(timeout = 10000) {
  const start = Date.now();
  return new Promise((resolve, reject) => {
    const check = () => {
      if (window.timefulAPI) {
        resolve(window.timefulAPI);
      } else if (Date.now() - start > timeout) {
        reject(new Error('Timeful API not available'));
      } else {
        setTimeout(check, 100);
      }
    };
    check();
  });
}

// Initialize plugin functionality
async function initializePlugin() {
  try {
    const api = await waitForTimefulAPI();
    
    // Register custom availability source
    // This could integrate with corporate scheduling systems,
    // custom calendar implementations, or external data sources
    api.registerAvailabilityProvider({
      name: 'corporate-ldap',
      
      // Fetch availability for given date range
      async getAvailability(userId, startDate, endDate) {
        const response = await fetch(`/internal/ldap/${userId}/availability`, {
          method: 'POST',
          headers: { 'Content-Type': 'application/json' },
          body: JSON.stringify({ start: startDate, end: endDate })
        });
        return response.json(); // Returns intervals in Timeful's expected format
      },
      
      // Optional: Push availability changes back to source
      async setAvailability(userId, intervals) {
        // Implementation for bidirectional sync
        console.log('Would sync to LDAP:', intervals);
      }
    });
    
    console.log('Corporate LDAP plugin registered');
  } catch (error) {
    console.error('Plugin initialization failed:', error);
  }
}

// Run when DOM is ready
if (document.readyState === 'loading') {
  document.addEventListener('DOMContentLoaded', initializePlugin);
} else {
  initializePlugin();
}

What's happening here? This pattern demonstrates how organizations can bridge Timeful with internal systems. The registerAvailabilityProvider interface allows custom data sources to feed availability information, enabling scenarios like:

• Corporate LDAP/Active Directory integration for on-premise scheduling
• Custom shift management systems for healthcare or manufacturing
• External contractor platforms that don't use standard calendar protocols

Event Manipulation Pattern

// Interact with specific Timeful events programmatically
async function enhanceEventInterface() {
  const api = await waitForTimefulAPI();
  
  // Listen for event creation
  api.on('eventCreated', (eventData) => {
    // Automatically add corporate compliance requirements
    if (eventData.participants.length > 10) {
      api.showNotification({
        type: 'warning',
        message: 'Large meeting detected—consider async alternative per company policy'
      });
    }
  });
  
  // Programmatically create availability poll
  const newEvent = await api.createEvent({
    title: 'Q3 Architecture Review',
    description: 'Quarterly technical planning session',
    duration: 90, // minutes
    dateRange: {
      start: '2024-01-15',
      end: '2024-01-19'
    },
    timeRange: {
      start: '09:00',
      end: '17:00'
    },
    participants: ['alice@company.com', 'bob@company.com'],
    requireCalendarSync: true, // Enforce calendar-integrated responses
    visibility: 'creator-only' // Hide responses from participants
  });
  
  console.log('Created event:', newEvent.id);
  
  // Export results when polling completes
  api.on('eventFinalized', async (eventId) => {
    const csv = await api.exportAvailability(eventId, 'csv');
    // Auto-upload to corporate document store
    await uploadToDocumentStore(`meeting-${eventId}.csv`, csv);
  });
}

Critical insight: The event creation API accepts semantic parameters (duration, date ranges) rather than forcing manual slot definition. The system calculates optimal slots based on integrated calendar data. The requireCalendarSync: true flag ensures participants can't manually override—their actual calendar busy times are authoritative.

Availability Group Automation

// Maintain persistent availability groups for recurring coordination
async function setupTeamAvailability() {
  const api = await waitForTimefulAPI();
  
  // Create or update availability group
  const platformTeam = await api.createAvailabilityGroup({
    name: 'Platform Engineering',
    members: ['sre-lead@company.com', 'backend-eng@company.com', 'frontend-eng@company.com'],
    refreshInterval: 300, // seconds, real-time calendar polling
    notificationRules: {
      overlapFound: true,      // Alert when mutual availability emerges
      memberUnavailable: true  // Notify when someone becomes fully booked
    }
  });
  
  // Query optimal meeting windows on-demand
  const windows = await platformTeam.findMeetingWindows({
    duration: 60,
    withinDays: 14,
    minParticipants: 2, // Allow subset meetings if full group impossible
    preferContiguous: true // Favor single block vs. fragmented availability
  });
  
  // windows[] contains ranked suggestions with confidence scores
  console.log('Best windows:', windows.slice(0, 3));
}

Why this matters: Traditional polling is stateless—you recreate the coordination problem for every meeting. Availability groups are stateful persistent structures that continuously reflect reality. For teams with recurring coordination needs, this eliminates repetitive setup and captures emergent availability that static polls miss.

Advanced Usage & Best Practices

Privacy-First Deployment

When self-hosting, run MongoDB with authentication enabled and network isolation:

# docker-compose.yml excerpt
services:
  mongodb:
    image: mongo:6
    environment:
      MONGO_INITDB_ROOT_USERNAME_FILE: /run/secrets/mongo_user
      MONGO_INITDB_ROOT_PASSWORD_FILE: /run/secrets/mongo_pass
    networks:
      - internal  # No external exposure
    # Never expose port 27017 publicly

Calendar Sync Optimization

Google Calendar API has quota limits. For large deployments:

• Implement exponential backoff for API retries
• Cache calendar data with TTL matching your freshness requirements
• Use push notifications (webhooks) instead of polling where supported

Plugin Development Workflow

# Set up development environment
git clone https://github.com/schej-it/timeful.app.git
cd timeful.app

# Install dependencies
npm install

# Run frontend dev server with hot reload
npm run dev

# In separate terminal, run Go backend with file watching
air # or: go run ./cmd/server with appropriate flags

# Load unpacked extension in Chrome for plugin testing
# chrome://extensions → Developer mode → Load unpacked

Monitoring Self-Hosted Instances

# Health check endpoint
# Add to your monitoring stack
curl -s https://your-timeful.app/health | jq .

# Expected response:
# {
#   "status": "healthy",
#   "database": "connected",
#   "calendar_services": {
#     "google": "operational",
#     "microsoft": "operational",
#     "apple": "degraded"  // Track third-party service status
#   }
# }

Comparison with Alternatives

The verdict: Doodle and Calendly optimize for individual scheduling ("book a slot with me"). When2meet is a bare-bones grid with no intelligence. Timeful uniquely optimizes for group coordination with calendar-native awareness—and the open-source model means you're never locked into pricing changes or acquisition-driven feature removal.

FAQ

Is Timeful really free for unlimited users?

Yes. The AGPL v3 license means the core software is perpetually free. The hosted version at timeful.app currently has no usage limits, though the project accepts PayPal donations to sustain infrastructure. Self-hosting eliminates even that dependency.

How does calendar integration handle privacy?

Timeful reads busy/free status, not event details. Your "Team Standup" and "Salary Negotiation" events appear identically as "busy" blocks. The system never accesses event titles, descriptions, or participants without explicit additional permissions.

Can I migrate from Schej to Timeful?

The rebrand maintained data continuity. Existing Schej users should find their accounts and polls preserved. The GitHub repository redirect ensures existing bookmarks and integrations continue functioning.

What calendar systems work with self-hosted deployments?

Google Calendar, Microsoft Outlook/Exchange Online, and Apple Calendar are supported. Each requires OAuth application registration with the respective provider. Corporate Exchange on-premise would require additional integration work via the Plugin API.

Is the Vue 2 frontend being modernized?

Vue 2 reaches end-of-life, but remains secure and functional. The project's open nature means community contributions for Vue 3 migration are possible. The Go backend and MongoDB layer are modern and actively maintained.

How does the Plugin API differ from typical webhooks?

Webhooks are passive—your system receives notifications. The Plugin API is active—your code runs in context of Timeful's interface and can directly manipulate availability data, create events, and extend functionality. It's closer to a browser extension model than a traditional API.

Can availability groups replace recurring calendar holds?

Strategically, yes. Instead of blocking "maybe" time on calendars (which creates artificial scarcity), availability groups maintain soft availability intelligence. The system finds genuine overlap without polluting calendars with speculative holds.

Conclusion

Scheduling is a solved problem that most tools somehow still get wrong. They either nickel-and-dime you for basic features, trap your data in proprietary silos, or ignore the calendars where your real availability actually lives.

Timeful takes a fundamentally different approach. By building on open-source principles, integrating deeply with existing calendar infrastructure, and designing for group coordination rather than individual booking pages, it solves the actual problem: finding when humans can genuinely meet, without the email theater.

The availability groups feature alone justifies adoption for any team with recurring coordination needs. The Plugin API transforms it from application to platform. And the self-hosting option means you're investing in infrastructure you control, not renting functionality subject to pricing whims.

My recommendation? Stop paying for scheduling tools that treat calendar integration as a premium upsell. Stop manually herding availability like it's 2005. Deploy Timeful—whether on their hosted instance or your own infrastructure—and reclaim the hours currently lost to coordination friction.

Ready to end scheduling hell? Star the repository, join the Discord community, and start your first availability poll at timeful.app. Your future self—the one not drowning in "does this time work?" emails—will thank you.

Built with Vue 2, MongoDB, Go, and TailwindCSS. Licensed under AGPL v3. Community-driven and calendar-native.