0% found this document useful (0 votes)
336 views4 pages

ResNet SDE Interview Guide

This include the all preparation and details about the resnet solutions.

Uploaded by

cyberknightshack
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
0% found this document useful (0 votes)
336 views4 pages

ResNet SDE Interview Guide

This include the all preparation and details about the resnet solutions.

Uploaded by

cyberknightshack
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd

ResNet Solutions – SDE Interview Pack

Last updated: 2025-09-06

1) Snapshot
• Company: ResNet Solutions (India) — software/app development,
UI/UX, AI/ML solutions, landing pages.
• Typical entry path: Internship → full-time SDE (based on perfor-
mance).
• Indicative perks seen in public postings: Internship stipend
~�20,000/month; full-time ~�6–8 LPA + benefits (health cover, certifica-
tion support, flexible leave).
Use this pack as a realistic guide; specific steps can vary by
team/role.

2) Step-by-step Interview Process (Typical)


1. Application & Resume Screen (Day 0–3)
• Submit resume + portfolio/GitHub.
• What they look for: clear projects, relevant stack (JS/TS, Re-
act/Node, Python/Java), internships, ML exposure if applying to
ML/SDE track.
2. Online Coding Screen (45–90 mins)
• Platform: shared doc/HackerRank/Google Form (varies).
• Format: 1–2 DSA problems + 5–15 MCQs (OOP, DBMS, OS, Git).
• Bar: clean code, edge cases, time/space complexity.
3. Technical Round #1 – DSA + Core CS (45–60 mins)
• Topics: arrays/strings, hashing, stacks/queues, trees/graphs,
OOP pillars, DB normalization/indexes/transactions, OS basics
(process/thread, deadlocks), networking (HTTP/REST).
• Expect 1 coding problem + 10–15 mins CS theory.
4. Technical Round #2 – Projects & System/Design (45–60 mins)
• Deep dive into your best project (problem → design → trade-offs →
testing → metrics).
• Lite system design: build an API/service, schema design, caching,
pagination, auth basics, logging/monitoring.
• For ML/SDE track: pipelines, model serving, data versioning, eval-
uation, failure modes.
5. Managerial/HR (20–30 mins)
• Behavioral, teamwork, ownership, timeline, compensation, joining
window.
6. Offer & Onboarding

1
SRI

SRI-2025
• Internship offer with performance pathway to full-time SDE; time-
lines typically quick (1–2 days from last round).

3) Representative “Previous Year” Style Practice Ques-


tions
These mirror what similar companies ask and align with ResNet’s
stated stacks. Use them like a mock paper.

A) Coding (10)
1. Longest Substring Without Repeating Characters — return length.
Target: O(n) using sliding window.
2. Min Stack — push/pop/top/getMin in O(1). Use auxiliary stack or
encode deltas.
3. Top K Frequent Elements — array of ints, return k most frequent.
Heap or bucket sort.
4. Meeting Rooms II — min rooms required given intervals. Sweep-line
with min-heap.
5. Clone Graph — deep copy of connected undirected graph. DFS/BFS
with map.
6. LRU Cache — get/put O(1). HashMap + doubly-linked list.
7. Rotting Oranges — minutes to rot all; BFS multi-source.
8. Kth Smallest in BST — inorder traversal or iterative stack.
9. Serialize/Deserialize Binary Tree — BFS with sentinels.
10. Word Ladder — length of shortest transformation; BFS with neighbor
generation.

B) SQL (8)
1. Nth highest salary (dense vs sparse ranks) — ROW_NUMBER, RANK,
DENSE_RANK differences.
2. Orders table: total revenue per day; filter days with revenue > avg rev-
enue.
3. Customers & Orders: find customers with no orders in last 90 days (LEFT
JOIN + date range).
4. Top 3 products by revenue per category (window functions + partition).
5. Detect duplicates by (email, phone) and keep latest record (CTE +
ROW_NUMBER).
6. Sessions table: DAU, 7-day rolling active users.
7. Find users who purchased all items in a set (“relational division”).
8. Soft deletes: return latest active version per id (SCD Type-2 pattern).

2
SRI

SRI-2025
C) Core CS (20 short Q/A)
1. OOP pillars and a 5-line example demonstrating polymorphism.
2. HashMap collisions strategies & complexity in best/worst cases.
3. Thread vs Process; context switch cost; why async IO.
4. Deadlock conditions & one practical prevention method.
5. HTTP 1.1 vs HTTP/2; what is idempotency in REST.
6. ACID; when to use read-committed vs repeatable-read.
7. Index types (B-Tree vs Hash vs GIN); composite index order rule-of-
thumb.
8. CAP theorem in plain words; where does a typical microservice sit.
9. Caching layers: client, CDN, reverse proxy, application; invalidation
strategies.
10. Message queues: at-least-once vs exactly-once semantics.
11. Docker basics; image vs container.
12. Kubernetes: service vs ingress; readiness vs liveness probe.
13. JWT pitfalls; when to rotate secrets.
14. Rate limiting strategies (token bucket, leaky bucket); where to enforce.
15. Testing pyramid; unit vs integration vs e2e.
16. CI/CD essentials; feature flags vs long-lived branches.
17. Time/Space complexity for common operations in ArrayList vs
LinkedList.
18. Binary search pitfalls (overflow in mid); lower_bound/upper_bound
variants.
19. UTF-8 basics; what happens on invalid byte sequences.
20. Git rebase vs merge; when to squash.

D) ML Track (Optional, 15)


1. ReLU vs GELU; when does tanh still make sense?
2. BatchNorm vs LayerNorm; where used in CNNs vs Transformers.
3. What is the bias–variance tradeoff? example.
4. Precision/Recall/F1; imbalanced datasets handling.
5. ROC–AUC vs PR–AUC; when to prefer which.
6. KNN time complexity; tricks to speed up (KD-Tree/FAISS).
7. SVM kernel trick in one paragraph.
8. CNN parameter count formula for conv layer.
9. Data leakage examples and prevention.
10. K-fold CV vs stratified CV; leakage with time series.
11. Train/serve skew; feature store idea.
12. VAE reparameterization trick intuition.
13. Regularization: L1 vs L2; effect on weights.
14. Model serving: batch vs real-time; A/B vs canary.
15. Monitoring ML in prod: drift, latency, SLOs.

3
SRI

SRI-2025
E) Behavioral (12)
• Ownership example where you fixed a production bug.
• A time you disagreed with a teammate and how you resolved it.
• Handling tight deadlines.
• Prioritization when everything is high priority.
• Most impactful project and measurable outcomes.
• A failure and what you learned.
• Explaining a complex topic to a non-technical stakeholder.
• Working with ambiguous requirements.
• Mentoring or being mentored.
• Navigating trade-offs: performance vs simplicity.
• Dealing with flaky tests.
• Building trust in a new team.

4) Quick Checklists
Coding round: read constraints, state approach + complexity first, write tests,
handle edge cases (empty, 1-length, duplicates, large N).
Project round: problem statement, design, tech choices, schema, APIs, testing,
performance, monitoring, metrics, what you’d improve next.
Behavioral: STAR (Situation, Task, Action, Result) with numbers (latency
↓40%, crashes ↓70%, revenue ↑12%).

5) One-Week Sprint Plan


• D1: Arrays/Strings/Hashing + 2 SQL sets.

• D2: Trees/Graphs + indexes/joins theory.

• D3: System design mini-problems (API + schema + caching).

• D4: Projects narrative + resumes/GitHub polish.

• D5: Mock interview + review weak areas.

• D6: ML section (if relevant) + behavioral stories.

• D7: Full-length mock + rest.


Good luck — you’ve got this!

4
SRI

SRI-2025

Common questions

Powered by AI

Candidates should prepare for a system design interview at ResNet Solutions by focusing on the problem statement and design choices. They should be ready to explain their technical choices, schema design, and considerations for caching, APIs, performance, and monitoring . Furthermore, candidates should highlight improvements they would make next and prepare to discuss metrics and testing strategies . It is crucial to understand how to handle APIs and services, including authentication, error handling, and logging .

The STAR method is effective in behavioral interviews as it helps structure responses clearly and cohesively. It stands for Situation, Task, Action, and Result. This method allows candidates to guide interviewers through a past experience logically: describing the Situation and Task to set the context, detailing the Actions taken to address the task, and concluding with the Result, emphasizing outcomes with quantifiable data where possible, such as improvements in latency or revenue . Using STAR ensures that candidates provide relevant and concise answers that highlight their problem-solving skills, leadership, and impact .

The reparameterization trick in variational autoencoders (VAEs) is crucial as it allows the gradient descent optimization to update the network parameters effectively. VAEs generate latent vector samples from a probability distribution, typically a Gaussian distribution, during training. Direct sampling introduces randomness, making backpropagation challenging. The reparameterization trick separates the randomness by expressing the sampled vector as a deterministic function of a non-random variable and a ~ standard-normal noise term, enabling gradients to be computed deterministically . This trick is necessary to train the VAE efficiently and ensure stable convergence of the latent variable model .

Understanding ACID properties in SQL interviews at ResNet Solutions is important as they ensure the reliability of database transactions. ACID stands for Atomicity, Consistency, Isolation, and Durability. Atomicity ensures that all parts of a transaction are completed successfully; if not, the transaction is aborted. Consistency ensures the database remains in a valid state before and after the transaction. Isolation means transactions are independent, and Durability ensures completed transactions are saved even in case of a system failure . Knowing when to use read-committed versus repeatable-read isolation levels is crucial for preventing common pitfalls like dirty reads and ensuring data integrity .

In technical interviews at ResNet Solutions, understanding the difference between threads and processes is critical. Threads are lightweight and share the same memory space, leading to lower context switch costs compared to processes which have separate memory space . To handle thread and process management effectively, candidates should be familiar with asynchronous I/O, which can help reduce blocking and improve efficiency in concurrent environments . Furthermore, comprehending the costs associated with context switching and ways to minimize it, such as by reducing the frequency of switching and optimizing thread usage, is important .

To manage trade-offs between performance and simplicity in projects, strategies involve assessing the project's requirements and prioritizing based on the impact and feasibility . Sometimes maintaining simplicity might mean using well-known, easy-to-maintain solutions that slightly underperform in cutting-edge terms, prioritizing developer productivity and lower maintenance costs . Implementing performance-critical features in isolated modules can allow a system to remain simple while enhancing certain capabilities . Regular code reviews and stakeholder feedback also help in maintaining an optimal balance, ensuring that simplicity does not overly compromise performance and vice versa . Prioritizing clear documentation and maintaining good test coverage are essential to facilitate future enhancements without deteriorating simplicity or performance .

Caching layers improve application performance by storing frequently accessed data closer to the user, which reduces load times and decreases the server load . Caching can occur at various layers, including the client, CDN, reverse proxy, and application. Invalidation strategies involve techniques such as time-based expiration, where the cache is automatically cleared after a certain period, and event-based invalidations, where the cache is cleared due to specific actions or updates in the database . Additionally, understanding cache refresh strategies, such as lazy loading and cache-aside, can be beneficial during technical discussions .

B-Tree indexes are versatile and suitable for range queries and full-field exact matches; their balanced tree structure provides efficient insertion and deletion operations . Hash indexes excel in scenarios that require fast lookups for exact matches but are limited in functionality since they do not support range queries . GIN (Generalized Inverted Index) indexes are beneficial for indexing composite types and arrays, particularly in full-text search applications where multi-valued keys are involved . The composite index order rule-of-thumb suggests placing columns with high cardinality at the front of the index to improve retrieval efficiency . Each index type is selected based on the application's query requirements and data characteristics .

The typical interview process for a software development engineer at ResNet Solutions starts with an application and resume review, focusing on clear projects and relevant technology stacks . It is followed by an online coding screen involving data structure and algorithm problems, and multiple choice questions on Computer Science fundamentals . The first technical round further tests data structures and algorithms along with core Computer Science concepts like operating systems and networking . The second technical round involves a deep dive into a candidate's project and includes system/design questions . This is followed by a managerial/HR interview delving into behavioral aspects and discussing timelines and compensation . The process concludes with an offer and onboarding, often with a quick turnaround time from the final interview .

HTTP/2 should be preferred over HTTP 1.1 in scenarios requiring better performance through multiplexing, which allows multiple requests to be sent simultaneously over a single TCP connection, reducing the overhead of multiple connections prevalent in HTTP 1.1 . HTTP/2 also employs binary framing and header compression, which reduces latency and improves page load times, making it suitable for applications with high user interactions and those requiring faster page rendering . Additionally, HTTP/2 is beneficial in reducing response times due to its prioritization and flow control mechanisms, making it ideal for web applications with complex data processing .

You might also like