UPTIQ Interview Experience
1. Company and Role
Company: Uptiq.ai
Role: SDE Role
Batch/Year of Graduation: 2027
Branch: Computer Engineering
2. Application Process
How did you apply? On-campus placement process
Selection Process: Online Assessment → Technical Interview → CTO Round → Final Selection
Timeline
Online Assessment: First stage of the selection process
Technical Interview: After the OA
CTO Round: Final interview round
Offer: Selected for the full-time role approximately 2 days after the CTO round
A total of 78 students were shortlisted for the interview process after the OA.
3. Interview Rounds
Round 1: Online Assessment
Type: Online Assessment — MCQs + DSA
Difficulty Level: Moderate to Hard
The OA consisted of 84 MCQ-based questions.
Most of the questions were focused on core Computer Science fundamentals, along with some questions related to:
Frontend development
Backend development
General software development concepts
Core CS fundamentals
The OA also included two DSA questions.
DSA Question 1 — Kadane's Algorithm
The first DSA question was based on the concept of Kadane's Algorithm, involving finding the maximum sum of a contiguous subarray.
This was an easy-level problem if you were familiar with Kadane's algorithm and maximum subarray problems.
DSA Question 2
Shifting Letters
You are given a string s and an integer array shifts of the same length.
For each index i, shift all characters in the string from index 0 to i by shifts[i] positions in the alphabet.
The alphabet is circular, meaning that after z comes a.
Return the final string after applying all the shifts.
Round 2: Technical Interview
Type: Technical + DSA + System Design + CS Fundamentals + Project Discussion
Difficulty Level: Hard
Before the interview, we were informed that the technical interview would be quite difficult and focused heavily on technical fundamentals.
The interview started with a brief self-introduction.
DSA
The interviewer then gave me a DSA problem.
The question was:
Given an array and a target k, you can remove an element from either the front or the back of the array and add it to your sum. Find the minimum number of operations required to obtain a sum equal to k.
This is similar to LeetCode 1423 — Maximum Points You Can Obtain from Cards. LeetCode 1423 — Maximum Points You Can Obtain from Cards
I discussed multiple approaches to solve the problem and was able to explain my reasoning. The interviewer was satisfied with the approaches I presented.
Project Discussion
After DSA, the discussion moved toward my project.
My project involved distributed systems, so the interviewer went quite deep into the architecture and implementation.
We discussed topics such as:
Distributed systems
Latency
Throughput
Database choices
Concurrent data structures
System-level design
High availability
Key-value stores
The discussion was not limited to what I had implemented; the interviewer also asked about the internal working and reasoning behind the technologies I had used.
System Design — Instagram Search
The interviewer then asked me to explain:
How does Instagram search work?
The discussion included questions around:
Database design
Database optimization
Sharding
Caching
Indexing
Scalability
I explained concepts such as sharding, caching, and indexes.
The interviewer then went deeper into how database indexes work internally.
B+ Tree and Database Indexing
I explained the internal working of a B+ Tree and discussed:
Internal nodes
Leaf nodes
How data is organized
Why B+ Trees are useful for database indexing
Searching through the tree
How indexes help improve database queries
The interviewer then expanded the discussion to other tree-based data structures.
We discussed:
AVL Trees
Red-Black Trees
B+ Trees
This part of the interview was particularly focused on understanding the internal implementation and data-structure fundamentals, rather than just knowing definitions.
Concurrent Data Structures in Java
Since my project used concurrent Java data structures, the interviewer asked about the data structures I had used.
I mentioned using:
- code
1ConcurrentSkipListMap Concurrent data structures
- code
1ConcurrentHashMap
The interviewer then asked about their internal working, particularly how concurrent data structures provide thread safety and support concurrent access.
This led to discussion around:
Concurrent collections
Internal implementation
Thread safety
Concurrent access
Java's
code1ConcurrentHashMap
Database / SQL
The interviewer also asked about SQL and database fundamentals.
There was some discussion around:
SQL basics
MySQL
Database fundamentals
This section was relatively straightforward compared with the deeper discussions on system design and data structures.
Operating Systems
The interview then moved to Operating Systems.
Some of the concepts discussed included:
Thrashing
Paging
Page-related concepts
Internal and external fragmentation
Swap-in and swap-out
Virtual memory
One interesting question was:
If a system has only 8 GB of RAM, how can a project/application requiring more than 8 GB of memory run?
This led to a discussion about virtual memory, paging, and swapping, particularly how the OS can move pages between RAM and secondary storage.
Distributed Systems and NoSQL
The discussion also went deeper into distributed-system concepts.
We discussed:
DynamoDB
Key-value stores
High availability
Distributed system design
Scalability
Latency
The interviewer was interested in the system-level reasoning behind these technologies rather than simply asking theoretical definitions.
After successfully completing the technical round, I was informed that I had cleared it and would proceed to the CTO round.
Round 3: CTO Round
Type: CTO / Technical + Project Deep Dive + System Design
Difficulty Level: Hard
The CTO round started with an introduction, followed by a deep discussion about my project.
Unlike a conventional interview where the discussion stays at a high level, the CTO went quite deep into the implementation details and the performance characteristics of the project.
Project Deep Dive
Some of the major areas discussed were:
Latency
Throughput
Latency vs. throughput
How latency was measured
How throughput was measured
Algorithms used in the project
Algorithms that I had implemented myself
Performance optimization
I was asked questions such as how I would optimize a system to achieve:
Millisecond-level latency
Sub-millisecond latency
Low-Latency Trading Systems
Since the project/domain was related to trading systems, we had a detailed discussion around low-latency trading.
We discussed how high-performance trading institutions optimize systems for extremely low latency.
The conversation went beyond software-level optimization and touched upon hardware-level optimizations and the techniques used in high-performance trading environments.
This was one of the most interesting parts of the interview because it involved thinking about the entire system stack rather than just application-level code.
I discussed several possible approaches for reducing latency and improving system performance.
Elevator Design Problem
The CTO then gave me a system-design/algorithmic problem:
Design an algorithm for an elevator system.
I designed the algorithm and explained my approach to the interviewer.
The discussion focused on the logic and reasoning behind the design rather than simply writing code.
HR / General Questions
Towards the end, there were some general questions, including:
What are your weaknesses?
Do you write SQL queries?
How much code do you write?
Questions about my general technical experience
The round was a mixture of technical depth, project discussion, system-level thinking, and general interview questions.
4. Overall Experience and Tips
Overall Interview Experience
The interview process was highly technical and strongly focused on fundamentals.
The interviewers did not simply ask theoretical questions. They frequently followed up with:
"How does it work internally?"
The interviews were more like technical discussions rather than a sequence of isolated questions.
The first technical round involved a wide range of CS fundamentals, while the CTO round focused more heavily on my project, system-level thinking, performance, latency, and real-world engineering decisions.
What to Prepare
Based on my experience, I would recommend preparing the following topics thoroughly.
1. DSA
Common LeetCode medium problems
Also practice explaining multiple approaches and their time/space complexities.
2. DBMS
Prepare:
SQL
Joins
Indexing
B+ Trees
B-Trees
Transactions
ACID properties
Isolation levels
Database optimization
Sharding
Replication
Caching
Most importantly, understand how indexes work internally rather than just knowing that "indexes make queries faster."
3. Operating Systems
Be prepared for questions that test whether you actually understand how the OS works internally.
4. System Design
Practice designing systems while being able to justify:
Database choice
Data structures
Caching strategy
Sharding strategy
Communication mechanism
Scalability
Availability
Latency
Bottlenecks
5. Your Projects
This is extremely important.
Know your project inside out.
Be prepared to explain:
Why you chose each technology
Architecture
Data flow
Algorithms
Database design
Performance
Latency
Throughput
Bottlenecks
Trade-offs
What you personally implemented
What you would improve
If you mention a technology on your resume, expect the interviewer to go several levels deeper.
Tips for Aspirants
Do not prepare only definitions. Understand how things work internally.
Know your projects extremely well. The interviewer can easily move from your project to databases, OS, distributed systems, concurrency, and system design.
Practice explaining your thought process. In the DSA round, explaining multiple approaches helped demonstrate problem-solving ability.
Prepare CS fundamentals seriously. DBMS, OS, DSA, and distributed systems were all important.
Understand performance. Be comfortable discussing latency, throughput, scalability, and optimization.
Expect follow-up questions. A question about database indexing can quickly become a discussion about B+ Trees and then move into tree data structures.
For technical interviews, don't stop at "what." Be ready for:
What is it?
Why do we use it?
How does it work?
How is it implemented internally?
What are the trade-offs?
When would you choose it?
