Software Engineer Top 50 Q&A

Arrays have O(1) access time but O(n) insertion/deletion. Linked Lists have O(n) access but O(1) insertion/deletion (if position is known). Arrays are contiguous in memory.

A data structure that maps keys to values using a hash function. Collisions are handled via Chaining (linked lists in buckets) or Open Addressing (probing).

It describes the upper bound of an algorithm's complexity in terms of time or space as the input size grows. Common: O(1), O(log n), O(n), O(n log n), O(n²).

BFS (Breadth-First Search) uses a queue and explores layer by layer. DFS (Depth-First Search) uses a stack (or recursion) and explores as deep as possible before backtracking.

A divide-and-conquer algorithm that picks a pivot element and partitions the array such that elements smaller than the pivot are on the left and larger on the right.

A tree where each node has at most two children. The left child is smaller than the parent, and the right child is larger. Search is O(log n) on average.

A function calling itself. The base case is the condition that stops the recursion to prevent a stack overflow.

A queue where each element has a priority. Elements with higher priority are dequeued before lower ones. Typically implemented with a Heap.

An optimization technique for recursion where you store results of subproblems (Memoization) to avoid redundant calculations. Example: Fibonacci sequence.

Stack is LIFO (Last-In-First-Out). Queue is FIFO (First-In-First-Out).

Distributing incoming network traffic across multiple servers to ensure no single server is overwhelmed, improving availability and reliability.

Vertical scaling means adding more power (CPU, RAM) to an existing server. Horizontal scaling means adding more servers to your pool.

Storing frequently accessed data in a fast storage layer (like Redis or Memcached) to reduce the latency of future requests.

Monolith is a single unified unit. Microservices break the app into small independent services that communicate over a network (e.g., via APIs).

Consistency, Availability, and Partition Tolerance. A distributed system can only guarantee two out of the three simultaneously.

Breaking a large database into smaller, faster, more manageable parts called shards, distributed across multiple servers.

REST has fixed endpoints and structures. GraphQL allows clients to request exactly the data they need, reducing over-fetching and under-fetching.

An asynchronous communication protocol (like RabbitMQ or Kafka) where a sender puts a message on a queue, and a receiver processes it when ready.

Content Delivery Network. A system of distributed servers that deliver web content to users based on their geographic location to reduce latency.

Copying data from one database server (Master) to another (Slave) to improve read performance and provide data redundancy.

Encapsulation, Abstraction, Inheritance, and Polymorphism.

An interface only defines methods (what to do). An abstract class can have both method signatures and full implementations (how to do).

Single Responsibility, Open/Closed, Liskov Substitution, Interface Segregation, and Dependency Inversion.

A design pattern where an object receives its dependencies from the outside rather than creating them itself, improving testability and decoupling.

Overloading is having multiple methods with the same name but different parameters in the same class. Overriding is a subclass providing a specific implementation of a method defined in its parent class.

A design pattern that restricts a class to only one instance throughout the application.

Inheritance is an "is-a" relationship. Composition is a "has-a" relationship. Composition is generally preferred for flexibility.

A pattern used to create objects without specifying the exact class of the object that will be created.

Don't Repeat Yourself. Every piece of knowledge must have a single, unambiguous representation within a system.

You Ain't Gonna Need It. A principle that programmers should not add functionality until deemed necessary.

A distributed version control system that tracks changes in source code. It uses snapshots and allows branching/merging.

Merge creates a new commit that combines both branches. Rebase moves the base of a branch to a new starting point, resulting in a cleaner, linear history.

A platform for developing, shipping, and running applications in lightweight, isolated containers that package all dependencies.

Continuous Integration and Continuous Deployment. Automated processes to build, test, and deploy code changes to production frequently.

Unit tests a single component. Integration tests how components work together. E2E (End-to-End) tests the entire user flow.

Test-Driven Development. Writing the test before writing the code itself.

A cloud model (like AWS Lambda) where the provider manages the server infrastructure, and you only write the code (functions) that run in response to events.

SQL databases are relational and structured. NoSQL databases are non-relational, flexible, and often document-oriented (e.g., MongoDB).

A server that acts as an entry point for APIs, handling routing, security, rate limiting, and other cross-cutting concerns.

A standard protocol for authorization that allows third-party applications to grant limited access to user accounts on another service.

Check logs, monitoring dashboards, reproduce the issue in a staging environment, and apply a hotfix after testing.

Document it, prioritize it based on impact, and allocate time in each sprint to refactor and pay it down.

Problem-solving ability, adaptability, and clear communication.

Read documentation, build a small PoC, and learn as I go while leveraging existing engineering fundamentals.

Focus on how you communicated, listened to their perspective, and reached a technical compromise for the project's benefit.

A powerful tool for productivity (coding assistants, debugging) but requires human oversight for architecture, ethics, and security.

Look for logic errors, clean code compliance, security vulnerabilities, and provide constructive, kind feedback.

Choose one and explain its strengths (e.g., Python for its simplicity and libraries, or Java for its robust enterprise features).

Using tools like Jira, focusing on high-priority tickets, and avoiding context switching.

Highlight your technical skills, culture fit, and your passion for solving their company's specific problems.