Google·Software Engineer·Onsite - System Design / Architecture·Intermediate

Intermediate

Apr 2026

Summary

System design round at Google for a software engineer role, centered entirely on designing Google Calendar's event creation flow. The real focus ended up being conflict detection and resolution between overlapping events, which took up most of the conversation.

Questions Asked (1)

Design the event scheduling functionality for Google Calendar, with a focus on detecting and handling conflicts between user events.

System DesignData ModelingTechnical Trade-offs

Author's notes

I started with the usual stuff, data models, API endpoints, storage, but they kept steering me back to conflict handling specifically.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying requirements (scale, conflict types, time zones, recurrence) and then design a data model that supports efficient conflict detection. Propose an interval-based approach with indexing and discuss trade-offs between consistency and availability, including how to handle concurrent updates.

Pro tip: Mention that conflict detection should be done at write time with optimistic concurrency control, and that recurrence rules (RRULE) add complexity—consider expanding instances or using a rule engine. Also, discuss how to handle time zones and DST to show attention to real-world details.

1. Clarify Requirements

Ask about scale (users, events per user), conflict types (hard vs soft), recurrence, time zones, and consistency needs. This ensures the design meets actual needs.

2. Data Model & Indexing

Design a schema for events with start/end times, user ID, and recurrence rules. Propose indexing on (user_id, start_time, end_time) to enable efficient range queries.

3. Conflict Detection Algorithm

For a new event, query overlapping events using the index. Check for conflicts by comparing intervals, considering recurrence expansion and time zone normalization.

4. Concurrency & Consistency

Handle concurrent writes with optimistic locking or transactions. Discuss trade-offs between strong consistency (e.g., using a database with serializable isolation) and availability.

5. Scalability & Trade-offs

Address scaling by sharding on user ID, caching, and asynchronous conflict checks. Discuss trade-offs like latency vs consistency and how to handle large recurring events.

Key Points to Mention

Interval overlap detection using start/end times and efficient indexing (e.g., B-tree or interval trees).
Handling recurrence rules (RRULE) and exceptions, including expansion strategies and performance implications.
Time zone and daylight saving time handling to avoid incorrect conflicts.
Concurrency control mechanisms (optimistic vs pessimistic locking) to prevent race conditions.
Scalability considerations: sharding by user, caching, and asynchronous processing.
Trade-offs between consistency and availability, and how to communicate them to stakeholders.

AI-generated suggestions, not part of the candidate's original notes. May be inaccurate — verify before relying on them.