cal-diy-oidc/agents/rules/performance-scheduling-complexity.md

title, impact, impactDescription, tags

title	impact	impactDescription	tags
Handle NP-Hard Scheduling Problems Carefully	HIGH	Prevents exponential blowup in scheduling operations	performance, scheduling, algorithms, np-hard

Handle NP-Hard Scheduling Problems Carefully

Impact: HIGH

Scheduling problems are fundamentally NP-hard. This means that as the number of constraints, participants, or time slots grows, the computational complexity can explode exponentially. Most optimal scheduling algorithms have worst-case exponential time complexity, making algorithm choice absolutely critical.

Real-world implications:

• Finding the optimal meeting time for 10 people across 3 time zones with individual availability constraints is computationally expensive
• Adding conflict detection, buffers, and other options amplifies the problem
• Poor algorithm choices that work fine for small teams become completely unusable for large organizations
• What takes milliseconds for 5 users might take many seconds for organizations

Strategies for managing NP-hard complexity:

// Use approximation algorithms
async function findMeetingTime(participants: User[], duration: number) {
  // Find "good enough" solution quickly rather than perfect solution slowly
  const approximateSlots = await findApproximateAvailability(participants, {
    maxIterations: 1000,
    timeout: 500, // ms
  });
  
  return approximateSlots[0]; // Return first good-enough option
}

// Implement aggressive caching
const cachedAvailability = new LRUCache<string, Availability>({
  max: 10000,
  ttl: 1000 * 60 * 5, // 5 minutes
});

// Pre-compute common scenarios during off-peak hours
async function precomputeTeamAvailability(teamId: number) {
  // Run during low-traffic periods
  const team = await teamRepository.findById(teamId);
  const availability = await computeTeamAvailability(team);
  await cache.set(`team:${teamId}:availability`, availability);
}

Key strategies:

• Use approximation algorithms that find "good enough" solutions quickly
• Implement aggressive caching of computed schedules and availability
• Pre-compute common scenarios during off-peak hours
• Break large scheduling problems into smaller, more manageable chunks
• Set reasonable timeout limits and fallback to simpler algorithms when needed

This is why performance isn't just a nice-to-have in scheduling software. It's the foundation that determines whether your system can scale to enterprise needs.

Reference: Cal.diy Engineering Blog