Skip to content
Tech Interview Prep
Technical interview guide

Network Troubleshooting

Systematically isolating where in the stack a connectivity problem actually lives, instead of guessing.

Read
45 min
Practice MCQs
25
Interview Q&A
25
Edition
v4
Editorial status
Reviewed
Relevant for
Network Engineer

Scope: Current Wireshark, tcpdump, Linux iproute2/ss/tc/ethtool, IETF host/TCP/ICMP/PMTUD/DNS/TLS references reviewed 2026-09-04.

Curated: · Written: · Reviewed:

25 questions

MCQ-3A host at 10.0.2.15/24 uses 10.0.2.1 as its gateway. `ip neigh show` reports `10.0.2.1 dev eth0 INCOMPLETE`, and the entry stays that way for several minutes. Pings to 10.0.2.20, another host on the same /24, succeed; pings to 10.0.2.1 fail with 'Destination Host Unreachable'. What does the INCOMPLETE entry establish?
MCQ-21A server NIC and a switch port are linked at 1 Gbps. Throughput on the server sits near 40 Mbps with heavy TCP retransmissions. `ethtool -S` on the server shows late collisions and CRC errors climbing steadily; the switch port reports no collisions and no drops. Which action fits this counter pattern?
MCQ-25A 48-port access switch has two uplinks to the same distribution switch. It drops all connectivity for one VLAN for 30–90 seconds at a time, and uplink captures during an outage show broadcast frames at roughly 40,000 pps against a 200 pps baseline with the switch's management CPU pinned at 100%. Which further evidence confirms a layer-2 loop?
MCQ-4A Linux router uses policy routing. Its rules and tables are: ``` ip rule 100: from 10.1.0.0/16 lookup 100 200: from 10.1.2.0/24 lookup 200 300: from 10.1.2.5 lookup 300 32766: from all lookup main ip route show table 100 10.20.0.0/16 via 10.0.0.2 dev eth1 ip route show table 200 10.20.0.0/16 via 10.0.0.5 dev eth3 ip route show table 300 10.20.0.0/16 via 10.0.0.7 dev eth4 ip route show table main 10.20.0.0/8 via 10.0.0.3 dev eth2 default via 10.0.0.1 dev eth0 ``` A packet from 10.1.2.5 to 10.20.5.7 is leaving via an interface the operator did not expect. Which next hop does the kernel actually use for this packet?
MCQ-23A host self-assigns 169.254.73.10/16 and has no default route. The DHCP server sits in a different subnet, reached through the relay agent. Captures on the host's NIC and on the relay agent's client-facing interface both show the same DHCPDISCOVERs, and neither shows a DHCPOFFER. Which capture next separates a fault in the relay's forwarding from a fault at the DHCP server or in its scope?
MCQ-24A dual-stack service answers on both address families. From one client host, `curl -4 https://api.example.com/health` returns 200 in 20 ms, but `curl -6` prints `curl: (28) Failed to connect to api.example.com port 443 after 30000 ms: Timeout was reached`. The client has a working IPv6 default route, and `ping6` to the server's IPv6 address returns replies. Which cause fits these observations?
MCQ-19An eBGP session between two directly connected routers stays down. Which observation confirms the failure is TCP/IP reachability rather than an ASN or authentication mismatch?
MCQ-18A BGP session between your edge router and a provider flaps every 40-90 minutes. Each time, the session recovers on its own within about 30 seconds, and the provider's NOC confirms no maintenance or config change on their side. You have a change window in six hours and are tempted to clear the BGP session now to see whether the flapping stops. What should you do before clearing the session?
MCQ-16You are writing the capture record for an incident review. The capture was taken on a Linux host with `tcpdump -i eth0 -s 96 -w trace.pcap 'tcp port 443'`; tcpdump reported 0 drops. The application team says the server sent a 1500-byte response, but the capture shows that packet as 96 bytes. Which detail must the record include to explain the discrepancy?
MCQ-7A client at 10.0.0.5 sends one 1460-byte segment to 10.0.0.9:443 and then has nothing more to send. Its capture shows that segment (seq=1, len=1460) leaving at t=0.000 and the same segment leaving again at t=1.001, with no ACK in between; the SRTT measured on the connection is 63 ms. Both hosts are NTP-synced to within a few milliseconds, and a capture at the server shows that segment arriving at t=0.031 and an ACK with ack=1461 leaving at t=0.032. Given both captures, which conclusion about the retransmission at t=1.001 is correct?
MCQ-8An established TCP connection between a client and a server stalls. The client's socket receive buffer is 128 KB and the client application has been blocked for 4 seconds in a downstream call. The server's most recent segment advertised Window=0; every 5 seconds the server sends a 1-byte probe, and the client ACKs each probe with Window=0. The server's send buffer still holds 40 KB of unacknowledged application data. Which diagnosis fits this capture?
MCQ-13A single TCP flow runs between two hosts over a WAN path with a measured 80 ms RTT and no packet loss. Both NICs are 1 Gbps, the sender's socket buffer is 4 MB, and the receiver advertises a steady 256 KiB window (window scaling enabled). iperf3 reports a steady 26 Mbps. What is the binding constraint on this flow?
MCQ-11A server with MTU 1500 sends a 10 MB HTTP response. tcpdump on the server shows TCP segments of 32768 and 65536 bytes with the DF bit set. A simultaneous capture on a SPAN port of the top-of-rack switch shows only frames of 1514 bytes or less; the SPAN port is not configured for truncation. Path MTU to the client is 1500. What explains the difference?
MCQ-10A 2 MB file download from a server behind an IPsec tunnel completes the TCP and TLS handshakes, then stalls. The server's NIC MTU is locked at 1500 bytes and cannot be changed. The underlay provider link is also 1500 bytes and cannot be raised. The tunnel adds 54 bytes of ESP and outer IP overhead. tcpdump on the server shows the same 1500-byte IP packet with 1460 bytes of TCP payload retransmitted six times. ICMP Type 3 Code 4 messages from the tunnel endpoint are dropped by an upstream ACL the provider will not change. The client is a third-party device you cannot configure. You control only the server and the tunnel endpoints. Which change restores the download?
MCQ-2A client at 10.0.1.10 connects to 198.51.100.1:443, a firewall VIP that destination-NATs to server 203.0.113.10. The client's tcpdump shows SYN, then SYN-ACK from 203.0.113.10, then RST from the client. The forward path goes through the firewall; the return path goes through a router that bypasses it. What does drawing both paths show?
MCQ-5A client cannot reach `api.example.com`. Its resolver returns 203.0.113.10, a shared edge that terminates TLS for about 40 hostnames and selects the backend from the SNI name and the Host header. `curl https://203.0.113.10/orders` returns 404 with a JSON body naming a different tenant, while `curl --resolve api.example.com:443:203.0.113.10 https://api.example.com/orders` returns 200. What does the 404 show?
MCQ-9A service at api.example.com runs nginx with `ssl_certificate` pointing at the leaf certificate only; the intermediate CA is not in the file. Chrome on a developer laptop loads https://api.example.com with no warning. A Go 1.21 program on a VPC host, whose trust store holds the same root CA as Chrome's, fails the handshake with `x509: certificate signed by unknown authority`. What explains the difference?
MCQ-6A load balancer health check opens a TCP connection to a backend on port 8080, then closes it without sending any data. The check passes, but users still get HTTP 503s. What does the passing check prove about that backend?
MCQ-15An order service keeps a pool of 20 long-lived TCP connections to a Postgres writer, all egressing a managed NAT gateway whose TCP idle timeout is 350 s and cannot be reconfigured. Keepalive is off on the client and the pool holds a connection idle for up to 900 s. Under steady traffic nothing fails; after a 10-minute quiet stretch the next 20 queries each fail once, one per pooled socket, and every retry on a fresh connection succeeds. Which change removes those failures?
MCQ-1A checkout service on Kubernetes 1.28 runs 3 replicas of an API pod. Each pod's container spec sets `resources.limits.cpu: 500m` and sets no `resources.requests.cpu`. The HPA is configured with `targetCPUUtilizationPercentage: 70`, `minReplicas: 3`, `maxReplicas: 10`. Every day at 09:00 UTC p99 latency climbs from 120 ms to 900 ms and `kubectl top pods` reports each API pod at 498-500m CPU. The replica count stays at 3 for the whole 20-minute spike. What is the most likely reason the HPA never scales out?
MCQ-14A gateway queues requests in front of a worker pool that drains 1,000 req/s. A 2-second burst arrives at 1,500 req/s. With the queue capped at 100 requests, p99 latency is 40 ms and 0.1% of requests are dropped. The team proposes raising the cap to 10,000 to stop the drops. What should they expect?
MCQ-22During a 09:00–09:20 UTC window, a gRPC service's client-observed p99 RPC latency jumps from 120 ms to 900 ms. Server-side handler p99 stays flat at 130 ms, DNS resolution p99 is 5 ms, and TCP retransmits on the client→server path rise from 0.1% to 4.8%. Which conclusion does this metric set support?
MCQ-12A checkout service's p99 end-to-end latency jumped from 220 ms to 1.4 s after a deploy, but the server-side handler timer still reports 180 ms and the load balancer's upstream response time is unchanged. The team needs to find which hop added the ~1.2 s. What should they do first?
MCQ-17A payments service shows p99 latency of 180 ms on the `checkout` endpoint, but only for requests routed through the `eu-west` cluster; the `us-east` cluster serves the same code at 45 ms p99. Both clusters run build 4.7.2, both hit the same Postgres primary, and both report identical CPU and memory. The on-call engineer wants to compare a single slow `eu-west` request against a single fast `us-east` request, capturing the full span tree for each. What does that comparison actually establish?
MCQ-20You mirror a 10 GbE server uplink to a 1 GbE capture host. Wireshark's capture statistics report 1,884,201 packets captured and 412,776 dropped. The trace shows a 60 ms gap in one TCP flow's sequence numbers. Which check settles whether those missing segments were lost on the wire or dropped by the capture path?