# Top 100 Technical Interview Questions & Answers (2026 Master Cheat Sheet) | RateMyInterview Blog > Canonical Source: https://ratemyinterview.online/blog/top-100-technical-interview-questions-answers-2026 > Platform: RateMyInterview (https://ratemyinterview.online) — Voice AI Mock Technical Interview Platform > Practice Live Out Loud: https://ratemyinterview.online/practice (2 free full sessions included, zero credit card required) 🔥 Mega Guide · 2026 Edition Global · FAANG · Startups · IT Services # Top 100 Technical Interview Questions & Answers: The 2026 Master Cheat Sheet The definitive, field-tested question bank for software engineers. Complete with spoken answer formulas, code patterns, architectural trade-offs, and voice mock interview checkpoints. October 11, 2026 · 38 min read · RateMyInterview Engineering Council ## Executive Summary: The 2026 Software Engineer Interview Matrix - • **The 7 Core Pillars:** Modern technical interviews in 2026 evaluate candidates across: OOPs & Language Mechanics (20%), DSA & Algorithmic Patterns (25%), High-Level System Design (20%), Databases & SQL (15%), OS & Concurrency (10%), and Behavioral STAR Alignment (10%). - • **The Verbal Shift:** Rote coding memorization is obsolete. Interviewers now look for your *spoken thought process*—verbal dry-runs, proactive edge-case enumeration, and structural trade-off articulation before typing a single character. - • **Universal Applicability:** Whether interviewing at Big Tech (Google, Meta, Amazon), high-frequency FinTech (Goldman Sachs, Stripe), top Indian IT services (TCS Digital/Prime, Infosys SP, Cognizant, Accenture), or high-scale unicorns, these 100 questions represent the 95th percentile of interview questions. ## Table of Contents · Jump to Category [ 1. OOPs, SOLID & Language Internals (Q1–Q20) → ](#part-1-oops) [ 2. DSA Patterns & Algorithmic Logic (Q21–Q40) → ](#part-2-dsa) [ 3. High-Level System Design & Scale (Q41–Q60) → ](#part-3-system-design) [ 4. SQL, ACID Transactions & Databases (Q61–Q75) → ](#part-4-sql-db) [ 5. OS, Concurrency & Networking (Q76–Q88) → ](#part-5-os-networks) [ 6. 2026 AI Era Engineering & Defense (Q89–Q94) → ](#part-6-ai-era) [ 7. Behavioral, Culture & STAR Questions (Q95–Q100) → ](#part-7-behavioral) [ 8. Frequently Asked Questions (FAQs) → ](#faqs) Part 1 ## Object-Oriented Programming, SOLID & Language Internals (Q1–Q20) ### Q1: Explain the 4 Pillars of OOPs using a real-world software architecture example. **Spoken Answer:** Rather than reciting dictionary definitions, anchor it to a payment gateway architecture: • **Encapsulation:** Bundling data with methods and restricting direct access (e.g., private credit card CVV field accessible only via sanitized validation methods). • **Abstraction:** Hiding underlying complexity and exposing only essential interfaces (e.g., an interface `PaymentGateway` with method `charge()` hiding Stripe/PayPal HTTP handshakes). • **Inheritance:** Reusing common behavioral invariants across hierarchical entities (e.g., `CardPayment` and `UPIPayment` extending a base `Transaction` class). • **Polymorphism:** The ability of different classes to respond to the same message in unique ways (e.g., executing `gateway.processRefund()` where runtime dispatch selects Stripe refund logic or PayPal refund logic). ### Q2: What is the difference between Method Overloading (Compile-Time) and Method Overriding (Run-Time)? **Key Insight:** Overloading happens in the same class with identical names but differing parameter signatures resolved by the compiler (static binding). Overriding happens in parent-child hierarchies where a subclass replaces the parent method implementation with identical signature, resolved dynamically at runtime using virtual method tables (vtable). ### Q3: How do Virtual Method Tables (vtables) work under the hood in C++ and Java? When a class contains virtual methods, the compiler adds a hidden pointer (`vptr`) to the object instance pointing to an array of function pointers (the `vtable`). When calling an overridden method, runtime looks up the function pointer via an extra pointer dereference (`O(1)` dispatch overhead). ### Q4: Walk through the 5 SOLID Principles with concise software design violations. - **S (Single Responsibility):** A class should have one reason to change. Violation: An `OrderService` calculating taxes, updating SQL DB, and sending Twilio SMS alerts. - **O (Open/Closed):** Open for extension, closed for modification. Use strategy interfaces instead of nested `switch/case` blocks when adding new pricing tiers. - **L (Liskov Substitution):** Derived classes must be substitutable for their base classes without altering correctness. Classic violation: Square extending Rectangle and overriding setters, breaking aspect ratio invariants. - **I (Interface Segregation):** Clients should not depend on interfaces they do not use. Split massive monolithic interfaces into targeted role interfaces. - **D (Dependency Inversion):** High-level modules should depend on abstractions, not concrete low-level implementations. Inject interfaces via Dependency Injection. ### Q5: How does Garbage Collection work in modern runtimes (JVM & V8)? Runtimes use Generational Garbage Collection based on the Weak Generational Hypothesis (most objects die young). Memory is split into Young Generation (Eden + Survivor spaces) and Old/Tenured Generation. Young gen uses fast minor copying GC (Mark-Copy). Long-lived objects are promoted to Old gen, which uses concurrent Mark-Sweep-Compact collectors (e.g., JVM G1/ZGC, V8 Scavenger + Mark-Sweep) to minimize stop-the-world pauses. ### Q6: What is the Python Global Interpreter Lock (GIL) and how did Python 3.13 free-threading change it? The GIL is a mutex guarding Python object memory against race conditions in CPython's reference counting. It prevents multiple native OS threads from executing Python bytecode simultaneously. For CPU-bound tasks, developers traditionally used multiprocessing. Python 3.13 introduces experimental free-threaded CPython (PEP 703) using mimalloc and biased reference counting, allowing true multi-core parallel execution. ### Q7: What is the difference between Abstract Class and Interface across Java, TypeScript, and C++? An abstract class provides partial implementation, instance state (fields), and constructor logic for tight "IS-A" relationships (single inheritance). An interface defines pure behavioral contracts ("CAN-DO" capabilities) supporting multiple inheritance of type. In modern Java, interfaces can have `default` methods, but cannot maintain mutable instance state. ### Q8: Explain Memory Leaks in garbage-collected languages (Java/JavaScript/Go). A memory leak occurs when unneeded objects remain reachable from GC Roots (e.g., static collections, unremoved event listeners, long-running thread local variables, unclosed database connection pools, or captured closure scopes). ### Q9: What is the difference between Composition and Inheritance? Why prefer Composition? Inheritance creates tight compile-time coupling where subclasses inherit internal parent vulnerabilities (fragile base class problem). Composition ("HAS-A") injects dependencies through interfaces, allowing dynamic runtime swapping, isolation, and easier unit testing with mock objects. ### Q10: What is the Event Loop in JavaScript/Node.js, and how does the microtask queue differ from the macrotask queue? JavaScript is single-threaded and non-blocking using Libuv's event loop. When synchronous code finishes, the runtime empties the **Microtask Queue** (Promise callbacks, `process.nextTick`, MutationObserver) before executing the next phase of the **Macrotask Queue** (`setTimeout`, `setInterval`, `setImmediate`, I/O polling). Microtasks always take immediate priority. **Quick Rapid-Fire OOPs Concepts (Q11–Q20):** • **Q11 (Diamond Problem):** Occurs in multiple inheritance when a class inherits from two classes sharing a common ancestor; resolved via virtual base classes in C++ or single-class + multiple-interface contracts in Java/C#. • **Q12 (Immutability):** Thread-safe by default, prevents side-effects, enables safe caching and hash key lookups. • **Q13 (Pass-by-value vs Pass-by-reference):** Java and Python are strictly pass-by-value (the object reference pointer itself is passed by value). • **Q14 (Shallow vs Deep Copy):** Shallow copy duplicates the top-level container pointing to same nested objects; Deep copy recursively clones all child objects. • **Q15 (Singleton Pattern Pitfalls):** Introduces global mutable state, complicates unit test parallelization, violates Single Responsibility. • **Q16 (Factory vs Abstract Factory):** Factory creates instances of a single product family; Abstract Factory creates families of related dependent products. • **Q17 (Dependency Injection Benefits):** Loose coupling, testability with mocks, lifecycle configuration inversion. • **Q18 (Static vs Dynamic Binding):** Static binding occurs at compile time (private, static, final methods); Dynamic binding occurs at runtime based on object instance. • **Q19 (Reflection Performance Cost):** Bypasses compiler optimizations, incurs runtime security checks, prevents JIT inlining. • **Q20 (Generics / Type Erasure):** Java compiler removes generic type arguments at bytecode compile time for backward compatibility; C++ templates generate distinct assembly code per type. Part 2 ## Data Structures & Algorithmic Patterns (Q21–Q40) ### Q21: How do you identify when to use Two Pointers vs Sliding Window? **Two Pointers:** Typically used on sorted arrays/linked lists searching for pairs, triplets, palindrome verification, or partitioning (e.g., QuickSort, 3Sum, Container With Most Water). Pointers usually start at opposite ends or move at different speeds. **Sliding Window:** Used on contiguous subarrays or substrings satisfying a specific condition (e.g., "Longest substring without repeating characters", "Minimum window substring"). Maintains a dynamic window expanding the right pointer and contracting the left pointer. ### Q22: Explain the time and space complexity of QuickSort vs MergeSort in worst and average cases. Algorithm Best / Avg Time Worst Time Space Complexity Stability MergeSort O(N log N) O(N log N) O(N) Stable QuickSort O(N log N) O(N²) (bad pivot) O(log N) in-place stack Unstable Why QuickSort is preferred in practice: Better CPU cache locality, smaller constant factors, and zero heap allocation overhead when using dual-pivot partitioning. ### Q23: How do you detect and find the start node of a cycle in a Linked List? Use Floyd's Cycle-Finding Algorithm (Tortoise and Hare). Move `slow` by 1 step and `fast` by 2 steps. If they meet, a cycle exists. To find the cycle entrance: Reset `slow` to the list head while keeping `fast` at the intersection point. Advance both by 1 step simultaneously; the node where they collide is the cycle head (mathematically proven via modular distance equivalence). ### Q24: What is the difference between BFS and DFS in Graph traversal? When use which? **BFS (Queue-based):** Traverses layer-by-layer. *Guarantees finding the shortest path* in unweighted graphs (e.g., Word Ladder, minimum steps in knight moves). Requires `O(V)` queue space. **DFS (Stack / Recursion):** Plunges deep down branches before backtracking. Best for connected components, topological sorting, cycle detection, maze solving, and backtracking combinations (e.g., N-Queens, Sudoku). ### Q25: Explain Dynamic Programming: Memoization (Top-Down) vs Tabulation (Bottom-Up). Both solve problems with *Overlapping Subproblems* and *Optimal Substructure*. **Memoization (Top-Down):** Natural recursive formulation caching subproblem outputs in a hash map or array. Suffers from call-stack overhead and recursion depth limits. **Tabulation (Bottom-Up):** Iterative array filling starting from base cases up to target state. Eliminates recursion stack overhead and frequently allows state compression (e.g., reducing `O(N)` space to `O(1)` space in Fibonacci or House Robber). **Core Algorithmic Rapid-Fire (Q26–Q40):** • **Q26 (LRU Cache Design):** Built using a Hash Map + Doubly Linked List for `O(1)` lookups, insertions, and evictions. • **Q27 (Trie vs Hash Map):** Trie is optimal for prefix search, autocomplete, and dictionary prefix matching with `O(L)` word length bounds. • **Q28 (Binary Heap Insertion/Deletion):** Insertion is `O(log N)` bubble-up; extraction of min/max is `O(log N)` bubble-down; finding min/max is `O(1)`. • **Q29 (Topological Sort):** Valid only on Directed Acyclic Graphs (DAGs) using Kahn's In-Degree algorithm or DFS post-order reversal. • **Q30 (Dijkstra's Algorithm):** Greedy shortest path using Min-Heap priority queue; time complexity `O((V + E) log V)`. Fails on negative edge weights. • **Q31 (Disjoint Set Union / DSU):** Union-Find with path compression and union-by-rank achieves near constant `O(α(N))` amortized time. • **Q32 (Monotonic Stack):** Best for "Next Greater Element", "Daily Temperatures", and "Largest Rectangle in Histogram" in linear `O(N)` time. • **Q33 (Kadane's Algorithm):** Solves Maximum Subarray sum in `O(N)` time and `O(1)` space by tracking running local and global maximums. • **Q34 (Binary Search on Answer Space):** Applied when monotonic answer spaces exist (e.g., "Koko Eating Bananas", "Capacity to Ship Packages"). • **Q35 (Tree Traversal Orders):** Pre-order (Root-Left-Right), In-order (Left-Root-Right, sorted in BST), Post-order (Left-Right-Root), Level-order (BFS). • **Q36 (Segment Tree vs Fenwick / BIT):** Fenwick tree is simpler and faster for prefix sum updates; Segment Tree supports range min/max/arbitrary associative operations. • **Q37 (Hash Collisions):** Handled via Chaining (LinkedList/Red-Black Tree buckets) or Open Addressing (Linear Probing, Quadratic Probing, Double Hashing). • **Q38 (Fast Exponentiation):** Calculates `x^n` in `O(log n)` time by repeatedly squaring base when exponent is even. • **Q39 (Reservoir Sampling):** Randomly selects `k` items from an unknown or streaming dataset of length `N` in `O(N)` with uniform probability. • **Q40 (String Matching):** KMP (Knuth-Morris-Pratt) achieves `O(N + M)` using a Longest Prefix Suffix (LPS) array avoiding redundant comparisons. Part 3 ## High-Level System Design & Scalability (Q41–Q60) ### Q41: Explain the CAP Theorem vs PACELC Theorem in Distributed Systems. **CAP Theorem:** In a distributed network partition (P), a system must choose between Consistency (all nodes see latest write) or Availability (every request receives a non-error response). **PACELC Theorem:** Extends CAP by considering normal operating conditions: If there is a **P**artition, choose **A**vailability or **C**onsistency; **E**lse (normal conditions), trade off **L**atency versus **C**onsistency. (e.g., MongoDB/Cassandra tuneable consistency). ### Q42: What is Consistent Hashing and why is it critical for distributed caches? Traditional hash mod `hash(key) % N` causes massive cache misses (remaps ~99% of keys) when scaling nodes from `N` to `N+1`. Consistent Hashing maps keys and servers onto a logical 360° hash ring. When adding or removing a node, only `K/N` keys need remapping. Virtual nodes (vnodes) prevent hot spots by evenly spreading partitions across physical servers. ### Q43: Compare Cache-Aside, Read-Through, Write-Through, and Write-Back Caching. - **Cache-Aside (Lazy Loading):** Application checks cache; on miss, loads from DB and writes to cache. Standard, flexible, resilient to cache node failures. - **Read-Through:** Application treats cache as master; cache automatically loads missing data from DB on demand. - **Write-Through:** Application writes to cache, which synchronously writes to DB before confirming success. High consistency, higher write latency. - **Write-Back (Write-Behind):** Application writes to cache; cache asynchronously batches updates to DB. Ultra-fast writes, but risks data loss during cache crashes. ### Q44: How do you design an Idempotent API for financial transactions? Clients send a unique `Idempotency-Key` header (UUIDv4) with each payment POST request. The API gateway uses a distributed atomic lock (e.g., Redis `SETNX` with TTL) on that key. If the key exists, return the cached result or a `409 In Progress`. If new, process the transaction, store the final response in database/Redis, and return. ### Q45: Compare Message Queues: Apache Kafka vs RabbitMQ. **RabbitMQ (Smart Broker, Dumb Consumer):** Message broker based on AMQP. Excellent for complex routing (topic/fanout exchanges), priority queues, and per-message acknowledgements. Messages are deleted post-consumption. **Apache Kafka (Dumb Broker, Smart Consumer):** Distributed append-only commit log. High throughput (millions of msgs/sec), sequential disk I/O, partitioned offsets, long retention, and consumer group replayability. Ideal for event sourcing and stream processing. **System Design Rapid-Fire Concepts (Q46–Q60):** • **Q46 (Rate Limiting Algorithms):** Token Bucket (bursts permitted), Leaky Bucket (smooth constant rate), Fixed Window Counter (boundary spikes), Sliding Window Log (high memory), Sliding Window Counter (hybrid standard). • **Q47 (Database Sharding Strategies):** Range-based (hot spots on new dates), Hash-based (uniform distribution), Directory/Lookup-based (flexible routing table). • **Q48 (Saga Pattern):** Manages distributed transactions across microservices via Choreography (event-driven) or Orchestration (central coordinator) using compensating rollback actions. • **Q49 (Load Balancer Types):** Layer 4 (Transport layer, TCP/UDP IP dispatch, blazing fast) vs Layer 7 (Application layer, HTTP headers/cookies/path inspection, SSL termination). • **Q50 (CDN Edge Caching):** Geographically distributed proxy servers caching static assets and API responses to minimize latency and origin egress load. • **Q51 (Bloom Filters):** Space-efficient probabilistic data structure answering "definitely not in set" or "possibly in set" with zero false negatives (used in BigTable, Cassandra). • **Q52 (Circuit Breaker Pattern):** Prevents cascading service failures via 3 states: Closed (normal), Open (fast fail), and Half-Open (trial traffic probe). • **Q53 (SQL vs NoSQL Choice):** SQL for structured relations and ACID compliance; Document (MongoDB) for polymorphic schemas; Key-Value (Redis) for caching; Graph (Neo4j) for deep relationships. • **Q54 (Horizontal vs Vertical Scaling):** Vertical (scaling up CPU/RAM) has physical hardware ceilings and single-point-of-failure; Horizontal (scaling out machines) requires stateless services and distributed databases. • **Q55 (Thundering Herd Problem):** Simultaneous cache expiration causing thousands of concurrent DB queries; solved via mutex locks, probabilistic early expiration (XFetch), or background cache warming. • **Q56 (Database Replication):** Primary-Replica (writes to primary, reads scaled across replicas, replication lag trade-off) vs Multi-Primary (conflict resolution overhead). • **Q57 (WebSockets vs Server-Sent Events vs Polling):** Long Polling (HTTP overhead); SSE (unidirectional server-to-client over HTTP); WebSockets (full-duplex persistent bidirectional TCP connection). • **Q58 (Two-Phase Commit / 2PC):** Distributed consensus protocol with Prepare and Commit phases; strong consistency but blocking and fragile under network partitions. • **Q59 (Distributed Tracing):** Uses W3C TraceContext headers (TraceID, SpanID) propagated across microservices (OpenTelemetry, Jaeger) for end-to-end latency profiling. • **Q60 (Disaster Recovery RTO & RPO):** RTO (Recovery Time Objective: max acceptable downtime) vs RPO (Recovery Point Objective: max acceptable data loss window). Part 4 ## Databases, SQL & ACID Transactions (Q61–Q75) ### Q61: Explain the 4 ACID Properties with concrete database failures. - **Atomicity:** All operations succeed or none do (using Write-Ahead Logging / WAL rollback). - **Consistency:** The database transitions only between valid states enforcing schema constraints, foreign keys, and triggers. - **Isolation:** Concurrent transactions execute without cross-interference depending on transaction isolation level. - **Durability:** Once committed, transaction writes survive power loss, crashes, and restarts (flushed to disk via fsync). ### Q62: Compare B-Tree vs B+ Tree indexing. Why do relational DBs (Postgres/MySQL) use B+ Trees? In a B-Tree, keys and actual data pointers are stored in both internal and leaf nodes. In a **B+ Tree**, internal nodes contain only routing keys, while all data/record pointers reside strictly in leaf nodes linked as a bidirectional linked list. B+ Trees provide higher branching factor (more keys per disk page), shallower tree depth, and blazing-fast range scan operations (`BETWEEN`, `>`, `<`) by traversing sequential leaf nodes. ### Q63: What are the 4 SQL Transaction Isolation Levels and their corresponding phenomena? Isolation Level Dirty Read Non-Repeatable Read Phantom Read Read Uncommitted Allowed Allowed Allowed Read Committed Prevented Allowed Allowed Repeatable Read Prevented Prevented Allowed (InnoDB prevents via MVCC) Serializable Prevented Prevented Prevented ### Q64: Write a SQL Query to find the Nth Highest Salary using DENSE_RANK(). ``` WITH RankedSalaries AS ( SELECT employee_id, salary, DENSE_RANK() OVER (ORDER BY salary DESC) as rnk FROM employees ) SELECT salary FROM RankedSalaries WHERE rnk = 2; -- 2nd highest ``` Why `DENSE_RANK()` over `ROW_NUMBER()`: Handles tie salaries without skipping consecutive rankings. **Database Rapid-Fire Concepts (Q65–Q75):** • **Q65 (Clustered vs Non-Clustered Index):** Clustered index dictates physical disk row ordering (only 1 per table, primary key); Non-clustered index stores index key with pointer back to clustered table row. • **Q66 (N+1 Query Problem):** An ORM executes 1 query for parent records followed by N queries for each child record; resolved using `JOIN FETCH` or eager loading. • **Q67 (Optimistic vs Pessimistic Locking):** Pessimistic locks database row (`SELECT FOR UPDATE`); Optimistic checks a version column before committing, rolling back on conflict. • **Q68 (Database Normalization):** 1NF (atomic columns), 2NF (eliminate partial key dependencies), 3NF (eliminate transitive dependencies), BCNF (every determinant is a candidate key). • **Q69 (Denormalization Trade-Off):** Improves read query speed by eliminating expensive joins at the cost of disk storage, data redundancy, and update anomaly risks. • **Q70 (SQL Window Functions):** Perform calculation across a set of table rows related to current row without collapsing rows like `GROUP BY` does. • **Q71 (EXPLAIN / EXPLAIN ANALYZE):** Inspects query execution plans, index scans vs sequential table scans, and estimated costs. • **Q72 (Write-Ahead Logging / WAL):** Changes are appended sequentially to a transaction log before disk pages are modified, guaranteeing durability and crash recovery. • **Q73 (Deadlock Detection in RDBMS):** RDBMS builds a Wait-For Graph of transactions; breaks cycles by aborting the transaction with the lowest cost. • **Q74 (Covering Index):** An index containing all columns requested in the query, allowing query resolution entirely from index leaf nodes without touching heap tables. • **Q75 (Foreign Keys in Microservices):** Relational foreign keys are replaced with eventual consistency, domain events, or API validation to preserve service boundaries. Part 5 ## Operating Systems, Concurrency & Networking (Q76–Q88) ### Q76: What is the fundamental difference between a Process and a Thread? A **Process** is an executing program instance with its own isolated virtual address space, memory heap, file descriptors, and security tokens. Inter-Process Communication (IPC) requires sockets, pipes, or shared memory. A **Thread** is the smallest unit of CPU execution within a process. Threads of the same process share the same code, heap, and open files, but possess private program counters, registers, and execution stacks. Context switching threads is significantly cheaper than context switching processes. ### Q77: What are the 4 Coffman Conditions required for a Deadlock to occur? Deadlock occurs if and only if all four conditions hold simultaneously: 1. **Mutual Exclusion:** Resources cannot be shared. 2. **Hold and Wait:** Processes hold allocated resources while requesting new ones. 3. **No Preemption:** Resources can only be released voluntarily by the holding process. 4. **Circular Wait:** A closed chain of processes exists where each holds a resource needed by the next. *Prevention:* Eliminate circular wait by enforcing a strict global resource acquisition ordering lock hierarchy. ### Q78: What happens step-by-step when you type https://ratemyinterview.online in your browser? - Browser checks local cache (DNS cache, OS hosts file, resolver cache). - DNS resolution initiates: Recursive resolver queries Root, TLD (.net), and Authoritative nameservers to resolve IP. - Browser initiates TCP 3-Way Handshake (SYN → SYN-ACK → ACK). - TLS 1.3 Handshake negotiates cipher suite, verifies certificate, and derives session keys (1-RTT). - Browser sends HTTP/2 or HTTP/3 GET request. - Web server (or CDN edge) processes request, terminates SSL, and returns HTML response. - Browser DOM tree construction, CSSOM parsing, JavaScript compilation, Layout calculation, and pixel Painting. **OS & Networking Rapid-Fire (Q79–Q88):** • **Q79 (Mutex vs Semaphore):** Mutex is a locking mechanism (ownership semantics; only locking thread can unlock); Semaphore is a signaling mechanism (counter allowing N concurrent accesses). • **Q80 (TCP vs UDP):** TCP is connection-oriented, reliable, ordered, with flow control and congestion control; UDP is connectionless, lightweight, with zero ordering or retransmission guarantees. • **Q81 (Virtual Memory & Paging):** Hardware MMU translates virtual addresses to physical RAM frames via page tables. When a page is not present in RAM, a Page Fault triggers disk retrieval. • **Q82 (TCP 4-Way Handshake Termination):** FIN → ACK → FIN → ACK, with TIME_WAIT state preventing duplicate delayed packets from corrupting new connections. • **Q83 (HTTP/1.1 vs HTTP/2 vs HTTP/3):** HTTP/1.1 (Head-of-Line blocking, keep-alive); HTTP/2 (binary framing, multiplexing over single TCP connection); HTTP/3 (QUIC protocol over UDP, eliminating TCP transport Head-of-Line blocking). • **Q84 (Race Conditions & Critical Sections):** Race conditions occur when concurrent threads access shared mutable state without synchronization; solved via locks, atomics, or channels. • **Q85 (Context Switching Overhead):** Involves saving CPU register states, switching page tables in the MMU, and flushing the CPU Translation Lookaside Buffer (TLB). • **Q86 (DNS Records):** A (IPv4), AAAA (IPv6), CNAME (canonical alias), MX (mail exchange), TXT (domain verification / SPF), NS (nameserver). • **Q87 (CORS):** Cross-Origin Resource Sharing is a browser security mechanism enforcing same-origin policy using HTTP headers (`Access-Control-Allow-Origin`) and OPTIONS preflight requests. • **Q88 (Socket Programming):** Server creates socket, binds to IP/port, listens for incoming connections, and accepts client sockets returning a dedicated file descriptor. Part 6 ## 2026 AI Era Engineering & Systems Defense (Q89–Q94) ### Q89: How have technical interview evaluations changed with the rise of Cursor, Claude, and Copilot? Companies no longer evaluate syntax typing speed. In 2026, candidates are judged on: • **Problem Decomposition:** Breaking vague requests into clean, verifiable specifications. • **Code Review Vigilance:** Spotting subtle race conditions, hallucinated API methods, or security flaws in AI-generated snippets. • **Verbal Architectural Defense:** Explaining why a specific database schema or concurrency pattern was chosen over alternatives. ### Q90: What is Prompt Injection and how do you protect tool-calling LLM agents? Prompt injection occurs when untrusted user input hijacks the system prompt instructions of an LLM. Defenses include: strict separation of system and user messages, deterministic schema validation (Pydantic / Zod), human-in-the-loop approvals for sensitive write actions, and read-only sandboxed tool execution. **AI Era Rapid-Fire Concepts (Q91–Q94):** • **Q91 (Model Context Protocol / MCP):** Open standard enabling secure client-server communication between AI agents and local developer tools via stdio/SSE. • **Q92 (RAG vs Fine-Tuning):** RAG connects models to dynamic, private, changing knowledge bases; Fine-Tuning adapts models for tone, format, or specialized domain syntax. • **Q93 (Slopsquatting Security Risk):** Threat actors publish malicious packages matching hallucinated library names suggested by LLMs. • **Q94 (Sandboxing Autonomous Code):** Using lightweight microVMs (Firecracker, gVisor) with network egress proxies to safely run arbitrary code generated by AI. Part 7 ## Behavioral, Culture & STAR Questions (Q95–Q100) ### Q95: How do you structure answers using the STAR Method? **S (Situation):** Set context in 1–2 sentences (company, timeline, initial metric). **T (Task):** Explain the exact responsibility and hurdle you were assigned. **A (Action):** The longest part (60% of answer) detailing the specific technical and interpersonal actions *you personally took*. **R (Result):** Quantifiable outcome (e.g., "Reduced P99 API latency by 42% and saved $18,000/month in cloud spend"). ### Q96: "Tell me about a time you had a technical disagreement with a teammate." *Formula:* Focus on data over ego. Explain how you created an objective benchmarking spike (measuring throughput or latency), presented the trade-offs respectfully in an RFC document, and either aligned on the optimal choice or adhered to "Disagree and Commit." **Behavioral Rapid-Fire Questions (Q97–Q100):** • **Q97 ("Tell me about a time you caused a production incident"):** Focus on immediate mitigation (rollback first), blameless post-mortem analysis, and automated invariant tests introduced to guarantee it never recurs. • **Q98 ("Why do you want to join our company?"):** Research specific engineering blog posts, open-source contributions, or product scale hurdles—never quote generic marketing slogans. • **Q99 ("How do you prioritize competing deadlines?"):** Communicate proactively, establish business impact matrices, and negotiate scope reduction with product managers before missing dates. • **Q100 ("Do you have any questions for us?"):** Ask high-signal engineering questions: "What is the team's biggest technical debt item right now?", "How does your deploy pipeline handle canary releases?", or "What separates a good engineer from a great engineer on this team?" ## Frequently Asked Questions (FAQs) What is the best way to practice these 100 questions? Reading answers silently gives a false sense of mastery. The gold standard is **spoken practice out loud**. Practice explaining concepts in under 90 seconds without filler words. You can practice any of these topics interactively on RateMyInterview's free AI mock interview rooms. Are these questions asked at FAANG or IT services companies? Both. Big Tech companies (Google, Amazon, Meta) focus heavily on Part 2 (DSA) and Part 3 (System Design). IT Services (TCS Digital/Prime, Infosys, Accenture, Cognizant, Wipro) focus intensely on Part 1 (OOPs & Language Mechanics), Part 4 (SQL), and Part 5 (OS & Networking). How many free interview sessions does RateMyInterview provide? Every user receives 2 free comprehensive voice AI mock technical interview sessions with Sophia AI with zero credit card required. Sessions include custom resume question adaptation, live spoken evaluation, and complete scoring reports. ### Don't Just Memorize Answers — Practice Speaking Them Out Loud Experience realistic voice-to-voice mock technical interviews tailored to your target company and tech stack. 100% free with Sophia AI. [ Start Free Voice Mock Session ](/login) --- ### Practice Live with Sophia AI Practice realistic voice technical interviews tailored directly to your real resume at https://ratemyinterview.online. Sophia AI speaks and listens via your microphone with sub-second speech latency (~900ms), giving instant objective scores, full transcripts, and question-by-question model solutions.