← Oracle Interview Insights

Oracle·Software Engineer·Onsite - System Design / Architecture·Senior

SeniorPrefer not to say
Jun 2026

Summary

System design round at Oracle for a software engineer role, focused entirely on building a job scheduler from scratch. Dense topic with a lot of ground to cover in a constrained window, and I definitely felt the time pressure.

Questions Asked (6)

Q1

Design a job scheduler system that supports cron and fixed-delay scheduling, dispatches jobs to workers, and handles retries and job dependencies.

System DesignData Modeling
Author's notes

This is the kind of question where you think you know where to start and then realize there are like five different places to start.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying requirements (scale, latency, durability, exactly-once vs at-least-once) and then present a high-level architecture with a scheduler service, a job store, a queue, and worker pool. Walk through the data model for jobs, schedules, dependencies, and retries, and explain how the scheduler triggers jobs, handles failures, and enforces dependencies.

Pro tip: Emphasize idempotency and at-least-once delivery with deduplication to avoid duplicate job execution, and discuss how to handle missed schedules (e.g., catch-up policies) — these are common pitfalls in production schedulers.

1. Clarify Requirements and Scope

Ask about scale (jobs per second, number of workers), latency requirements, durability guarantees, and whether exactly-once execution is needed. Also clarify supported schedule types (cron, fixed-delay) and dependency semantics.

2. High-Level Architecture

Propose a distributed system with a scheduler service that reads job definitions from a persistent store, computes next run times, and enqueues jobs to a message queue. Workers consume jobs, execute them, and report status back to the store.

3. Data Model and Storage

Design tables for jobs (id, name, schedule, payload, retry policy), job_runs (id, job_id, status, scheduled_time, start_time, end_time, attempt), and dependencies (job_id, depends_on_job_id). Use a relational DB for strong consistency and indexing on next_run_time.

4. Scheduling and Dispatching

Explain how the scheduler polls for due jobs (e.g., using a time-ordered index), applies cron/fixed-delay logic, and enqueues to a queue like Kafka or RabbitMQ. Discuss partitioning and leader election to avoid duplicate scheduling.

5. Retries, Dependencies, and Failure Handling

Describe retry policies (exponential backoff, max attempts), dead-letter queues, and how to handle dependencies (e.g., only enqueue a job when all dependencies succeed). Discuss idempotency and exactly-once semantics via deduplication.

Key Points to Mention

  • Use of a persistent job store (e.g., relational DB) with indexes on next_run_time for efficient polling.
  • Cron parsing and fixed-delay calculation, including timezone handling and daylight saving time.
  • Message queue for decoupling scheduler and workers, with at-least-once delivery and idempotent job execution.
  • Retry strategies: exponential backoff, jitter, max retries, and dead-letter queue for failed jobs.
  • Dependency management: DAG representation, topological ordering, and conditional enqueueing based on dependency status.
  • Scalability and fault tolerance: partitioning, leader election, and handling missed schedules (catch-up policies).

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

Q2

How would you architect the core components of the scheduler, including the queue, worker pool, and status store?

System DesignTechnical Trade-offs
Author's notes

Went with a time-ordered priority queue for next-run times plus a task queue for actual dispatch, and a separate status/history store.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying requirements and scale, then propose a high-level architecture for the queue, worker pool, and status store. Discuss trade-offs between different technologies and designs, and explain how components interact to ensure reliability and scalability.

Pro tip: Emphasize idempotency and exactly-once processing semantics, as these are critical for scheduler reliability and often overlooked. Also, mention how you would monitor and handle failures in each component.

1. Clarify Requirements

Ask about scale (jobs per second, queue size), latency requirements, durability needs, and failure handling expectations. This ensures your design meets the actual needs.

2. Design the Queue

Choose a durable, distributed queue like Kafka, RabbitMQ, or cloud-based (SQS). Discuss partitioning, replication, and how to handle backpressure and message ordering.

3. Design the Worker Pool

Decide on worker scaling (horizontal), concurrency model (threads vs. async), and how workers pull tasks. Address task distribution, load balancing, and graceful shutdown.

4. Design the Status Store

Select a database (SQL/NoSQL) for job statuses. Consider consistency, indexing for queries, and how to update statuses atomically. Discuss TTL for completed jobs.

5. Discuss Trade-offs and Integration

Compare alternatives (e.g., Kafka vs. RabbitMQ, SQL vs. NoSQL) and explain your choices. Describe how components interact, including retries, dead-letter queues, and monitoring.

Key Points to Mention

  • Idempotency and exactly-once processing to avoid duplicate job execution
  • Scalability and partitioning strategies for the queue and workers
  • Fault tolerance: replication, retries, dead-letter queues, and graceful degradation
  • Consistency and atomicity in status updates, possibly using transactions or optimistic locking
  • Monitoring and observability: metrics, logging, and alerting for each component
  • Trade-offs between different technologies (e.g., Kafka vs. RabbitMQ, SQL vs. NoSQL) based on requirements

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

Q3

Walk through the scheduling algorithm and how you'd scale it across multiple scheduler instances.

System DesignAlgorithms & Data Structures
Author's notes

Talked about sharding the priority queue by job ID range and using leader election so only one node fires a given job.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying the scheduling problem: what is being scheduled (jobs, tasks, resources), constraints (priority, dependencies, deadlines), and objectives (throughput, fairness, latency). Then describe a single-instance algorithm (e.g., priority queue with dependency handling) and finally discuss scaling via partitioning, distributed coordination, and fault tolerance.

Pro tip: Emphasize trade-offs and real-world constraints like clock skew, network partitions, and exactly-once semantics; Oracle interviewers value candidates who anticipate failure modes and can justify design choices with concrete examples.

1. Clarify Requirements and Constraints

Ask questions to understand the scheduling domain: job types, priorities, dependencies, SLAs, and scale (jobs/sec, number of workers). Define success metrics like latency, throughput, and fairness.

2. Design Single-Instance Algorithm

Propose a core algorithm: e.g., priority queue (heap) for priority scheduling, topological sort for dependencies, or round-robin for fairness. Discuss data structures and complexity.

3. Identify Scaling Challenges

List issues when moving to multiple schedulers: state consistency, coordination overhead, load balancing, fault tolerance, and clock synchronization.

4. Propose Distributed Architecture

Describe partitioning strategies (e.g., by job ID, priority range, or consistent hashing) and coordination mechanisms (e.g., leader election, distributed locks, consensus protocols like Raft/Paxos).

5. Address Fault Tolerance and Monitoring

Explain how to handle scheduler failures (replication, checkpointing), ensure exactly-once semantics, and monitor system health with metrics and alerts.

Key Points to Mention

  • Partitioning strategies (e.g., consistent hashing, range partitioning) to distribute load across schedulers.
  • Distributed coordination using consensus (Raft, Paxos) or a coordination service (ZooKeeper, etcd) for leader election and state management.
  • Handling dependencies and priorities in a distributed setting (e.g., DAG scheduling, priority queues per partition).
  • Fault tolerance: replication, checkpointing, idempotent operations, and recovery from scheduler failures.
  • Scalability metrics: throughput, latency, and fairness; trade-offs between consistency and availability (CAP theorem).
  • Real-world examples: Kubernetes scheduler, Apache Mesos, or Oracle Cloud Infrastructure scheduling services.

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

Q4

How do you handle failure scenarios, specifically at-least-once delivery and missed job runs?

System DesignTechnical Trade-offs
Author's notes

Idempotency keys for dedup on the worker side, and for missed runs I said you could either catch up all missed executions or just skip to the next scheduled time depending on the job type.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by acknowledging that failures are inevitable in distributed systems, then explain how you design for idempotency and resilience to handle at-least-once delivery and missed job runs. Use a concrete example from your experience to illustrate the trade-offs and your decision-making process.

Pro tip: Emphasize that you always consider the business impact of failures and choose solutions that balance consistency, availability, and cost—showing you think beyond just technical correctness.

1. Acknowledge the challenge

State that at-least-once delivery and missed job runs are common in distributed systems and must be handled proactively.

2. Design for idempotency

Explain how you make operations idempotent using unique keys, deduplication, or state checks to safely handle duplicate messages.

3. Implement retries and dead-letter queues

Describe your strategy for retrying failed jobs with exponential backoff and routing persistent failures to a dead-letter queue for analysis.

4. Monitor and alert on missed runs

Discuss how you track job execution (e.g., heartbeats, timestamps) and set up alerts to detect and recover from missed runs.

5. Share a real example

Provide a specific instance where you applied these principles, the trade-offs you made, and the outcome.

Key Points to Mention

  • Idempotency and deduplication techniques (e.g., unique message IDs, database constraints)
  • Retry policies with exponential backoff and jitter
  • Dead-letter queues for handling poison messages
  • Monitoring and alerting for job execution (e.g., using heartbeats, cron monitoring)
  • Trade-offs between consistency, availability, and cost
  • Real-world example demonstrating your approach

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

Q5

What metrics and observability would you build into this system?

Product Analytics & MetricsSystem Design
Author's notes

Per-job success rate, p99 execution duration, and queue depth.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by clarifying the system's critical user journeys and business goals, then propose a layered observability strategy covering metrics, logs, and traces. Focus on actionable metrics tied to SLOs, and explain how you'd use them for alerting, debugging, and capacity planning.

Pro tip: Tie every metric to a decision or action—if a metric doesn't trigger an alert, inform a dashboard, or guide a rollback, it's noise. Also, mention that you'd start with the 'four golden signals' and then add domain-specific metrics.

1. Clarify system goals and critical paths

Ask about the system's purpose, key user journeys, and business objectives to identify what matters most. This ensures your observability plan is aligned with real needs.

2. Define SLIs and SLOs

Propose specific service level indicators (e.g., latency, error rate, throughput, saturation) and set service level objectives. These form the foundation for alerting and prioritization.

3. Choose the right telemetry types

Explain how you'd use metrics for trends and alerting, logs for detailed debugging, and distributed traces for request flow analysis. Mention tools like Prometheus, Grafana, Jaeger, and the ELK stack.

4. Design dashboards and alerts

Describe how you'd create dashboards for different audiences (e.g., on-call, business stakeholders) and set up alerting with appropriate thresholds and escalation policies.

5. Iterate and improve

Emphasize that observability is not a one-time setup; you'd continuously review incidents, refine metrics, and add new instrumentation as the system evolves.

Key Points to Mention

  • The four golden signals: latency, traffic, errors, and saturation
  • Use of RED method (Rate, Errors, Duration) for services and USE method (Utilization, Saturation, Errors) for resources
  • Distributed tracing with context propagation to debug microservices
  • Structured logging with correlation IDs for traceability
  • Alerting on symptoms (SLO burn rates) rather than causes to reduce noise
  • Capacity planning and forecasting using historical metrics

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

Q6

What are the trade-offs between a pull-based versus push-based dispatch model, and between a centralized scheduler versus partitioned schedulers?

Technical Trade-offsSystem Design
Author's notes

Pull is easier to backpressure but adds polling overhead; push is lower latency but you need the scheduler to know worker capacity.

Create a free account to read the full note

AI HintsAI Generated

Suggested Approach

Start by defining the two dimensions clearly: pull vs. push dispatch and centralized vs. partitioned schedulers. Then compare them across key trade-offs like latency, scalability, complexity, and failure modes, using concrete examples (e.g., Kubernetes, Kafka, Celery). Finally, tie your answer back to the specific use case and constraints, showing that the right choice depends on context.

Pro tip: Emphasize that these are not binary choices—many production systems use hybrid approaches (e.g., push-based dispatch with partitioned schedulers) and the decision often hinges on workload characteristics and operational maturity.

1. Define the models

Briefly explain pull-based dispatch (workers request tasks) vs. push-based dispatch (scheduler assigns tasks to workers), and centralized (single scheduler) vs. partitioned (multiple schedulers each owning a subset of tasks).

2. Compare pull vs. push

Discuss trade-offs: pull offers better load balancing and backpressure but adds latency and polling overhead; push provides lower latency and immediate dispatch but can overload workers and requires sophisticated health tracking.

3. Compare centralized vs. partitioned

Analyze trade-offs: centralized simplifies coordination and global optimization but is a single point of failure and scalability bottleneck; partitioned improves scalability and fault isolation but complicates cross-partition coordination and can lead to uneven load.

4. Connect to real-world systems

Give examples: Kubernetes uses a centralized scheduler with pull-based kubelet; Kafka uses partitioned pull-based consumers; Celery supports both push and pull with centralized or partitioned brokers.

5. Conclude with context

Summarize that the best choice depends on factors like scale, latency requirements, failure tolerance, and operational complexity, and mention hybrid approaches.

Key Points to Mention

  • Latency vs. throughput trade-offs: push reduces dispatch latency, pull enables better throughput under load.
  • Scalability limits: centralized schedulers hit bottlenecks; partitioned schedulers scale horizontally but require partition management.
  • Fault tolerance: centralized scheduler is a single point of failure; partitioned schedulers isolate failures but need coordination for rebalancing.
  • Complexity and operational overhead: push requires worker health monitoring and retry logic; pull requires polling infrastructure and task visibility.
  • Load balancing and backpressure: pull naturally handles backpressure; push can overwhelm workers without careful rate limiting.
  • Real-world examples: Kubernetes (centralized push/pull hybrid), Kafka (partitioned pull), Mesos (centralized with offer-based pull).

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