Interview Experience

ONIX

SDE

Company page

IT 2027

Saturday, September 12, 2026

55 reads

✦7 min read

Onix Interview Experience 2026 — Associate Member of Technical Staff

I recently appeared for the Onix Networks campus recruitment process for the Associate Member of Technical Staffrole.

The process was conducted on campus, and the entire interview process took place in person on 7th September 2026.

I was fortunate enough to be selected for the role with a package of ₹12 LPA.

Here is a structured overview of my experience for anyone preparing for Onix or similar software engineering roles.

2. Recruitment Process

The application process was conducted through our college placement process in August 2026.

The recruitment process consisted of:

Online Assessment — 1st September 2026
Technical Interview Round 1 — 7th September 2026
Technical Interview Round 2 — 7th September 2026
HR Round — 7th September 2026

Both technical interviews were conducted in person.

The OA was divided into multiple sections covering aptitude, CS fundamentals, DBMS, networking, OBA and DSA.

3. Interview Rounds

Round 1 — Technical Interview

The first round was primarily focused on core CS concepts, problem solving and practical engineering scenarios.

It started with the usual:

“Tell me about yourself.”

After that, the discussion moved through several areas.

LLD + OOP

I was asked to design a vehicle booking/rental system using OOP.

The discussion involved:

Abstraction
Encapsulation
Inheritance
Polymorphism
Virtual functions
Pure virtual functions

The interviewer was interested not only in definitions but in whether I could actually apply these concepts while designing the system.

DBMS + ER Diagram

The same vehicle-booking system was then converted into a database design.

We discussed the relationship between:

Customer ↔ Vehicle

Since a customer can book multiple vehicles and a vehicle can be booked by multiple customers over time, the relationship was many-to-many, requiring an intermediate

code

1Booking

entity.

A follow-up question was:

“What if the same customer books the same vehicle multiple times?”

This led to the discussion of having a separate

code

1booking_id

to uniquely identify every booking.

SQL

I was then asked to find vehicles that had been booked more than once by a particular customer.

The discussion involved:

code
```
1GROUP BY
```
code
```
1COUNT()
```
code
```
1HAVING
```
Understanding exactly what level the grouping should happen at

The interviewer then changed the question slightly and asked for customers who had booked any vehicle more than once.

This changed the grouping requirement.

DSA — Minimum Coin Change

I was given a minimum coin change problem.

Time and space complexity were also discussed.

First Release Containing a Bug

Another interesting problem involved finding the first release containing a bug when testing a release was computationally expensive.

I approached it using binary search, but first considered when the relevant feature was introduced.

This allowed the search space to be reduced before applying binary search.

API Performance

I was given a scenario where:

“The API works, but it is slow.”

I initially discussed common approaches such as caching, CDN and reducing unnecessary requests.

The interviewer then added the constraint that all of these were already implemented.

The discussion moved toward handling extremely large datasets, including a scenario with 10 billion rows, and we discussed pagination, including:

Offset-based pagination
Cursor-based pagination

API Debugging

I was also asked how I would debug a non-working API.

I explained a systematic approach:

Request → API → Application Logic → Database/External Services → Response

The focus was on identifying exactly where the failure was occurring rather than immediately assuming a particular cause.

Networking

Another question was:

“The application doesn't work in the browser, but pinging the server works. What could be wrong?”

I initially mentioned CORS, but the interviewer ruled it out.

This led to discussing the difference between network-level connectivity and whether the actual HTTP service, backend, frontend integration or rendering is working correctly.

Large CSV Files

The final major problem involved comparing two CSV files.

The constraints kept changing:

Initially, compare the files line by line.
Then the matching line could occur at a different position.
Then both files could be 10 GB.
The CSVs could have a very large number of columns, making individual rows large as well.

This led to thinking about incremental processing and hashing rather than loading the complete files into memory.

Round 1 Result

The round covered:

OOP → LLD → DBMS → ER Model → SQL → DSA → Binary Search → APIs → Debugging → Networking → Large File Processing

I was selected for Round 2.

Round 2 — Technical Interview

The second technical round was very different.

It was conducted by a Senior Architect at Onix and was much more focused on my projects and the engineering decisions behind them.

The major areas were:

Projects → Architecture → RAG → Retrieval → Chunking → Multi-Agent Systems → LangChain → LangGraph → Scalability → DSA → OOP

RAG Project Deep Dive

The interviewer wanted to understand my implementation rather than simply asking:

“What is RAG?”

I had to explain:

Input and output
Overall pipeline
Chunking
Retrieval
Storage
Why the particular storage was used
How retrieved information moves through the system
Language-aware parsing
Communication between components

I also had to draw and explain the architecture, including the retrieval and chunking pipelines.

The questions were highly interactive.

Whenever I mentioned a component, the next question could be:

“Why is it there?”

“How does that actually work?”

“Where are you storing this?”

This made it clear that knowing the names of technologies was not enough. I had to understand the actual system.

Scaling the RAG System

The discussion then moved toward scalability.

The interviewer asked how I would scale the system to production-level usage with:

More documents
More users
More retrieval requests
Higher traffic
Larger workloads

The focus shifted from:

“How did you build it?”

to:

“What happens when this system becomes large?”

Multi-Agent Project

My other project involved a multi-agent architecture.

One of the first questions was:

“How is this actually agentic?”

I had to explain:

What each agent does
How the agents interact
How the workflow is controlled
How decisions are made
Why the architecture qualifies as agentic

LangGraph vs LangChain

The interviewer also asked:

Why did you use LangGraph?
Where did you use LangChain?
Why didn't you use LangChain here?

The focus was not on memorizing definitions.

It was about understanding why a particular technology was chosen for a particular problem.

DSA — String Rotation

I was then given a string problem involving determining whether one string could be obtained by right-rotating another string.

There was an important constraint:

The original string could not actually be rotated.

There was also an ambiguity around the case where both strings were equal, so I clarified the requirement before proceeding.

I then implemented the solution using a two-pointer approach, dry-ran it and passed the test cases.

The solution was O(n).

OOP — Polymorphism

The final major technical discussion was around polymorphism.

I was asked:

“What is polymorphism?”

We discussed:

Compile-time polymorphism

Function overloading
Operator overloading

Runtime polymorphism

Inheritance
Virtual functions
Function overriding

I also wrote C++ code demonstrating runtime polymorphism using virtual functions.

Round 2 Result

At the end of the second technical round, I was recommended for the HR round.

4. HR Round

The HR round was comparatively relaxed.

The focus was mainly on:

Personal introduction
Previous experience
Willingness to join Onix
Willingness to accept the offer
Other offers/interviews
Relocation
Family/background
General fit and willingness to join

There were no major technical questions.

The primary focus was understanding whether I was genuinely interested in the opportunity and comfortable with the requirements of the role.

5. Overall Experience

What stood out to me most about the Onix interview was the way the interviewers kept changing the constraints.

A simple database question became a discussion about repeated bookings.

A SQL question became a test of whether I understood the exact grouping requirement.

A standard binary-search problem became a discussion about reducing the search space using domain knowledge.

An API-performance question turned into a discussion about handling billions of records.

And the CSV problem became progressively more challenging as file size and row size increased.

The two technical rounds also tested very different things.

Round 1 was largely about how I approach unfamiliar engineering problems.

Round 2 was about how deeply I understand the systems I have already built.

The biggest lesson for me was that in a technical interview, it is not enough to know what a technology does.

You should be able to explain:

Why you used it
How it works
What alternatives you considered
What happens when the system scales
What happens when something fails
Why your design makes sense

6. What to Prepare for Onix

Based on my experience, I would recommend preparing:

Core CS

OOP
DBMS
SQL
Computer Networks
Operating Systems
Basic system design

DSA

Arrays
Strings
Hashing
Binary Search
Dynamic Programming
Two Pointers
Common interview patterns

Backend / Engineering

APIs
API debugging
Pagination
Databases
Large-file processing
Scalability
Networking basics

Projects

Most importantly, know your projects deeply.

Be prepared to explain:

What → Why → How → Alternatives → Limitations → Scaling → Failure cases

AI / RAG roles

If your resume contains AI projects, prepare:

RAG architecture
Chunking
Embeddings
Vector databases/search
Retrieval
LLM flow
Agentic systems
LangChain
LangGraph
Scalability
Hallucination/failure scenarios

7. Final Result

After clearing both technical rounds and the HR round, I was selected by Onix for the role of:

Associate Member of Technical Staff

Package: ₹12 LPA

Overall, it was a very interesting interview experience because the questions were not simply a fixed list of concepts.

The interviewers kept adding constraints and changing the problem.

That made the interview less about recalling predefined answers and more about thinking through engineering problems step by step.

And that was probably the most valuable part of the entire experience.

Full Interview Experience

I have written the complete detailed version of my Onix interview experience, including the detailed questions, approaches, project discussion, RAG architecture, multi-agent discussion, API scenarios, CSV problem and more.

Read the full article here:

Onix Interview Experience 2026 — From OOP to RAG, APIs and System Design