Software Engineer Interview Questions 2026

Sample Answer

A stack follows Last-In-First-Out (LIFO) while a queue follows First-In-First-Out (FIFO). Use a stack for undo/redo operations, function call tracking, and expression parsing. Use a queue for task scheduling, BFS traversal, and message buffering. In practice, a stack is ideal when you need to reverse order or backtrack, while a queue is best when processing items in arrival order matters.

Sample Answer

Use Floyd's Tortoise and Hare algorithm: maintain two pointers, one moving one step and another moving two steps at a time. If there is a cycle, the fast pointer will eventually meet the slow pointer. This runs in O(n) time and O(1) space. To find the cycle's start node, reset one pointer to the head and advance both one step at a time until they meet again. This is significantly more efficient than using a hash set which requires O(n) extra space.

Sample Answer

Start with requirements: generate short URLs, redirect to original URLs, handle high read traffic, and track analytics. Use a base-62 encoding scheme on an auto-incrementing ID or a hash function for URL generation. Store mappings in a key-value store like Redis for fast lookups with a relational database as the persistent store. Add a caching layer with LRU eviction, use consistent hashing for horizontal scaling, and implement rate limiting. For analytics, use an append-only log or event stream. Discuss trade-offs between hash collisions vs sequential IDs, and eventual consistency vs strong consistency.

Sample Answer

QuickSort averages O(n log n) but degrades to O(n^2) in worst case; great for general-purpose sorting with good cache locality. MergeSort guarantees O(n log n) and is stable, making it ideal for linked lists or when stability matters. HeapSort is O(n log n) with O(1) space but poor cache performance. For nearly sorted data, Insertion Sort runs in O(n). TimSort, used in Python and Java, combines MergeSort and Insertion Sort and performs best on real-world data with natural runs. Choose based on data characteristics, stability needs, and memory constraints.

Sample Answer

A database index is a data structure (typically a B-tree or hash) that speeds up data retrieval at the cost of additional storage and slower writes. Add indexes on columns frequently used in WHERE clauses, JOIN conditions, and ORDER BY statements. Avoid indexing columns with low cardinality, tables with frequent writes and few reads, or very small tables where a full scan is faster. Composite indexes should follow the leftmost prefix rule. Monitor query execution plans using EXPLAIN to validate index effectiveness and watch for index bloat over time.

Sample Answer

Use WebSockets for persistent bidirectional connections. Each user connects to a WebSocket server; messages are published to a message broker like Redis Pub/Sub or Kafka. For group chats, maintain a membership table and fan out messages to all online members. Store messages in a database partitioned by conversation ID with pagination. Handle offline users with push notifications and message queuing. For horizontal scaling, use a load balancer with sticky sessions or a shared session store. Consider eventual consistency for read receipts and typing indicators. Add end-to-end encryption for security.

Sample Answer

SOLID stands for Single Responsibility, Open-Closed, Liskov Substitution, Interface Segregation, and Dependency Inversion. The Single Responsibility Principle states that a class should have only one reason to change. For example, instead of a User class that handles authentication, email sending, and database persistence, split it into UserAuthenticator, EmailService, and UserRepository. Each class has one clear responsibility, making the code easier to test, maintain, and extend without unintended side effects.

Sample Answer

JavaScript uses mark-and-sweep garbage collection. The GC starts from root objects (global scope, stack references) and marks all reachable objects; unreachable objects are swept and freed. Common memory leak causes include: forgotten event listeners not being removed, closures retaining references to large objects, detached DOM nodes still referenced in JavaScript, global variables accumulating data, and timers (setInterval) not being cleared. Use Chrome DevTools Memory panel to take heap snapshots and identify retained objects. WeakRef and WeakMap help avoid accidental retention of objects.

Sample Answer

SQL databases (PostgreSQL, MySQL) enforce schemas, support ACID transactions, and excel at complex queries with joins. NoSQL databases (MongoDB, DynamoDB, Redis) offer flexible schemas, horizontal scalability, and are optimized for specific access patterns. Choose SQL for applications with complex relationships, financial data requiring strong consistency, or when your query patterns are varied. Choose NoSQL when you need to scale writes massively, have well-defined access patterns, or work with semi-structured data like user profiles or event logs. Many modern systems use both (polyglot persistence).

Sample Answer

Use dynamic programming with a 2D table where dp[i][j] represents the LCS length of the first i characters of string1 and first j characters of string2. If characters match, dp[i][j] = dp[i-1][j-1] + 1. Otherwise, dp[i][j] = max(dp[i-1][j], dp[i][j-1]). To reconstruct the actual subsequence, backtrack through the table. Time complexity is O(m*n) and space can be optimized to O(min(m,n)) using rolling arrays. This pattern appears frequently in diff algorithms, DNA sequence alignment, and version control systems.

Sample Answer

A monolith is a single deployable unit with shared memory and database, offering simplicity, easier debugging, and strong consistency. Microservices decompose the system into independently deployable services, each owning its data, enabling independent scaling, technology diversity, and team autonomy. Trade-offs include operational complexity (service discovery, distributed tracing, eventual consistency), network latency, and data consistency challenges. Start with a modular monolith and extract services at natural boundaries when team size, deployment frequency, or scaling requirements demand it. Premature microservices is a common anti-pattern that adds complexity without benefits.

Sample Answer

REST uses resource-based URLs with HTTP methods (GET, POST, PUT, DELETE) and returns fixed data structures. GraphQL uses a single endpoint where clients specify exactly what data they need through queries. REST is simpler, well-cached by HTTP infrastructure, and sufficient for most CRUD apps. GraphQL excels when clients need flexible data fetching (mobile apps needing different data than web), reducing over-fetching and under-fetching. Trade-offs include GraphQL's complexity in caching, potential for expensive queries (N+1 problem), and the need for query complexity limits. Many teams use REST for public APIs and GraphQL for internal frontend consumption.

Sample Answer

Write code with dependency injection so external services can be mocked. Follow the testing pyramid: many unit tests (fast, isolated, testing business logic), fewer integration tests (testing component interactions and API contracts), and minimal end-to-end tests (critical user flows). Use TDD for complex logic where requirements are clear. Test edge cases, error paths, and boundary conditions. For frontend, test component behavior rather than implementation details using Testing Library patterns. Aim for meaningful coverage, not 100% line coverage. Critical business logic should have near-complete coverage; UI layout code less so.

Sample Answer

Start with requirements: per-user or per-IP limiting, fixed window vs sliding window, distributed system support. The token bucket algorithm allows bursty traffic while maintaining average rate limits. The sliding window counter provides more accurate rate limiting. For a distributed system, use Redis with atomic operations (INCR + EXPIRE) for the counter. Handle race conditions with Lua scripts for atomicity. Return proper HTTP 429 status codes with Retry-After headers. Consider different rate limits for different API endpoints and user tiers. Discuss trade-offs between accuracy, memory usage, and latency. Add monitoring to detect abuse patterns.

Sample Answer

HTTPS uses TLS (Transport Layer Security) to encrypt communication between client and server. The process involves: the client initiates a TLS handshake, the server presents its SSL certificate (verified against trusted CAs), they negotiate an encryption algorithm and exchange keys using asymmetric encryption, then switch to faster symmetric encryption for data transfer. HTTPS prevents eavesdropping, man-in-the-middle attacks, and data tampering. It is essential for protecting user credentials, session tokens, and sensitive data. Modern browsers flag HTTP sites as insecure, and HTTPS is required for HTTP/2, service workers, and many Web APIs.