Phase 1 — Computer Science Fundamentals

How computers, operating systems, file systems and networks really work, plus the core data structures and algorithms, explained for .NET 10 engineers.

41. What is the difference between sequential and random file access? Why does it matter for performance on HDDs and SSDs, and which .NET APIs (FileOptions, RandomAccess, memory-mapped files) help with each?

    Sequential vs random I/O, device and OS effects (seek time, read-ahead, page cache), FileOptions hints, the RandomAccess API, and memory-mapped files.

    Senior Theory File System · 🔗 3 follow-ups · 🛠 1 real-world
42. You need to import a 20 GB CSV file into SQL Server every night from a .NET service running in a container with a 1 GB memory limit. How would you design it?

    Designing a memory-bounded, resumable large-file import: streaming, low-allocation parsing, bounded pipelines, bulk insert, checkpoints and bad-row handling.

    Senior RealWorldScenario File System · 🔗 3 follow-ups · 🛠 1 real-world
43. Walk me through what happens, at the network level, when a .NET client calls https://api.example.com/orders/42 and gets a response.

    An end-to-end tour of one HTTPS request: DNS, IP routing, ports, TCP handshake, TLS, HTTP, load balancers and proxies, connection reuse, and where time goes.

    Intermediate Theory Networking Basics · 🔗 3 follow-ups
44. What is an IP address? Explain IPv4 vs IPv6, private vs public ranges, subnets and CIDR notation, and NAT, with examples from cloud or container networking.

    IP addressing fundamentals: IPv4 and IPv6, CIDR and subnet sizing, private, loopback and link-local ranges, NAT, and how they show up in cloud VNets and Kubernetes.

    Junior Theory Networking Basics · 🔗 2 follow-ups
45. What is the difference between TCP and UDP? When would you choose each, and why does HTTP/3 run over UDP?

    TCP and UDP compared: connections, reliability, ordering, flow and congestion control, head-of-line blocking, typical uses, and QUIC/HTTP/3 in .NET.

    Mid-Level Theory Networking Basics · 🔗 3 follow-ups · 🛠 1 real-world
46. What are ports and sockets? Your ASP.NET Core API works on your laptop but nothing answers when you run it in Docker. What is going on?

    Ports, listening vs connected sockets, the 4-tuple, binding to localhost vs all interfaces, container port mapping, and tools to see who is listening.

    Mid-Level Debugging Networking Basics · 🔗 3 follow-ups · 🛠 1 real-world
47. How does DNS resolution work? Describe a DNS-related incident you could see in a .NET service in Kubernetes or the cloud, and how you would diagnose it.

    DNS records, recursive resolution, TTLs and caching, how .NET resolves names, connection pooling vs DNS changes, Kubernetes ndots and conntrack issues, and diagnosis tools.

    Senior Debugging Networking Basics · 🔗 3 follow-ups · 🛠 1 real-world
48. Explain HTTP from a backend engineer's point of view: methods and idempotency, status codes, important headers, and the practical differences between HTTP/1.1, HTTP/2 and HTTP/3.

    HTTP semantics for API design and operations: safe and idempotent methods, status code classes, caching and content headers, and the evolution from HTTP/1.1 to HTTP/2 and HTTP/3.

    Mid-Level Theory Networking Basics · 🔗 3 follow-ups · 🛠 1 real-world
49. How do HTTPS and TLS work? Walk through the TLS 1.3 handshake and certificate validation, and explain how you would fix "The remote certificate is invalid" errors in a .NET service without disabling validation.

    TLS goals, the TLS 1.3 handshake, certificate chains and validation, SNI and ALPN, mutual TLS, and safe diagnosis of certificate errors in .NET.

    Senior Security Networking Basics · 🔗 3 follow-ups · 🛠 1 real-world
50. What is the difference between latency, bandwidth and throughput? How do round-trip time and chatty communication affect a .NET service, and how would you improve it?

    Latency, bandwidth and throughput defined; RTT, bandwidth-delay product, Little's law and tail latency; why chatty calls across regions hurt and how batching, caching and placement fix it.

    Senior Theory Networking Basics · 🔗 3 follow-ups · 🛠 1 real-world
51. How do firewalls, security groups and network policies work? A .NET service cannot reach a dependency, or its connections drop after being idle. How do you troubleshoot it?

    Stateful vs stateless firewalls, cloud NSGs/security groups, NACLs, WAFs, Kubernetes NetworkPolicy, idle timeouts, and a step-by-step connectivity troubleshooting method.

    Mid-Level Debugging Networking Basics · 🔗 3 follow-ups · 🛠 1 real-world
52. What is the difference between a forward proxy and a reverse proxy? Your ASP.NET Core app behind a reverse proxy logs the proxy's IP for every user and gets into an HTTPS redirect loop. What is wrong and how do you fix it safely?

    Forward vs reverse proxies, what they change (TLS, headers, timeouts, buffering), X-Forwarded-* headers and the ForwardedHeaders middleware, outbound proxy settings, and spoofing risks.

    Senior Debugging Networking Basics · 🔗 3 follow-ups · 🛠 1 real-world
53. How do load balancers work? Compare layer 4 and layer 7 load balancing, explain health checks, algorithms, sticky sessions and connection draining, and why gRPC traffic can end up on only one pod.

    L4 vs L7 load balancing, balancing algorithms, health checks and readiness, session affinity, graceful shutdown and draining, global load balancing, and long-lived HTTP/2 connection imbalance.

    Senior SystemDesign Networking Basics · 🔗 3 follow-ups · 🛠 1 real-world
54. Design the network path for a public .NET API on a cloud platform: from the user's browser to the database. Which components do you put in the path (DNS, CDN/WAF, load balancers, proxies, firewalls, private networking), and what does each one do?

    An end-to-end cloud network design for a public API: global entry, TLS, WAF, L7 routing, private subnets, egress control, private endpoints, and how each choice affects security, latency and operations.

    Staff / Architect SystemDesign Networking Basics · 🔗 3 follow-ups · 🛠 1 real-world
55. What is an array, and how does List<T> build on it in .NET? Explain memory layout, indexing cost, how List<T> grows, and when you would use an array, List<T> or Span<T>.

    Arrays as contiguous memory, O(1) indexing, List<T> as a growable array with capacity doubling, amortised O(1) Add, and when to use arrays, lists, spans and pooled buffers.

    Junior Theory Data Structures · 🔗 3 follow-ups
56. What is a linked list? Compare LinkedList<T> with List<T> in .NET, including big-O and real-world performance, and give a case where a linked list is the right choice.

    Singly and doubly linked lists, O(1) node insert/remove vs O(n) search, poor cache locality, LinkedList<T> in .NET, and the LRU cache as a classic use.

    Intermediate Theory Data Structures · 🔗 2 follow-ups
57. Explain stacks and queues. How are Stack<T> and Queue<T> implemented in .NET, where do you see them in real systems, and which thread-safe alternatives would you use?

    LIFO and FIFO structures, their array-based implementations in .NET, the call stack, undo, BFS and work queues, plus ConcurrentStack, ConcurrentQueue and Channels.

    Junior Theory Data Structures · 🔗 3 follow-ups
58. How does a hash table work? Explain how Dictionary<TKey,TValue> in .NET stores and finds entries, handles collisions and resizes, and what GetHashCode and Equals must guarantee.

    Hash table fundamentals and .NET Dictionary internals: buckets and entries, chaining, load and resizing, the GetHashCode/Equals contract, average vs worst-case cost, and hash flooding protection.

    Mid-Level Theory Data Structures · 🔗 3 follow-ups · 🛠 1 real-world
59. A Dictionary-based cache in a .NET service gets slower and slower and sometimes "loses" entries that were definitely added. What could be wrong with the key type, and how would you debug and fix it?

    Debugging hash-based collection failures: constant or poor GetHashCode, mutable keys, inconsistent Equals, culture-sensitive comparisons, and thread-unsafe access to Dictionary.

    Senior Debugging Data Structures · 🔗 2 follow-ups · 🛠 1 real-world
60. What is a set? When would you use HashSet<T>, SortedSet<T>, FrozenSet<T> or ImmutableHashSet<T> in .NET, and what set operations do they support?

    Sets as collections of unique items, hash vs tree-based sets, set algebra (union, intersection, difference), frozen and immutable variants, and common performance wins over List.Contains.

    Intermediate Theory Data Structures · 🔗 3 follow-ups