Abzooba Software Engineer Interview Guide

The 60-second brief

Candidate-facing role descriptions say Abzooba builds data-driven applications, analytics platforms and intelligent solutions for enterprise clients. The Software Engineer role is described as sitting between application development and data engineering: backend logic, relational schemas, algorithms that process large volumes of data, unit tests, error-log analysis, SQL tuning and code review, mostly in Java or Python. The role is described as working with product teams, data scientists, technical architects and project managers. Candidates report that machine learning and data analytics awareness is a bonus on the software track, while coding, databases and computer science fundamentals come first.

This guide is for candidates interviewing for the Software Engineer role at Abzooba, from a campus drive or off campus, at the early-career level the role description targets. It covers the four reported stages (Resume Screening, Online Assessment, Technical Interviews, HR Discussion), the twenty questions candidates report across coding, core computer science, design and behavioral topics, and a week of preparation built on them. It does not cover data scientist or machine learning engineer loops.

Candidates report four stages over roughly 3-5 weeks: Resume Screening, an Online Assessment, Technical Interviews and an HR Discussion. Some campus drives are reported to finish all rounds in a single day.

Focus areas

• Data Structures (DSA)
• Algorithms
• SQL

Overview

The reported question list is broad, and each area sits at fundamentals level: string and graph coding, regular expressions, optimizing a given snippet, object-oriented programming, operating systems, networking, database indexing and normalization, SQL, a basic system design, scaling a backend service, and walking through your own projects. Candidates describe the most-tested topics as data structures, algorithms, SQL, live coding and database concepts. Preparation therefore means breadth with working depth: you should be able to write a correct solution in Java or Python, then explain why it is correct and what it costs.

The role description mixes software engineering with data work: relational schemas, SQL optimization, processing large data volumes, and unit tests. For you that means a schema question and a query question deserve as much time as a graph question. Practise saying why an index helps a particular query, what normalization removes, and what you would change when the table grows.

Candidates also report that your resume projects are the base for technical questioning, and that the online assessment mixes multiple-choice questions on databases, operating systems and networking with coding and SQL tasks. Treat every project line on your resume as an exam topic: know its schema, its data flow, the bug that cost you most time and the alternative you rejected. The behavioral and design questions reported for this loop (a complex project, deadlines, debugging under pressure, collaborating on a design) can all be answered from the same two or three projects, so choose them early and rehearse them until you can go one level deeper on any component.

The Abzooba interview process

These are the four stages candidates describe, in the order they report them. Formats vary between campus and off-campus hiring and between offices, so confirm the exact sequence with your recruiter.

Resume Screening

Candidates report that the process starts with a review of your resume for fit with the role. Nothing is reported about live questions here, so the work is in the document itself: it is also the baseline candidates say technical interviewers later use for questioning. Every project, tool and language on it should be something you can explain in depth. Cut or demote anything you cannot defend.

What to demonstrate

• Whether your listed skills match the role requirements candidates describe: Java or Python, data structures and algorithms, relational databases and SQL, object-oriented programming
• Whether your internships, projects and academic work show practical programming and, as a bonus, data analytics, machine learning basics, web frameworks or Git

How to prepare

• Rewrite each project entry as stack, your specific contribution and one measurable or checkable outcome, and delete any technology you could not discuss for ten minutes
• Pick two projects to narrate fully and prepare the architecture of each, since the project walkthrough and previous-architecture questions are reported for this loop
• Prepare a short, factual answer to why you want to join Abzooba as a Software Engineer, anchored in the data-driven software work the role description lists

Online Assessment

Candidates report a test hosted on platforms such as HackerRank. It combines multiple-choice questions on core subjects (databases, operating systems, networking) with coding challenges and SQL queries. Medium-difficulty exercises in Python or Java are reported, so you need working, edge-case-safe code under a clock rather than a sketch, and you need quick recall for the multiple-choice portion. Practise in the same kind of browser editor with no autocompletion help.

What to demonstrate

• Working code in Python or Java for medium-difficulty problems: string and substring manipulation, graph traversal, regular-expression tasks such as email validation
• SQL query writing: joins, grouping, subqueries, and recognising a slow query
• Recall of operating system, networking and database concepts through multiple-choice questions

How to prepare

• Solve timed medium problems in your chosen language, covering substring or string manipulation and graph traversal for paths and connected components, and keep a list of the edge cases that broke your first attempt
• Write an email validator with a regular expression, then test it against a table of valid and invalid addresses, using full-string matching so partial matches do not pass
• Revise multiple-choice material: process scheduling and deadlocks, memory management, TCP versus UDP, HTTP, clustered versus non-clustered indexes, normal forms, transactions

Technical Interviews

Candidates report several technical interviews, online or on-site depending on hiring location, assessing coding and problem-solving. The reported questions that fit this format include optimizing a given snippet, explaining object-oriented principles with examples from your projects, operating systems and networking basics, database indexing and SQL, and design questions: a basic system from requirements, tables and relationships for a feature, scaling a backend service, how components of an application communicate, and a previous project's architecture. Some candidates also report basic machine learning or analytics concepts where relevant to the role. Say your plan out loud before coding and state complexity for every solution.

What to demonstrate

• Coding and problem-solving: data structures, algorithms, complexity analysis and choosing the right structure
• Core fundamentals: object-oriented programming, operating systems, networking, database indexing, normalization and optimized SQL
• Design and architecture at a basic level: schemas, components, communication between modules and scaling a backend service
• Ability to explain your own project work and technical choices in depth

How to prepare

• Practise optimizing a slow snippet end to end: find the dominant cost, replace a nested loop with a hash map or sort plus scan, and state time and space before and after
• Rehearse the design questions with a concrete example such as a task management application: tables, keys, endpoints, then what changes under load (index, cache, replica, queue)
• Prepare spoken, example-backed answers for the object-oriented, operating system and networking questions, including the browser-to-server request lifecycle and the conditions for deadlock

HR Discussion

Candidates report a final discussion with HR about fit within the team and company culture. Some formats are also reported to include managerial deep dives. Treat it as the stage for the behavioral and managerial questions candidates report: a complex project from an internship or earlier role, tight deadlines or conflicting priorities, debugging a difficult issue under pressure, collaborating on a design, and why you want to join. Prepare specific stories rather than general statements about being a team player.

What to demonstrate

• Fit within the team and company culture, as candidates describe the stage
• Communication and teamwork, including how you describe past project work and collaboration
• Motivation for the role and for Abzooba

How to prepare

• Write four short STAR outlines (project, deadline, debugging under pressure, design collaboration), each with the decision you personally made and its result
• Prepare questions for the team about their technology stack and current projects, which candidates are advised to ask in managerial and HR conversations
• Clarify the office location (candidates mention Pune and Calcutta) and any hybrid arrangement with the recruiter, and have your own constraints ready

Where candidates lose points

Defining object-oriented principles from a textbook without a single example from your own code

For each of encapsulation, inheritance, polymorphism and abstraction, prepare one concrete use from a project: the class, why it was shaped that way, and what would go wrong without it. Be ready to name a design pattern you would use to decouple a tightly bound module and show the before and after.

Starting to code a string, substring or graph problem straight away, then missing the empty input, a disconnected graph or a cycle

Restate the input, list edge cases (empty string, single character, repeated characters, disconnected components, self-loops) and state the target complexity before writing. For graphs, choose BFS or DFS deliberately and keep a visited set so each node is processed once.

Writing an email-validation regular expression that is long, untested and matches partial strings

Keep the pattern simple (local part, @, domain with a dot), use full-string matching, and test it against a short table of valid and invalid addresses including missing @, double dots and spaces. Say aloud what the pattern deliberately does not cover.

Answering SQL and database questions with syntax only, unable to explain what an index does or why a query is slow

For every query, say which index it would use and why. Be able to explain clustered versus non-clustered indexes, the first three normal forms, and what an execution plan shows. Practise optimizing a slow query on a large table, not just a correct one.

Describing resume projects at feature level, so a question about the schema, data flow or architecture ends the discussion

For each listed project, prepare the component diagram, the tables, the hardest bug and one rejected alternative. Remove anything on your resume that you cannot explain at that depth.

Questions & practice

Write a program to solve a given substring problem or manipulate strings efficiently.

Medium · Coding and Algorithms

Approach

1. Name the pattern before coding. Longest substring without repeats is a sliding window with a last-seen index map: move the left edge to max(left, last[c] + 1). Each index enters and leaves the window once, so it runs in O(n) time with O(k) space for k distinct characters.
2. For anagram or permutation-in-string variants, keep a fixed-size window with a 26-slot count array. Update the counts as the window slides and track how many slots match, so each step costs O(1) instead of re-comparing 26 counts.
3. For plain pattern search, say that naive matching is O(n*m) in the worst case. KMP (prefix function) or Rabin-Karp (rolling hash, checking each hash hit to rule out collisions) brings it to O(n + m).
4. Build strings with ''.join(parts) in Python or StringBuilder in Java. Both are immutable string types, so += inside a loop can become quadratic.
5. Edge cases to state out loud: an empty string, a single character, the whole string as the answer, case sensitivity, and whether the input is ASCII or full Unicode.

Follow-up

• How would you find the minimum window of s that contains every character of t, duplicates included?
• What changes if the alphabet is full Unicode instead of 26 lowercase letters?
• Can you return every substring that ties for the longest length, not just its length?

Implement graph traversal algorithms to find paths or connected components.

Medium · Coding and Algorithms

Approach

1. Build an adjacency list from the edge list (a dict of lists, or List<List<Integer>> in Java). Ask whether the graph is directed or undirected, weighted or unweighted, and whether it can be disconnected. Traversal is then O(V + E).
2. For the shortest path in an unweighted graph, use BFS with a queue. Mark a node visited when you enqueue it, not when you dequeue it, so it is never queued twice. Keep a parent map and walk it backwards from the target to rebuild the path.
3. For connected components, loop over every node and start a DFS or BFS from each unvisited one, incrementing a counter. In Python, use an explicit stack: the default recursion limit is about 1000, and a long chain overflows it.
4. Mention union-find as the alternative for components. With path compression and union by rank, each operation is near-constant amortized (inverse Ackermann), and it handles edges that arrive one at a time.
5. Grids are implicit graphs (number of islands). Neighbours are the 4 or 8 adjacent cells with bounds checks, and you can mark visited cells in place if you are allowed to change the input.

Follow-up

• The edges now have non-negative weights: what replaces BFS, and what is its complexity? (Dijkstra with a binary heap, O((V + E) log V).)
• How would you detect a cycle in a directed graph? (Three-colour DFS, or check that Kahn's topological sort processes every node.)
• How would you find whether a path exists between two nodes as edges keep being added?

Solve coding problems involving regular expressions, such as validating email formats.

Medium · Coding and Algorithms

Approach

1. Anchor the whole match. In Python, re.fullmatch (or ^...$ with re.match) is correct. re.search alone accepts junk around a valid address, and re.match anchors only at the start. In Java, String.matches and Matcher.matches already require the whole string to match.
2. Agree on a practical subset instead of full RFC 5322. One workable pattern is ^[A-Za-z0-9._%+-]+@[A-Za-z0-9-]+(.[A-Za-z0-9-]+)*.[A-Za-z]{2,}$. Say what it still lets through, such as consecutive dots in the local part or a hyphen at the start of a domain label, and tighten it if asked.
3. Write the test cases before trusting the pattern. Valid: a@b.co, first.last+tag@sub.example.org. Invalid: @x.com, a@x, a@x., a..b@x.com, a space inside, two @ signs.
4. Compile the pattern once (re.compile or Pattern.compile) when validating many inputs. Avoid nested quantifiers such as (a+)+: on near-miss input they cause catastrophic backtracking, which takes exponential time in backtracking engines.
5. State the limit: a regex checks format, not deliverability. In production, the only real check is sending a confirmation message.

Follow-up

• How would you extract every email address from a block of text instead of validating one string?
• Can you validate the same format without regex, by hand? (Split on '@' exactly once, then check each label.)
• Why can't a regex alone reject a date like 2024-02-30, and what would you add?

Complete medium-difficulty coding exercises in Python or Java during timed assessments.

Medium · Coding and Algorithms

Approach

1. Read the constraints first and turn them into a complexity budget. n up to about 10^5 needs O(n log n) or better, while n up to about 20 allows 2^n subsets. Choose the algorithm before typing.
2. Map the problem to a known pattern: a hash map for complement lookups (two-sum), two pointers on sorted input, a sliding window for contiguous ranges, prefix sums for range totals, binary search on the answer for monotone feasibility, and a heap for top-k in O(n log k).
3. Know the library calls cold. In Python: collections.Counter, defaultdict, deque, and heapq (a min-heap only, so negate keys for a max-heap). In Java: HashMap, ArrayDeque, PriorityQueue with a comparator, and Arrays.sort.
4. Guard against platform failure modes. In Java, use long when sums or products can pass 2^31 - 1. For large stdin input, read with sys.stdin in Python or BufferedReader in Java. Check output format character for character.
5. Before submitting, run the boundary cases yourself: an empty or single-element input, all duplicates, negative numbers and the maximum size. A hidden test failing on these is the usual cause of partial scores.

Follow-up

• Your solution passes the sample tests but times out on hidden ones: what do you check first?
• How would this solution change if you had to write it in Java instead of Python?
• What is the space complexity, and can you bring it down to O(1) extra?

Optimize a provided code snippet for better time and space complexity.

Medium · Coding and Algorithms

Approach

1. Read the snippet and state its current complexity before changing anything. Point to the exact line that dominates, usually a nested loop or a linear search inside a loop.
2. Apply the standard rewrites and name each one's cost. Membership tests on a list inside a loop become a set or HashSet (O(1) average). Repeated recomputation becomes memoization or a prefix-sum array. Pairwise comparisons often become sort plus two pointers, O(n log n).
3. Spot hidden linear costs: list.pop(0) and list.insert(0, x) in Python are O(n), so use collections.deque. String += in a loop should be ''.join or StringBuilder. In Java, ArrayList.remove(0) shifts the whole list.
4. Treat space as part of the trade-off. A hash set buys time with O(n) memory. A generator or streaming pass avoids building a full intermediate list. In-place updates save memory but change the caller's data.
5. Prove the new version is still correct. Keep the original as an oracle and compare outputs on random and edge-case inputs, then restate the before and after Big-O.

Follow-up

• The loop makes one database query per item: how would you remove the N+1 pattern?
• When would you leave the slower version in place instead of optimizing it?
• How would you confirm with a profiler (cProfile, or a Java profiler) that this line is really the hot spot?

Answer fundamental questions regarding operating systems, process management, and memory allocation.

Medium · Core Computer Science and Technical Fund

Approach

1. Process vs thread: a process has its own virtual address space. Threads in one process share the heap and globals but each has its own stack and registers, so switching between threads is cheaper and shared data needs synchronization.
2. Scheduling: compare FCFS (convoy effect), SJF (lowest average waiting time but can starve long jobs), round robin (fairness depends on the time quantum) and priority scheduling (starvation, fixed by aging).
3. Deadlock: name the four Coffman conditions (mutual exclusion, hold and wait, no preemption, circular wait), since breaking any one prevents it. In code, the usual fix is a global lock ordering or tryLock with a timeout. The Banker's algorithm is the textbook avoidance method.
4. Memory: stack vs heap allocation, paging and virtual memory, and page faults. Thrashing is when the working set exceeds physical memory. Internal fragmentation is wasted space inside allocated blocks; external fragmentation is scattered free space between them.
5. Tie it to the languages listed for the role. Java uses a tracing garbage collector. CPython uses reference counting plus a cycle collector. In standard CPython, the GIL stops threads from running Python bytecode in parallel, so CPU-bound work goes to multiprocessing.

Follow-up

• What is the difference between a mutex and a counting semaphore, and when would you use each?
• What happens to memory when a process calls fork()? (Copy-on-write pages.)
• What causes thrashing, and how would you notice it on a server?

Explain database indexing, normalization, and how to write optimized SQL queries.

Medium · Core Computer Science and Technical Fund

Approach

1. Indexing: a B-tree index turns a full scan into an O(log n) lookup plus a range walk. A composite index on (a, b) follows the leftmost-prefix rule: it serves filters on a, or on a and b, but not on b alone. Every index slows writes and takes storage.
2. Clustered vs non-clustered: a clustered index sets the physical order of the table's rows, so there is only one (the primary key in InnoDB). A non-clustered index is a separate structure that points back to the row, which can cost an extra lookup unless the index covers the query.
3. Say what makes an index unusable: wrapping the column in a function (YEAR(created_at) = 2024; rewrite it as a date range), a LIKE pattern that starts with %, implicit type conversion, or a predicate so unselective that a scan is cheaper.
4. Normalization: 1NF has atomic values, 2NF has no partial dependency on part of a composite key, 3NF has no transitive dependency between non-key columns. Denormalize on purpose for read-heavy reporting, and accept the update cost.
5. Query tuning: read the plan with EXPLAIN (EXPLAIN ANALYZE in PostgreSQL), select only the columns you need, filter before joining and aggregating, join on indexed keys, and replace per-row correlated subqueries with a join or a window function.

Follow-up

• Write the query for the second-highest salary per department. (DENSE_RANK() OVER (PARTITION BY dept ORDER BY salary DESC) = 2.)
• What is the difference between WHERE and HAVING, and when does it matter for performance?
• The table has an index on the filtered column but the plan still shows a full scan: why might that be?

Why do you want to join Abzooba as a Software Engineer?

Medium · Behavioral and Managerial

Approach

1. Treat this as a motivation question, not a technical one. The answer needs three parts: what attracts you to the work, evidence from your own background that fits it, and what you want to learn there.
2. Anchor the first part on what candidates describe about the role: building data-driven applications and analytics systems for enterprise clients, in work that mixes backend software with data engineering. Check the company's public material yourself and cite only what you can back up.
3. Connect it to a specific project of yours, such as a SQL-heavy backend, a data pipeline, or a Java or Python service, and say in the first person what you did and why you want more of that work.
4. Avoid answers that would fit any employer, like praise for the company, salary, or 'it is a great opportunity'. They show no research.
5. Keep it to about four or five sentences, and end with one sincere question about the team's current work.

Follow-up

• What do you know about the kind of projects this team delivers for its clients?
• Where do you want to be in a few years, and how does this role get you there?
• Why this role rather than a pure data science or a pure backend position?

Explain the core principles of object-oriented programming and how you apply them in your projects.

Medium · Core Computer Science and Technical Fund

Approach

1. Define the four principles in one line each, with a concrete example from your own project. Encapsulation: private state behind methods that protect invariants. Abstraction: callers depend on an interface, not the implementation. Inheritance: an is-a relationship that reuses behaviour. Polymorphism: one call resolves to different implementations.
2. Separate the two kinds of polymorphism in Java. Overloading is resolved at compile time from the argument types. Overriding is resolved at runtime by dynamic dispatch on the object's actual class.
3. Prefer composition over inheritance and say why. Deep hierarchies create the fragile base class problem, and a subclass that breaks its parent's contract violates Liskov substitution (the Square-extends-Rectangle example).
4. Cover the language specifics. A Java interface vs an abstract class: since Java 8, interfaces can have default methods but still hold no instance state. Python has no access modifiers: a single underscore is a convention, and a double underscore triggers name mangling, not true privacy.
5. Close with one class from your project, which principle it applies, and what would have broken without it. That shows you apply OOP rather than recite it.

Follow-up

• Which design patterns would you use to decouple a tightly bound module? (Dependency injection, strategy, observer, adapter: say what each separates.)
• When would you choose an abstract class over an interface?
• Give an example where inheritance made your code harder to change.

Walk through foundational machine learning or data analytics concepts if applicable to the role.

Medium · Core Computer Science and Technical Fund

Approach

1. Start with the split: supervised learning (labelled data, as in regression and classification) vs unsupervised (clustering such as k-means, dimensionality reduction such as PCA). Give one example of each from a data-heavy application.
2. Explain overfitting through the bias-variance trade-off. Detect it as low training error with high validation error. Fix it with more data, simpler models, or regularization: L2 shrinks weights, while L1 can drive weights to exactly zero, so it also selects features.
3. Evaluation: keep separate train, validation and test sets, or use k-fold cross-validation. On imbalanced classes, accuracy misleads, so report precision, recall, F1 or ROC-AUC, and say which error costs more.
4. Name data leakage explicitly: fit scalers and imputers on the training split only, and never let future data inform a time-ordered prediction.
5. For analytics concepts, cover mean vs median under skew, handling missing values (drop, impute, or flag them), and a group-by aggregation in SQL or pandas. Keep the depth at a software engineer level unless asked to go further.

Follow-up

• For fraud detection, would you favour precision or recall, and why?
• How would you tell whether a model is overfitting, and what would you try first?
• How is logistic regression different from linear regression?

Design a basic system or workflow based on a given set of functional requirements.

Medium · System Design and Architecture

Approach

1. Turn the requirements into a short list of functional requirements (what users do) and non-functional ones (expected scale, latency, consistency). Confirm the list before drawing anything.
2. Name the entities and the API. For a task management app: users, projects and tasks, with endpoints like POST /tasks, PATCH /tasks/{id} and GET /tasks?assignee=&status= with pagination.
3. Sketch the data model and the indexes that serve the main reads, such as an index on tasks(assignee_id, status). Then draw the components: client, stateless API service, relational database, and a queue with a worker for slow or scheduled jobs like due-date reminders.
4. Walk one request end to end, including validation, the write, and what the client sees on failure. Then state one trade-off you made, such as computing counts on read versus maintaining them on write.
5. Close with the limits: what you left out of scope and what you would add first as usage grows (caching hot reads, read replicas, moving notifications off the request path).

Follow-up

• Two users edit the same task at once: how do you stop one update from silently overwriting the other? (Optimistic locking with a version column.)
• How would you add email reminders an hour before a task is due?
• How does the design change if one project has hundreds of thousands of tasks?

Discuss how to structure database tables and relationships for a new application feature.

Medium · System Design and Architecture

Approach

1. List the entities the feature needs and the cardinality between each pair. One-to-many puts a foreign key on the many side. Many-to-many needs a junction table, for example task_tags(task_id, tag_id) with a composite primary key.
2. Encode the rules as constraints, not just application checks: NOT NULL, UNIQUE (such as one email per user), CHECK, and foreign keys with a chosen ON DELETE behaviour (CASCADE, RESTRICT or SET NULL). Say why you chose each.
3. Normalize to 3NF first so every fact lives in one place. Then denormalize only where a known read path needs it, such as a cached comment count, and say how it stays correct.
4. Index the foreign key columns and the columns behind the feature's main queries. Add created_at and updated_at columns, and decide between soft delete (a deleted_at column) and hard delete.
5. Walk one or two of the feature's queries against the schema to show it supports them without awkward joins or full scans.

Follow-up

• How would you add a NOT NULL column to a large live table without downtime? (Add it nullable, backfill in batches, then add the constraint.)
• How would you store a hierarchy such as nested comments or subtasks? (A parent_id column with a recursive CTE, or a closure table.)
• Would you store a status as an enum, a string, or a lookup table, and why?

Explain how you would approach scaling a backend service to handle increased load.

Medium · System Design and Architecture

Approach

1. Measure before scaling: find the bottleneck from metrics (p95 and p99 latency, CPU, database time, error rate). Adding servers does nothing if the database is saturated.
2. Make the app tier stateless so it scales horizontally behind a load balancer: move sessions to a shared store or use signed tokens, and add health checks so failed instances leave the pool.
3. Reduce database load in order of cost: fix slow queries and indexes, add connection pooling, use a cache-aside layer with TTLs and explicit invalidation, then add read replicas. Shard only when writes outgrow one primary, because it complicates cross-shard queries.
4. Take slow work off the request path: put emails, reports and data processing on a queue handled by workers, and return quickly to the caller. Serve static assets from a CDN.
5. Protect the service under overload with rate limiting, timeouts and backpressure. Run a load test before and after each change to confirm the gain.

Follow-up

• A popular cache key expires and every request hits the database at once: how do you prevent the stampede? (Request coalescing, or TTLs with random jitter.)
• After moving reads to a replica, a user cannot see the change they just saved: why, and how do you fix it?
• What do you do when writes, not reads, are the bottleneck?

Talk through the architecture of a previous project you built or maintained.

Medium · System Design and Architecture

Approach

1. Open with the problem and the users in two sentences. Then draw one diagram of the components and the data flow between them, and walk a single request or data record through it.
2. Mark clearly which parts you built yourself and which you inherited or shared. Candidates report technical questioning built on the projects listed on their resume, so expect follow-ups on any part you claim.
3. Pick one or two decisions and give the alternatives you rejected and why. For example, PostgreSQL over a document store because the data was relational, or a batch job over streaming because results could be an hour old.
4. Give real numbers if you have them (data volume, request rate, latency, run time), and say how you measured them. Do not invent scale.
5. End with a limitation or a failure you hit, how you fixed it, and what you would change if you rebuilt it.

Follow-up

• What would break first if usage grew ten times?
• Why that database or framework rather than the alternative you mentioned?
• How was the project tested and deployed, and what was your part in that?

Describe how different components of a software application communicate with one another.

Medium · System Design and Architecture

Approach

1. Start inside one application: layers (controller, service, repository) talk through method calls on interfaces, and decoupled parts can use in-process events (the observer pattern) instead of direct calls.
2. Between services, compare synchronous calls: REST over HTTP with JSON (simple, human-readable) vs gRPC with Protocol Buffers over HTTP/2 (typed contracts, smaller payloads, streaming). Both couple the caller to the callee's availability and latency.
3. Then cover asynchronous messaging: a message queue for work distribution, or publish-subscribe over a log such as Kafka for fan-out. It decouples timing and absorbs spikes, but it adds eventual consistency and makes requests harder to trace.
4. Make calls reliable with timeouts on every remote call, retries with exponential backoff and jitter, idempotency keys so a retry does not duplicate a write, and a circuit breaker to stop calling a failing dependency.
5. Mention delivery semantics: most brokers give at-least-once delivery, so consumers must be idempotent. Say that two services sharing one database couples their schemas, and call it a trade-off rather than a pattern to default to.

Follow-up

• The downstream service is down for ten minutes: what happens to the requests in your design?
• How do you make sure a database write and its event are not lost or duplicated? (The transactional outbox pattern plus idempotent consumers.)
• When would you pick gRPC over REST, or a queue over a direct call?

Discuss computer networking basics, including protocols and basic troubleshooting concepts.

Medium · Core Computer Science and Technical Fund

Approach

1. Lay out the layers you will reason with, TCP/IP or OSI, and place the common protocols: Ethernet, IP, TCP and UDP, then DNS, HTTP and TLS at the top.
2. TCP vs UDP: TCP is connection-oriented (SYN, SYN-ACK, ACK handshake) with ordered, retransmitted delivery and congestion control. UDP sends datagrams with none of that, so DNS lookups and real-time media use it to save latency.
3. Walk through typing a URL and pressing enter: DNS resolution (browser and OS caches, then a resolver), the TCP handshake, the TLS handshake with certificate check for HTTPS, the HTTP request and response with status codes, and then rendering.
4. Know the HTTP basics: GET, PUT and DELETE are idempotent and POST is not. Know the status classes (2xx success, 3xx redirect, 4xx client error, 5xx server error) and the difference between 401 and 403.
5. Troubleshoot bottom-up and say what each step rules out. ping checks reachability (ICMP may be blocked). nslookup or dig checks DNS. traceroute finds the path. nc or curl -v checks the port and the HTTP layer. Then check the firewall and the service logs.

Follow-up

• Why does 'connection refused' mean something different from a timeout? (A RST from a host with nothing listening vs packets silently dropped.)
• How does the browser decide to trust a server's TLS certificate?
• What does HTTP/2 multiplexing fix compared with HTTP/1.1 keep-alive?

Suggested practice checklist

Seven days built on the four reported stages: first the project inventory, then coding for the online test, SQL and databases, computer science fundamentals, design, and finally behavioral stories and a mock.

Day 1 — Map the loop and inventory your projects

• Write the four reported stages (Resume Screening, Online Assessment, Technical Interviews, HR Discussion) on one page and mark which topic in each you are weakest at
• List every project on your resume with its stack, your contribution and one result, and choose the two you will narrate in depth
• Set up a plain editor in Java or Python with no autocompletion, because candidates are told to be ready to write code that way

Deliverable: A one-page loop map plus a project inventory with two projects marked for deep preparation.

Day 2 — Strings, substrings and regular expressions

• Solve three substring or string problems, for example longest substring without repeating characters and anagram detection, using a sliding window or counting array, and write time and space for each
• Write an email validator with a regular expression using full-string matching, then a test table of at least ten valid and invalid addresses
• Redo one of the solutions with no pattern or library help and note which edge cases you missed the first time

Deliverable: Three working string solutions with complexity notes and an email validator with its test table.

Day 3 — Graph traversal and code optimization

• Implement BFS and DFS over an adjacency list, then find a path between two nodes and count connected components in a graph with disconnected parts
• Take a quadratic snippet (for example a nested-loop duplicate or pair search) and optimize it with a hash set or sort, stating the time and space change
• Do one timed medium problem in Python or Java as in the online assessment, and write down the first bug you hit

Deliverable: Working traversal code with a component count, one before-and-after optimization with complexities, and one timed solution.

Day 4 — SQL and database design

• Write queries using joins, GROUP BY with HAVING and a subquery against a small orders and customers schema, then rewrite one to remove the subquery
• Explain clustered versus non-clustered indexes, and pick an index for a slow filter-and-sort query, checking it with an execution plan
• Normalize a flat table of tasks, users and projects into third normal form and sketch the tables and foreign keys for a task management feature

Deliverable: A set of tested queries, one index recommendation with its reasoning, and a normalized schema diagram.

Day 5 — Computer science fundamentals

• Write a one-page explanation of the four object-oriented principles with an example from your own project for each, plus one design pattern for decoupling a module
• Explain process versus thread, scheduling, paging, and the four conditions for deadlock with a prevention strategy
• Trace what happens when a URL is typed into a browser: DNS, TCP, TLS, HTTP request and response, and name two troubleshooting steps for each layer
• Write a short glossary of basic machine learning and analytics terms (train versus test data, overfitting, precision and recall) for questions about them

Deliverable: Four one-page spoken-answer outlines: object-oriented programming, operating systems, networking, and basic machine learning.

Day 6 — Basic design and project architecture

• Design a basic task management backend: entities, tables, REST endpoints and how a request flows from client to database
• List the order in which you would scale it: profiling, indexes, caching, read replicas, background queues and horizontal scaling, naming what each fixes
• Compare synchronous calls (HTTP or REST) with asynchronous messaging between components, and state when you would choose each
• Rehearse the architecture of your main resume project aloud with a diagram, including one decision you would now make differently

Deliverable: A design sketch with endpoints and schema, a scaling checklist, and a recorded architecture walkthrough of your own project.

Day 7 — Behavioral stories and a full mock

• Write STAR outlines for the project, deadline, debugging and design-collaboration prompts, each stating the decision you made and the result
• Write a short, factual answer to why you want to join Abzooba as a Software Engineer, using only what you can verify about the role and your own goals
• Run a mock: one timed coding problem aloud, one SQL question, then one behavioral story, and note where you went silent or vague

Deliverable: Four STAR outlines, one motivation answer, and a mock-interview note listing three things to fix.

Project and teamwork stories

Candidates report that the final stages discuss fit within the team and company culture, and that managerial and HR conversations cover past project work, deadlines, debugging, collaboration and motivation. For a software engineer this means stories with real technical content: a decision you made, what you checked, what it cost and how you worked with others. Prepare each story so it can survive a follow-up about the technical details underneath it.

1. Why do you want to join Abzooba as a Software Engineer?
2. Tell me about code review feedback you disagreed with and what you did about it.

Walk me through a complex project you worked on during your internship or previous role.

Medium · Behavioral and Managerial

Approach

1. Choose one internship or work project where you owned a real decision. Open with the situation in two sentences: what the system did, who used it, and your role. Then spend most of the answer on the reasoning behind your choices.
2. Describe the architecture so the listener can picture it: language, framework, database and schema, how components communicated, and where the data came from. Because candidates report that technical questions are built on resume projects, expect any layer you mention to be drilled.
3. Walk through one hard technical decision, such as a schema design, an algorithm change or a query optimization. Name the alternatives you considered and why you rejected them, then give the result with a number you actually measured (query time, error rate, test coverage), not an estimate.
4. Say what you would change now, and distinguish clearly between work done by you and by the team. The sinking mistake is describing a project at feature level ('we built a dashboard') so that any follow-up exposes that you never touched the internals.

Follow-up

• Why did you choose that database or schema, and what would break if the data grew by ten times?
• Which part of the system did you not write, and how did you integrate with it?
• What bug cost you the most time on this project and how did you finally find it?

How do you handle tight deadlines or conflicting priorities when developing software?

Medium · Behavioral and Managerial

Approach

1. Use a concrete situation with two real competing demands, for example a release date and a production bug, or two teammates each needing your review. State the date and what was at risk.
2. Show how you triaged: what was blocking other people, what had the larger user or client impact, what could safely wait, and what the smallest correct version of each was. Name the technique, even if it is as simple as listing tasks by impact and effort.
3. Explain the communication: whom you told, what you offered (a reduced scope, a different order, a later date for one item) and what they agreed to. Prioritization is a negotiation, so show that you raised the conflict early rather than absorbing it silently.
4. Close with what shipped, what you deliberately deferred and how you tracked it (a follow-up ticket, a test added later). The common failure is the 'I worked late and did everything' answer: it shows no judgment, and a rushed change without tests is a quality risk you should address directly.

Follow-up

• What exactly did you cut, and who had to agree to that?
• What would you do if two managers gave you conflicting priorities and neither would move?
• How did you make sure the rushed work did not introduce a bug?

Describe a time when you had to debug a difficult issue under pressure.

Medium · Behavioral and Managerial

Approach

1. Frame the incident first: what broke, who was affected, and what the pressure was (a client demo, a deployment, a failing build). Keep it to a few sentences so the debugging sequence gets the time.
2. Narrate the sequence in order: reproduce or narrow the failure, check what changed recently, read the logs and error output, form one hypothesis at a time, and use a test, a debugger or a bisect to confirm or reject it. For a data application, say whether you looked at the query, the data or the code.
3. Separate the mitigation from the root cause. If you rolled back, added a guard or patched the symptom to restore service, say so, then explain how you found the underlying defect and verified the fix with a test that fails before and passes after.
4. Say how you communicated while under pressure (short status updates, an honest estimate) and what you added afterwards: a regression test, a log line, an alert or a review checklist. The sinking mistake is a story where the fix was luck or a guess that nobody can verify.

Follow-up

• How did you confirm that was the root cause rather than a coincidence?
• What did you tell the stakeholders while you were still investigating?
• What test or monitoring did you add to stop it recurring?

How do you collaborate with team members when designing a technical solution?

Medium · Behavioral and Managerial

Approach

1. Pick a design where several options were credible, such as a schema layout, a sync or async integration, or how to split a module. State the options in a sentence each and your own role in the decision.
2. Show your process for collaborating: you wrote the options down (a short design outline, a diagram, a table of trade-offs), shared it with the engineers, data specialists or project manager who were affected, and asked for specific objections instead of general approval.
3. Describe a real disagreement and how it was settled with evidence: a quick prototype, a benchmark, a constraint from the client or a deciding criterion you all agreed on. Include one point where you changed your mind or conceded, because it shows you are open to feedback.
4. End with how the decision was recorded and executed: who built which part, how code review worked, and how you explained the outcome to a non-technical stakeholder if needed. The sinking mistake is a story where you either overruled everyone or just agreed with whoever spoke last.

Follow-up

• What was the strongest argument against your preferred option, and how did you respond?
• How did you handle review feedback that you believed was wrong?
• How would you explain that design decision to someone who is not an engineer?