Launch Rail Logo
Launch Rail
Launch Rail: Scheduler Service

Stop Fighting Cron & Timezones. Ship Enterprise Scheduling.

A high-reliability Go microservice for event booking, availability management, and recurring job orchestration. Built for multi-tenant SaaS platforms that need to handle complex time-based workflows without the infrastructure overhead. Accessible via REST, gRPC, and native MCP server.

Get the Source CodeView API Docs
REST APIgRPCMCP Server

The Problem: Time-Based Logic is Fragile

Every developer thinks they can handle scheduling with a cron job and a database table. Then come the edge cases: timezones, recurring events with exclusions, race conditions in booking, and the massive overhead of managing a reliable background worker. Building a secure, multi-tenant scheduling system that won't fail at scale takes weeks of specialized work.

The Solution: Bounded, Reliable Scheduling

The Launch Rail Scheduler Service provides a complete, bounded context for all time-based operations. Built in Go and exposed via ConnectRPC, it delivers strictly typed REST and gRPC endpoints to handle everything from simple event booking to complex recurring job orchestration.

The Solution: A Tri-Service Architecture

The Launch Rail Schedule module is cleanly separated into three highly focused domain services, giving your application complete control over the booking lifecycle without monolithic entanglement.

1. Config Service The Rules

Define exactly when a resource is working. Author schedules in local "Wall Clock Time" with a designated timezone (e.g., Europe/Kyiv), and let the engine handle the exact UTC conversions automatically.

  • Weekly Rules: Standard Mon-Fri logic.
  • Shift Patterns: Rolling "2 days on, 2 off".
  • Calendar Rules: Date-specific adjustments.

2. Availability Service The Math

The core computation engine. It dynamically calculates Availability = Schedule - Exceptions - Bookings in real-time.

  • Instant Checks: Validate if a resource is free.
  • Slot Generation: FindAvailableTimeSlots for UI.
  • Batch Ops: Check multiple resources easily.

3. Booking Service The State

The source of truth for all confirmed reservations. It handles the lifecycle of an appointment, from pending intent to confirmed attendance.

  • Persistence: Confirmed, Cancelled, No-Show states.
  • Waitlists: Automatic user promotion logic.
  • Metadata: Attach per-booking custom data.

Built for High Throughput

A clean, stateless architecture that scales horizontally. Decoupled inputs and outputs ensure zero-downtime operations.

REST / gRPC

ConnectRPC Gateway

MCP Server

AI Agent Interface

Service Logic

Domain Engine

PostgreSQL

ACID Compliant Storage

NATS / CloudEvents

Async Broadcasting

Universal Scheduling Logic

Maximum Horizon

Restrict users from booking appointments more than 3 months into the future.

Cancellation Notice

Enforce rules requiring at least 24 hours of notice before a clean cancellation.

Buffer Times

Auto-block time buffer_before and buffer_after around every booking.

Implementation Examples

Developer-first by design. Access full-featured gRPC, REST, and MCP endpoints out of the box. Our services use ConnectRPC for lightweight, production-grade communication.

Go Code
1// Atomically book multiple resources
2res, err := schedClient.CreateBooking(ctx, connect.NewRequest(&schedv1.CreateBookingRequest{
3    ResourceIds: []string{"doc_001", "room_B2", "equip_Xray"},
4    Interval: &schedv1.Interval{
5        Start: timestamppb.New(startTime),
6        End:   timestamppb.New(endTime),
7    },
8    TenantId: "hospital_central",
9    Metadata: map[string]string{"patient_id": "p_991"},
10}))
Command Line Interface

Manage your infrastructure from the Terminal.

  • One-command provisioning

    Create users, tenants, and roles without touching the UI.

  • Secure Key Management

    Easily rotate API keys and manage workspace secrets.

  • Environment Sync

    Synchronize permissions across staging and production.

launchrail-ctl — zsh
$
Connected: Staging-US-East-1Latency: 12ms
Native MCP Server

AI Agents Talk to Scheduler Natively

Every Launch Rail service ships with a built-in MCP server. Your AI agents can discover tools, read resources, and execute actions—no wrappers, no custom integrations.

MCP Tools

Actions agents can execute

create_booking

Book a resource for a specific time slot with conflict prevention

find_available_slots

Query available time slots for a resource within a date range

cancel_booking

Cancel a reservation respecting cancellation policies

join_waitlist

Add a user to the waitlist for a fully-booked time slot

MCP Resources

Data agents can read

scheduler://resources/{id}/availability

Real-time availability for a resource including exceptions

scheduler://bookings/{id}

Full booking details with status, location, and participants

scheduler://resources/{id}/schedule

Working hours configuration and shift patterns

In Practice

What this looks like

AI Agent asks

“Find an available 30-minute slot with Dr. Smith next Tuesday afternoon and book it for patient Jane Doe”

MCP Server responds

Calls find_available_slots for Dr. Smith on Tuesday 12:00-18:00 → returns 3 open slots → selects 14:00-14:30 → calls create_booking with patient ID → confirms booking with idempotency key.

Build vs. Buy Launch Rail

Why spend 4 months building table structures and plumbing when you can start shipping features tomorrow?

Build it Yourself

The "Not Invented Here" approach

4+Months
High Opportunity Cost

Diving into low-level plumbing means your engineers aren't building your core product features. You risk security vulnerabilities and maintenance debt.

Buy Launch Rail

The "Speed of Light" approach

1Afternoon
Immediate ROI

Get the source code, deploy it in minutes, and focus on what makes your business unique. Zero technical debt, enterprise-ready from day one.

Feature ComparisonSelf-BuiltLaunch Rail
Atomic Conflict Checks
Multi-Resource Bookings
Automatic Waitlists
Timezone Math Logic
Custom Buffer Times
Native MCP Support

Real-World Value: Scheduler in Action

See how teams across industries use Scheduler to ship faster, reduce costs, and deliver enterprise-grade experiences from day one.

Healthcare

Multi-Resource Medical Appointments

Book a surgeon, an operating room, and anesthesia equipment in a single atomic transaction. Buffer times between surgeries are enforced automatically. Waitlists capture overflow demand.

Education

Class Scheduling & Room Allocation

Manage teacher availability across multiple campuses, assign classrooms based on capacity, and handle recurring lecture patterns with shift rules. Exceptions for holidays applied globally.

Fitness & Wellness

Group Class Bookings with Capacity

Yoga classes with 20-person limits, personal training 1:1 sessions, and equipment reservations—all in one system. Waitlists auto-promote when cancellations occur.

Beauty & Services

Salon & Spa Appointment Management

Stylists with individual working hours, service durations that vary by type, buffer times for cleanup, and advance booking policies that prevent same-day rushes.

Why Buy the License?

This module alone saves your engineering team 6+ months of development and testing.

By purchasing the Launch Rail Schedule module, you get the complete, production-ready Golang source code. Expose both high-performance gRPC and standard REST/JSON interfaces via ConnectRPC.

Zero Per-Booking Fees. Stop paying third-party APIs. Own the infrastructure and scale infinitely.

Ready to solve scheduling forever?

Frequently Asked Questions

Common Questions & Answers

Everything you need to know about integrating and hosting this Launch Rail service.

Related services

Identity ServiceNotifications Service

Related services

NotificationsSubmissionsIdentity

Related use cases

HealthcarePropTechLegalTech