CV0-004 Cloud Architecture and Design Practice Question
A cloud architect is designing a microservices-based application that requires inter-service communication. The services must be loosely coupled, and the architecture must handle service failures gracefully. Which communication pattern is most appropriate?
⚠ Common exam trap
The trap here is thinking that synchronous calls with retries or timeouts provide sufficient decoupling, when they still create runtime dependencies that can propagate failures.
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
✓
Asynchronous messaging using a message queue or pub/sub system.
Asynchronous messaging decouples services and allows them to operate independently, with messages buffered during failures. This ensures that a service outage does not immediately impact others, providing resilience and loose coupling, which are critical for microservices architectures.
Answer analysis
Option-by-option breakdown
For each option: why learners choose it and why it is or isn't the right answer here.
- ✓
Asynchronous messaging using a message queue or pub/sub system.
Why this is correct
Asynchronous messaging decouples services by allowing them to communicate via messages without waiting for immediate responses. If a service fails, messages can be queued and processed later, providing graceful failure handling. This pattern promotes loose coupling and resilience, making it the most appropriate for the scenario.
- ✗
Remote procedure calls (RPC) with timeouts.
Why it's wrong here
RPC with timeouts is still synchronous and tightly couples services. While timeouts prevent indefinite waiting, the caller must handle failures, and cascading failures can occur if timeouts are not tuned properly. This pattern does not provide the loose coupling and graceful failure handling required.
- ✗
Shared database with direct reads and writes.
Why it's wrong here
A shared database tightly couples services because they depend on the same schema and data. Changes to the database can impact multiple services, and failures in one service can affect others. This pattern does not handle service failures gracefully and violates loose coupling principles, making it unsuitable.
- ✗
Synchronous HTTP/REST calls between services.
Why it's wrong here
Synchronous HTTP/REST calls create tight coupling because the caller must wait for a response and handle failures immediately. If a service is down, the caller may fail or need retry logic, which can cascade failures. This pattern does not gracefully handle service failures and increases coupling, contrary to the requirements.
Go deeper
Related to this question
About these practice questions
One of 834 original CV0-004 practice questions on Courseiva, each with a full explanation and wrong-answer analysis — not exam dumps or protected exam content. 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 CompTIA exam blueprint
This CV0-004 practice question is part of Courseiva's free CompTIA 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 CV0-004 exam.