200-901 Network Fundamentals Practice Question
A developer is building a Python application that must connect to a REST API hosted on a server. The API requires a persistent connection and the ability to send multiple requests without re-establishing a TCP handshake each time. The developer wants to minimize latency. Which HTTP feature should the application leverage?
⚠ Common exam trap
Many exam-takers confuse HTTP pipelining with persistent connections; pipelining is an extension that still requires keep-alive and is not the primary mechanism for connection reuse.
Answer choices
Why each option matters
Answer the question above first, then reveal the full breakdown to understand why each option is right or wrong.
Correct answer & explanation
✓
HTTP persistent connections (keep-alive)
Persistent connections, enabled by the Connection: keep-alive header in HTTP/1.1, allow a client to reuse an existing TCP connection for multiple requests. This reduces latency by eliminating repeated TCP and TLS handshakes. While HTTP/2 multiplexing also improves efficiency, it requires server support and is not the basic feature described. The other options do not directly address the need for connection reuse.
Answer analysis
Option-by-option breakdown
For each option: why learners choose it and why it is or isn't the right answer here.
- ✓
HTTP persistent connections (keep-alive)
Why this is correct
HTTP persistent connections, also known as keep-alive, allow multiple HTTP requests and responses to be sent over a single TCP connection. This avoids the overhead of establishing a new TCP handshake for each request, reducing latency and improving performance for applications that make frequent API calls to the same server.
- ✗
HTTP pipelining
Why it's wrong here
HTTP pipelining allows a client to send multiple requests without waiting for each response, but it still uses a single TCP connection and is not widely supported due to head-of-line blocking issues. It does not inherently provide the persistent connection benefit; it relies on keep-alive. Modern applications typically avoid pipelining in favor of multiplexing.
- ✗
HTTP/2 multiplexing
Why it's wrong here
HTTP/2 multiplexing allows multiple concurrent requests over a single connection, but the scenario does not specify that the server supports HTTP/2. The question asks for a feature to minimize latency with a persistent connection; keep-alive is the foundational HTTP/1.1 feature that achieves this without requiring protocol upgrade.
- ✗
HTTP cookies
Why it's wrong here
HTTP cookies are used to maintain state between requests, such as session management, but they do not affect connection persistence or latency. Cookies are sent as headers and do not reduce the number of TCP handshakes; they are unrelated to connection reuse.
Visual reference
Go deeper
Related to this question
About these practice questions
This 200-901 question is part of Courseiva's 975-question bank — original exam-style content with full explanations and wrong-answer analysis, never real exam questions or exam dumps. Learn why practice questions differ from exam dumps →
JA
Written and reviewed by Johnson Ajibi, MSc IT Security
Senior Network & Security Engineer · founder of Courseiva
Last reviewed September 2026 · checked against the official Cisco exam blueprint
This 200-901 practice question is part of Courseiva's free Cisco certification practice question bank. Courseiva provides original exam-style practice questions with explanations, topic-based practice, mock exams, readiness tracking, and study analytics to help learners prepare for the 200-901 exam.