Interview experience
Oracle Interview Questions and Answers (2026)
Overview
Section titled “Overview”Oracle’s fresher process is a fairly standard 4-round loop (assessment, two technical interviews, HR), but the technical bar leans harder on SQL and database fundamentals than most product companies since Oracle’s core business is databases and enterprise software.
Oracle interview process at a glance
Section titled “Oracle interview process at a glance”| Round | Duration | What it tests |
|---|---|---|
| Online assessment | 60-90 min | Quant, logical reasoning, verbal + DSA/OS/DBMS MCQs, 1-2 coding problems |
| Technical Interview Round 1 | 45-60 min | DSA, SQL queries, resume/project discussion |
| Technical Interview Round 2 | 45-60 min | DSA, database concepts, system-design basics |
| HR / hiring manager | 30 min | Motivation, fit, logistics |
Online assessment
Section titled “Online assessment”A single timed test with a quant/logical/verbal aptitude section plus a “general computer programming” section covering data structures, OS, DBMS, and C++/Big-O MCQs, followed by 1-2 coding problems. It’s the first filter and is usually taken on Oracle’s own testing platform.
Common questions
- Quantitative aptitude (time-speed-distance, percentages) and logical reasoning/flowchart-based puzzles
- Sentence correction, reordering, and reading comprehension
- MCQs on data structures, OS basics, DBMS, and Big-O complexity
- 1-2 coding problems, typically array/string manipulation at an easy-medium level
Technical Interview Round 1
Section titled “Technical Interview Round 1”Coding plus SQL, anchored on your resume. Interviewers ask you to write or trace code live, run SQL queries against a described schema, and explain your most substantial project in detail.
Common questions
- Array/string/linked-list coding problems (e.g. sliding-window or two-pointer patterns)
- Write a SQL query using joins, GROUP BY/HAVING, or a subquery against a sample schema
- Explain normalization, primary vs foreign keys, and when you’d denormalize
- Walk through your resume project’s architecture and the hardest bug you fixed
Technical Interview Round 2
Section titled “Technical Interview Round 2”A second technical pass that goes deeper into DSA or shifts into database/system-design basics depending on the interviewer and business unit (Database, OCI, Fusion Applications).
Common questions
- Medium-difficulty DSA problems (trees, graphs, or DP depending on level)
- Indexing and query-optimization basics - how indexes affect a slow query
- Basic system-design questions - how you’d structure a small API/service and its data layer
- OOPs fundamentals - inheritance, polymorphism, and where you used them in a project
Full round-by-round narratives are on the Oracle interview experience page.
HR / hiring manager round
Section titled “HR / hiring manager round”A closing 30-minute conversation on motivation, fit, and logistics after the technical bar is cleared.
Common questions
- Tell me about yourself and why Oracle
- Tell me about a time you failed at something - what did you learn
- Describe a time you made a mistake and how you owned up to it
- Are you open to relocation and the offered work location?
Sample answer frameworks for each of these are on the Oracle HR interview questions page.
OCI, Fusion Apps, and core Database roles
Section titled “OCI, Fusion Apps, and core Database roles”Oracle hires into meaningfully different businesses under one brand: Oracle Cloud Infrastructure (OCI, cloud/distributed-systems work), Fusion Applications (Java-heavy enterprise app engineering), and core Database engineering (SQL internals, storage, query optimization). The round structure is the same everywhere, but the technical depth of round 2 shifts toward whichever business unit posted the role - check the job title before you calibrate prep.
Common technical interview questions and answers
Section titled “Common technical interview questions and answers”Q: Write a SQL query to find the departments whose average salary is above 50000.
Aggregate by department and filter on the aggregate with HAVING: SELECT d.dept_name, AVG(e.salary) AS avg_salary FROM Employee e JOIN Department d ON e.dept_id = d.dept_id GROUP BY d.dept_name HAVING AVG(e.salary) > 50000 ORDER BY avg_salary DESC. The key points an interviewer listens for are that every non-aggregated column in the SELECT must appear in the GROUP BY, that the JOIN happens before grouping, and that the filter on the average has to live in HAVING because WHERE is evaluated before rows are grouped. Logical execution order is FROM, then JOIN, then WHERE, then GROUP BY, then HAVING, then SELECT, then ORDER BY - knowing that order lets you answer most follow-ups.
Q: What is the difference between WHERE and HAVING?
WHERE filters individual rows before any grouping happens, so it cannot reference an aggregate function - writing WHERE AVG(salary) > 50000 is an error. HAVING filters the groups produced by GROUP BY, so it can reference aggregates like COUNT, SUM, or AVG. If a condition can be expressed in WHERE, put it there: it removes rows early and so reduces the work the grouping step has to do, which matters on large tables. A query can use both - for example WHERE join_date >= '2020-01-01' narrows the rows first, then HAVING COUNT(*) > 5 keeps only the departments that still have more than five such employees.
Q: How does an index speed up a query, and what does it cost?
Most relational indexes are B-tree structures that keep the indexed column’s values in sorted order with pointers to the underlying rows. Instead of scanning every row (a full table scan, O(n)), the database walks the tree in roughly O(log n) to find matching values, which is why an index on a column used in WHERE, JOIN, or ORDER BY can turn a multi-second query into a millisecond one. The costs are real: every INSERT, UPDATE, and DELETE must also maintain the index, and indexes consume disk space. Indexes also stop helping when the query applies a function to the column (WHERE UPPER(name) = 'X' cannot use a plain index on name), when the column has very low cardinality, or when the query returns a large fraction of the table anyway.
Q: What is the difference between a primary key, a unique key, and a foreign key?
A primary key uniquely identifies each row, cannot contain NULLs, and a table can have only one - most databases create a clustered or unique index on it automatically. A unique key also enforces uniqueness but permits NULLs (how many NULLs is allowed varies by database) and a table can have several, which is how you enforce that email and phone are each unique alongside a numeric primary key. A foreign key is a column in one table that references the primary or unique key of another, enforcing referential integrity so you cannot insert an order for a customer_id that does not exist. Foreign keys also drive ON DELETE CASCADE or ON DELETE SET NULL behaviour when the parent row is removed.
Q: When would you deliberately denormalize a database?
Normalization removes redundancy and update anomalies, but every extra table means another join at read time. You denormalize when read performance matters more than storage and write simplicity - a reporting or analytics table that would otherwise join six tables, a product listing that stores a cached review_count instead of recomputing COUNT(*) on every page load, or a data warehouse star schema where dimensions are intentionally flattened. The trade-off is that duplicated data can drift out of sync, so you need a disciplined way to keep it correct: triggers, application-level updates, or a scheduled refresh. The interview-safe answer is: normalize by default to 3NF, then denormalize selectively with measurements showing the join is the actual bottleneck.
Q: How do you find the longest substring without repeating characters?
Use a sliding window with a hash map that stores the most recent index of each character. Move the right pointer across the string one character at a time; when the current character is already in the map at an index at or after the current window’s left boundary, jump the left pointer to one past that stored index. After each step, update the character’s index and record the window length right - left + 1 if it beats the best so far. This visits each character once, giving O(n) time and O(k) space where k is the alphabet size, versus the O(n squared) or worse cost of checking every substring. For “abcabcbb” the answer is 3 (“abc”), and the tricky test case is “abba”, where the left pointer must never move backwards.
Q: How do you detect a cycle in a linked list?
Use Floyd’s cycle-detection algorithm, also called the tortoise and hare. Advance a slow pointer one node at a time and a fast pointer two nodes at a time; if the fast pointer or its next reaches null, the list ends and there is no cycle. If a cycle exists, the fast pointer eventually laps the slow one inside the loop and they meet at the same node. This is O(n) time and O(1) space, better than the hash-set approach that stores every visited node in O(n) space. To find where the cycle starts, reset one pointer to the head after they meet and advance both one step at a time - the node where they meet again is the cycle’s entry point.
Q: Explain polymorphism with a concrete example.
Polymorphism lets one interface stand for many concrete behaviours. Compile-time polymorphism is method overloading: an area(int side) and an area(int length, int width) in the same class, resolved by the compiler from the argument list. Runtime polymorphism is method overriding through inheritance: declare an abstract class Shape with an abstract method area(), then have Circle and Rectangle each implement it. Code that holds a Shape reference and calls shape.area() runs the correct subclass implementation, chosen by the JVM from the actual object type at runtime through dynamic dispatch. The practical payoff is that a list of Shape objects can be totalled in a single loop, and adding a Triangle class later requires no change to that loop - which is exactly the open/closed principle in action.
Frequently asked questions about Oracle interviews
Section titled “Frequently asked questions about Oracle interviews”What is the Oracle interview process for freshers?
Oracle’s campus process usually runs 4 stages: 1. Online assessment (60-90 min) covering quantitative aptitude, logical reasoning, verbal ability, and a general-computer-programming section with MCQs on data structures, OS, DBMS, and C++/Big-O, plus 1-2 coding problems. 2. Technical Interview Round 1 (45-60 min) - DSA, SQL queries, and a walkthrough of your resume project. 3. Technical Interview Round 2 (45-60 min) - deeper DSA/system-design basics and database concepts. 4. HR/hiring-manager round (30 min) on motivation and fit. Total timeline is roughly 2-3 weeks.
What questions are asked in Oracle interviews?
Expect array/string/linked-list coding problems, SQL queries (joins, aggregates, subqueries), and core DBMS concepts (normalization, indexing, triggers, cursors) - unsurprising for a database company. OOPs fundamentals and a detailed cross-questioning of your resume project round out the technical rounds. HR checks motivation for Oracle, ownership, and teamwork.
How many rounds are there in the Oracle interview?
Typically 4: online assessment, two technical interviews, and a closing HR/hiring-manager round. Some drives merge HR into the second technical round or add an extra round for specific businesses like Oracle Cloud Infrastructure (OCI) or Fusion Applications.
How should I prepare for Oracle interviews?
Practise timed DSA problems, but weight SQL and database fundamentals more heavily than at a typical product company - Oracle interviewers lean on joins, indexing, and normalization questions since it’s core to the business. Prepare one detailed project narrative and revise OOPs basics.
Does Oracle interview differently for OCI, Fusion Apps, and core Database roles?
The overall round structure (assessment, two technical rounds, HR) stays the same, but the technical depth shifts with the business unit: OCI/cloud-infra roles lean into distributed systems and networking basics, Fusion Applications roles lean into Java/enterprise-app concepts, and core Database engineering roles go deepest on SQL internals, indexing, and query optimization. Check the specific job posting to calibrate prep.
What is Oracle’s fresher salary and eligibility?
Oracle typically hires CSE/IT/ECE graduates with around 6.5+ CGPA (varies by drive and campus), with some drives also open to related branches. Fresher PL/SQL and SDE roles commonly start in the mid single-digit to low double-digit LPA range - always confirm on your specific offer letter.