Spinny SDE-1 Interview Experience (Selected)
- Company: Spinny
- Role: SDE-1 / Associate Software Engineer
- Interview Mode: Remote
- Total Rounds: 4
- Difficulty Level: Medium
- Timeline: 1–2 Weeks
- Result: Selected
Recently, I interviewed with Spinny for an SDE-1 role. The process consisted of four rounds covering coding, low-level design, project discussions, Java fundamentals and SQL. The overall experience was structured and focused on evaluating both problem-solving ability and practical software engineering skills.
Unlike some interview processes that focus heavily on data structures and algorithms alone, Spinny's interviews also emphasized system design, database knowledge and understanding of real-world engineering challenges.
Interview Process Overview
| Round | Focus Area |
|---|---|
| Round 1 | Coding Round (HackerRank) |
| Round 2 | Low-Level Design |
| Round 3 | Project Discussion + Java |
| Round 4 | SQL + Technical Discussion |
Round 1: Coding Round
The first round was conducted on HackerRank and consisted of two medium-level coding problems. The interviewer was primarily interested in problem-solving approach, code quality and complexity analysis.
Problem 1: AVL Tree Based Problem
The first question involved AVL Trees. The problem required understanding:
- Self-balancing binary search trees
- Tree rotations
- Height balancing
- Efficient insertions and lookups
The challenge wasn't simply implementing a binary search tree but ensuring that the tree remained balanced after every insertion.
What the Interviewer Was Looking For
The interviewer focused on:
- Understanding of AVL balancing rules
- Correct use of rotations
- Time complexity analysis
- Ability to explain edge cases
Since AVL Trees guarantee balanced height, operations such as insertion, deletion and search remain efficient.
Key Complexity:
- Search → O(log N)
- Insert → O(log N)
- Delete → O(log N)
Problem 2: Graph-Based Problem
The second question was based on graph traversal concepts. Although the exact problem statement not remimber, the solution required identifying the appropriate graph algorithm and applying it efficiently. The discussion revolved around:
- Graph representation
- DFS vs BFS
- Visited node tracking
- Time and space complexity
The interviewer paid close attention to whether I could reason through the problem systematically rather than jumping directly into coding.
Round 2: Low-Level Design (Trip Expense Sharing System)
The second round was my favorite because it closely resembled a real-world software engineering problem. The interviewer asked me to design a system similar to Splitwise or a Trip Expense Manager.
Problem Statement
Imagine a group of friends going on a trip together. During the trip:
- Multiple users spend money
- Expenses are shared among participants
- The system tracks balances
- Users can settle payments later
The goal was to automatically determine who owes money to whom.
Requirement Gathering
Before discussing classes and APIs, I clarified requirements such as:
- Can multiple trips exist simultaneously?
- Can users participate in multiple trips?
- Should expenses support equal and custom splits?
- How are settlements handled?
The interviewer appreciated that I spent time understanding the problem before proposing a design.
Core Entities
I identified the primary entities:
User
Represents a participant in the system.
class User {
String userId;
String name;
}
Trip
Represents a shared travel event.
class Trip {
String tripId;
List<User> participants;
}
Expense
Stores information about spending.
class Expense {
User paidBy;
double amount;
List<User> participants;
}
Settlement
Represents debt resolution between users.
class Settlement {
User payer;
User receiver;
double amount;
}
Design Discussion
The majority of the discussion focused on:
- Balance calculation
- Extensibility
- Data modeling
- Future scalability
For example, if one user pays ₹5,000 for a hotel shared among five people, the system should automatically determine how much each participant owes.
The interviewer was less interested in code and more interested in whether the design could evolve as requirements changed.
Round 3: Project Discussion + Java Fundamentals
This round focused heavily on my previous projects and Java fundamentals. Unlike coding interviews, this discussion was centered around real engineering work and technical depth.
Project Discussion
The interviewer asked detailed questions about:
- Architecture decisions
- Challenges faced
- Performance improvements
- Production issues
- Scalability concerns
Every major project mentioned on my resume became a discussion topic.
One important lesson from this round is that interviewers often know when candidates are speaking from actual experience versus memorized answers.
Career Goals Discussion
The interviewer also explored:
- Long-term career aspirations
- Interest in backend engineering
- Motivation for joining Spinny
- Areas I wanted to grow in
This felt more like a conversation than an interrogation.
Java Questions
Several questions were asked around Java fundamentals and collections. Topics included:
- HashMap internals
- ConcurrentHashMap
- ArrayList vs LinkedList
- HashSet implementation
- equals() and hashCode()
- Comparable vs Comparator
- Collection framework hierarchy
The interviewer expected both theoretical understanding and practical usage knowledge.
Round 4: SQL + Technical Discussion
The final round was conducted by a senior engineering leader and focused heavily on SQL and database concepts. This round felt much closer to discussions that happen in real backend engineering work.
SQL Topics Covered
Joins
Questions around:
- Inner Join
- Left Join
- Right Join
- Full Join
The focus was understanding when and why each join type should be used.
Aggregations
Topics included:
The interviewer was interested in both syntax and business use cases.
Window Functions
This was one of the more advanced topics discussed. Examples included:
- ROW_NUMBER()
- RANK()
- DENSE_RANK()
- LEAD()
- LAG()
The discussion focused on solving analytical queries efficiently.
Query Optimization
Several questions explored how to improve slow queries.
Topics included:
- Proper indexing
- Query execution plans
- Avoiding unnecessary scans
- Reducing joins where possible
- Database performance tuning
This section felt particularly practical because these are common challenges faced in production systems.
Overall Experience
Overall, the interview process was balanced and practical. The coding round tested problem-solving ability, the design round evaluated software engineering thinking and the later rounds focused on real-world backend development skills such as databases, Java and project experience.
What I appreciated most was that every round felt relevant to the day-to-day responsibilities of a software engineer rather than focusing exclusively on competitive programming.
Preparation Tips
If you're preparing for a Spinny SDE-1 interview, I would recommend focusing on the following areas:
Coding
- Trees
- Graphs
- DFS/BFS
- Recursion
- Medium-level LeetCode problems
Low-Level Design
Practice designing systems like:
- Splitwise
- Parking Lot
- Library Management System
- Expense Sharing Platform
Java Fundamentals
Be comfortable with:
- Collections Framework
- Multithreading basics
- OOP principles
- HashMap internals
- Comparable and Comparator
SQL
Strong SQL knowledge is extremely important. Focus on:
- Joins
- Aggregations
- Window Functions
- Indexing
- Query Optimization
Final Thoughts
The Spinny interview process provided a well-rounded assessment of software engineering skills. Instead of focusing exclusively on algorithms, it evaluated coding ability, design thinking, database expertise, Java knowledge and project ownership.
If you're targeting similar product companies, don't limit your preparation to DSA alone. A strong understanding of system design, SQL and the ability to discuss real-world engineering decisions can make a significant difference in the outcome.