Arcitura Certified Microservice Architect (S90.MSA) — Questions and Answers

Question 1: In distributed systems, why does the timeout budget need to be coordinated across a call chain?

So an upstream timeout isn't shorter than the sum of downstream timeouts, causing wasted work (Correct answer)
To make all services use the same language
To reduce the number of microservices
To synchronize clocks

Correct answer: So an upstream timeout isn't shorter than the sum of downstream timeouts, causing wasted work

Timeout budgets must decrease down the chain so callers don't give up while downstream calls still run and waste resources.

Question 2: What does 'smart endpoints and dumb pipes' advocate?

Keeping logic in services and using simple transport like HTTP/messaging (Correct answer)
Centralizing all routing logic in an ESB
Putting business logic in the message bus
Embedding orchestration in the network

Correct answer: Keeping logic in services and using simple transport like HTTP/messaging

Business logic lives in the services (smart endpoints), while the transport stays simple (dumb pipes).

Question 3: What does idempotency guarantee in service-to-service messaging?

Messages are never delivered
Zero network latency
Processing the same message multiple times has the same effect as once (Correct answer)
Strong ordering across all services

Correct answer: Processing the same message multiple times has the same effect as once

Idempotency ensures repeated delivery of the same message produces the same result, vital for at-least-once messaging.

Question 4: In the Saga pattern, what is a 'compensating transaction'?

A transaction that compensates employees
An operation that undoes the effect of a previously completed transaction (Correct answer)
A transaction that runs twice for redundancy
A backup of the entire database

Correct answer: An operation that undoes the effect of a previously completed transaction

Compensating transactions reverse prior steps when a later step in the saga fails, restoring consistency.

Question 5: Which is a recommended pattern for emitting logs from containerized microservices?

Write logs only to a local file inside the container
Write logs to stdout/stderr and let the platform collect them (Correct answer)
Store logs in application memory only
Email each log line

Correct answer: Write logs to stdout/stderr and let the platform collect them

Writing to stdout/stderr lets the orchestration platform capture and forward logs, following twelve-factor principles.

Question 6: Which pattern helps detect compromised or anomalous behavior across distributed microservices?

Removing request IDs from logs
Running each service on its own physical machine
Centralized security monitoring with distributed tracing and correlated logs (Correct answer)
Turning off all telemetry

Correct answer: Centralized security monitoring with distributed tracing and correlated logs

Correlated logs and distributed tracing across services enable detection of anomalous, distributed attacks.

Question 7: What is the purpose of a Kubernetes readiness probe?

Determine when a Pod can receive traffic (Correct answer)
Drain a node
Restart unhealthy containers
Scale the deployment

Correct answer: Determine when a Pod can receive traffic

A readiness probe signals when a Pod is ready to accept requests.

Question 8: Why is pipeline-as-code (e.g., YAML pipeline definitions) preferred over manual UI configuration?

It is faster to click through
It hides changes from review
It cannot be audited
It is version-controlled, reviewable, and reproducible (Correct answer)

Correct answer: It is version-controlled, reviewable, and reproducible

Defining pipelines as code makes them versioned, peer-reviewable, and reproducible alongside the application.

Question 9: An e-commerce platform uses a choreography-based Saga pattern to process new orders. The 'Order' service emits an 'OrderCreated' event. The 'Inventory' service listens for this event to reserve stock, and the 'Payment' service listens to it to process payment. What is a primary disadvantage of this choreographed approach compared to an orchestrated one?

It leads to tighter coupling between the services because they must directly call each other.
It introduces a single point of failure through a central coordinator.
The overall business transaction flow is not explicitly defined in one place, making it harder to monitor and debug. (Correct answer)
It cannot support compensating transactions to roll back the process in case of a failure.

Correct answer: The overall business transaction flow is not explicitly defined in one place, making it harder to monitor and debug.

In a choreography-based Saga, each service participates by reacting to events from other services. While this promotes loose coupling, it means the end-to-end business logic is distributed and not centrally defined. This makes it challenging to understand, monitor, and debug the entire workflow, as there is no single orchestrator that explicitly models the process.

Question 10: What is the main drawback of relying heavily on end-to-end tests in a microservices architecture?

They are slow, brittle, and difficult to maintain as the number of services grows (Correct answer)
They cannot be automated and require manual execution
They cannot find bugs that unit tests miss
They require contract files to be shared between teams

Correct answer: They are slow, brittle, and difficult to maintain as the number of services grows

End-to-end tests in microservices are notoriously slow and flaky because they depend on the availability and correct behavior of many services simultaneously, making them expensive to maintain.

Question 11: When the Circuit Breaker is in the 'half-open' state, what happens?

All requests pass freely
The service restarts
All requests are blocked permanently
A limited number of trial requests test if the dependency recovered (Correct answer)

Correct answer: A limited number of trial requests test if the dependency recovered

Half-open lets a few probe requests through to decide whether to close or re-open the breaker.

Question 12: What is a key advantage of an orchestration-based saga over choreography?

It removes the need for compensating transactions
Centralized coordination makes the workflow easier to understand and monitor (Correct answer)
It guarantees strong consistency
It eliminates network calls

Correct answer: Centralized coordination makes the workflow easier to understand and monitor

An orchestrator centralizes saga logic, improving visibility and control of the workflow.

Question 13: Containerization (e.g., Docker) benefits microservices by:

Eliminating version control
Forcing all services into one process
Removing the need for networking
Packaging each service with its dependencies for consistent, portable deployment (Correct answer)

Correct answer: Packaging each service with its dependencies for consistent, portable deployment

Containers bundle a service and its dependencies for consistent deployment across environments.

Question 14: What problem does the Circuit Breaker pattern primarily solve?

Discovering service instances
Splitting reads and writes
Storing event history
Preventing cascading failures from a failing dependency (Correct answer)

Correct answer: Preventing cascading failures from a failing dependency

A circuit breaker stops calls to a failing service to avoid resource exhaustion and cascading failure.

Question 15: What is the 'fail fast' principle in resilient design?

Detect failures quickly and return an error immediately rather than blocking (Correct answer)
Disable all error logging
Always retry until success
Delay all responses to batch them

Correct answer: Detect failures quickly and return an error immediately rather than blocking

Failing fast returns errors promptly instead of holding resources on doomed calls, keeping the system responsive.

Question 16: In a microservices architecture, what does the 'Database per Service' pattern primarily ensure?

All services share a single relational database
Services bypass APIs to query each other's tables
Each service owns and encapsulates its own data store (Correct answer)
Data is never persisted to disk

Correct answer: Each service owns and encapsulates its own data store

Database per Service gives each microservice exclusive ownership of its data, preventing tight coupling at the data layer.

Question 17: What does client-side service discovery require the client to do?

Send all traffic to a fixed IP
Avoid any registry
Query a registry and choose an instance itself (Correct answer)
Rely solely on DNS round-robin from the load balancer

Correct answer: Query a registry and choose an instance itself

In client-side discovery, the client looks up the registry and performs load balancing across instances.

Question 18: Which strategy updates Pods incrementally to avoid downtime during a deployment?

Cold restart
Rolling update (Correct answer)
Recreate
Manual swap

Correct answer: Rolling update

A rolling update replaces Pods gradually so the service stays available.

Question 19: In the third-party registration pattern, registration is handled by:

The end client
The service instance
A separate registrar (service manager) that tracks instances (Correct answer)
The load balancer's cache

Correct answer: A separate registrar (service manager) that tracks instances

A dedicated registrar component watches instances and registers/deregisters them.

Question 20: What is the main trade-off introduced by adopting CQRS?

Inability to scale reads
Loss of independent deployment
Mandatory shared database
Added complexity and eventual consistency between read and write models (Correct answer)

Correct answer: Added complexity and eventual consistency between read and write models

CQRS increases architectural complexity and the read model may lag the write model.

Question 21: A financial services application requires high-performance, low-latency communication between internal microservices for processing real-time stock trades. The services are developed in multiple programming languages (Polyglot). Which communication technology is best suited for this scenario?

gRPC with Protocol Buffers. (Correct answer)
REST over HTTP/1.1 with JSON payloads.
Asynchronous messaging via an email server.
SOAP with XML payloads.

Correct answer: gRPC with Protocol Buffers.

gRPC is designed for high-performance, low-latency communication and is ideal for internal microservice interactions. It uses HTTP/2 for transport and Protocol Buffers for efficient binary serialization, which is faster than text-based formats like JSON or XML. Its support for code generation across multiple languages makes it an excellent choice for polyglot environments.

Question 22: Which of the following describes the primary role of an API Gateway in a microservices architecture?

To act as a single entry point for clients, handling routing, security, and other cross-cutting concerns. (Correct answer)
To orchestrate complex, multi-service business transactions using the Saga pattern.
To provide a persistent storage layer shared by all microservices.
To manage the deployment and scaling of individual microservice instances.

Correct answer: To act as a single entry point for clients, handling routing, security, and other cross-cutting concerns.

The fundamental purpose of an API Gateway is to serve as a reverse proxy and unified entry point for all external client requests. It abstracts the underlying microservice architecture, routing requests to the appropriate services while handling concerns like authentication, rate limiting, and SSL termination. It decouples clients from the internal service structure. Service scaling, transaction orchestration, and data storage are handled by other components in the ecosystem (e.g., container orchestrators, the services themselves).

Question 23: Which pattern maintains a denormalized read model updated from events?

Ambassador
Strangler Fig
Materialized View (CQRS read model) (Correct answer)
Bulkhead

Correct answer: Materialized View (CQRS read model)

A materialized view precomputes a query-optimized read model kept current via events.

Question 24: Why is observability (metrics, logs, traces) critical to fault tolerance?

It encrypts all traffic
It eliminates the need for circuit breakers
It replaces the need for retries
It enables fast detection and diagnosis of failures so the system can react and recover (Correct answer)

Correct answer: It enables fast detection and diagnosis of failures so the system can react and recover

Observability surfaces failures quickly and pinpoints root causes, which is essential for both automated and human recovery.

Question 25: Which Kubernetes resource is designed to run a task to completion and then stop?

Service
Deployment
Job (Correct answer)
DaemonSet

Correct answer: Job

A Job creates Pods that run until a task completes successfully.

Question 26: Why are containers considered more lightweight than virtual machines?

They share the host OS kernel (Correct answer)
They require a hypervisor
They cannot be isolated
They include a full guest operating system

Correct answer: They share the host OS kernel

Containers share the host kernel, avoiding the overhead of a full guest OS per instance.

Question 27: A risk of DNS-based service discovery is that:

It only works in Kubernetes
Aggressive client-side DNS caching can mask instance changes (Correct answer)
It cannot return any IP
It requires no configuration

Correct answer: Aggressive client-side DNS caching can mask instance changes

Clients or libraries that cache DNS too long may keep using removed instances.

Question 28: What Kubernetes object stores non-confidential configuration data as key-value pairs?

Secret
ConfigMap (Correct answer)
ServiceAccount
Volume

Correct answer: ConfigMap

A ConfigMap holds non-sensitive configuration data injected into Pods.

Question 29: What is the primary advantage of using a Canary Release strategy when deploying a new version of a microservice?

It simplifies the CI/CD pipeline by eliminating the need for integration testing.
It allows for testing the new version with a small subset of live production traffic to minimize the impact of potential bugs. (Correct answer)
It updates all service instances simultaneously for the fastest possible deployment.
It requires maintaining two full production environments, increasing infrastructure cost.

Correct answer: It allows for testing the new version with a small subset of live production traffic to minimize the impact of potential bugs.

The main goal of a Canary Release is to mitigate risk by exposing a new version of a service to a small percentage of users first. This allows the team to monitor for errors, performance degradation, or negative user feedback in a controlled manner before rolling it out to the entire user base, thus limiting the 'blast radius' of any potential issues.

Question 30: A mobile application's main screen needs to display a user's profile, their last three transactions, and their loyalty status. This data resides in three separate microservices: 'User', 'Transaction', and 'Loyalty'. To minimize the number of network requests from the client device, which pattern should be implemented at the API Gateway?

API Composition (Aggregation) (Correct answer)
Gateway Offloading
Circuit Breaking
Rate Limiting

Correct answer: API Composition (Aggregation)

The API Composition (or Aggregation) pattern involves the API Gateway receiving a single request from a client and then invoking multiple downstream microservices. It aggregates the responses from these services into a single, consolidated response that is sent back to the client. This is highly effective for reducing the chattiness between the client and the backend, improving performance and simplifying client-side logic.

Question 31: When a gateway terminates TLS and forwards plain HTTP internally, this is known as:

TLS termination (Correct answer)
TLS passthrough
Mutual TLS
Certificate pinning

Correct answer: TLS termination

TLS termination decrypts incoming traffic at the gateway, offloading crypto work from backend services.

Question 32: What does a Kubernetes Service of type ClusterIP provide?

A public load balancer IP
An internal-only stable IP for Pods (Correct answer)
A node-level port on every host
External DNS registration

Correct answer: An internal-only stable IP for Pods

ClusterIP exposes the Service on an internal IP reachable only within the cluster.

Question 33: In microservices, what is the preferred way for services to communicate to maximize loose coupling?

Well-defined APIs and asynchronous messaging (Correct answer)
Global variables
Direct database reads
Shared in-memory objects

Correct answer: Well-defined APIs and asynchronous messaging

Loose coupling is achieved through explicit APIs and asynchronous, event-driven messaging.

Question 34: What is the main role of a service mesh sidecar in interservice communication?

Handling networking concerns like routing, retries, and mTLS transparently (Correct answer)
Compiling the application code
Generating the UI
Storing the service's database

Correct answer: Handling networking concerns like routing, retries, and mTLS transparently

A sidecar proxy offloads cross-cutting network concerns away from application code.

Question 35: In a social media application, the service responsible for handling user posts has significantly different requirements for writing data (creating a post) versus reading data (viewing a feed). The read operations are far more frequent and require complex queries and denormalized views for performance, while write operations are simpler but must be highly consistent. Which pattern would be most effective for optimizing these distinct workloads?

Saga Pattern
API Gateway
Service Discovery
Command Query Responsibility Segregation (CQRS) (Correct answer)

Correct answer: Command Query Responsibility Segregation (CQRS)

The Command Query Responsibility Segregation (CQRS) pattern separates the models for updating data (Commands) from the models for reading data (Queries). This allows the read and write sides to be scaled, optimized, and developed independently. For example, the write side can use a normalized schema for consistency, while the read side can use a denormalized view optimized for fast queries.

Question 36: Which pattern is commonly used to maintain data consistency across services without distributed transactions?

Saga pattern (Correct answer)
Two-phase commit lock
Synchronous join query
Global table lock

Correct answer: Saga pattern

The Saga pattern coordinates a sequence of local transactions with compensating actions instead of a distributed transaction.

Question 37: What is 'property-based testing' and how does it benefit microservices?

Testing only the public properties of service objects
Automatically generating a wide range of inputs to verify that service properties hold true across all of them (Correct answer)
Testing services based on their OpenAPI property definitions
Checking that service configurations match expected property files

Correct answer: Automatically generating a wide range of inputs to verify that service properties hold true across all of them

Property-based testing generates many random inputs and verifies that defined properties (invariants) always hold, catching edge cases that hand-written example tests often miss.

Question 38: Which Kubernetes resource exposes HTTP routes from outside the cluster to Services?

ConfigMap
ReplicaSet
PersistentVolume
Ingress (Correct answer)

Correct answer: Ingress

An Ingress manages external HTTP/HTTPS access and routing to internal Services.

Question 39: A development team is working on a legacy monolithic application and wants to gradually migrate its functionality to a new microservices architecture without performing a risky 'big bang' rewrite. They plan to incrementally build new microservices and route traffic to them, while the old monolith continues to handle the remaining functionality. Which pattern facilitates this gradual migration strategy?

API Composition Pattern
Strangler Fig Pattern (Correct answer)
Circuit Breaker Pattern
Sidecar Pattern

Correct answer: Strangler Fig Pattern

The Strangler Fig pattern is an architectural approach for incrementally migrating a legacy system. It involves creating a new application (the 'strangler') around the old one and gradually replacing pieces of the monolith's functionality with new microservices. An intermediary layer, often a proxy or API gateway, intercepts requests and routes them to either the new microservice or the old monolith, allowing for a safe, phased migration.

Question 40: Which of the following is a primary benefit of implementing the 'Database per Service' design pattern in a microservices architecture?

Guaranteed immediate consistency across all microservices.
Increased service autonomy and loose coupling. (Correct answer)
Simplified cross-service data queries and joins.
Reduced operational complexity from managing multiple databases.

Correct answer: Increased service autonomy and loose coupling.

The Database per Service pattern ensures that each microservice has its own private database, which is not accessible by other services. This enforces loose coupling, as changes to one service's database schema do not directly impact others. It grants each service the autonomy to choose its own database technology and evolve independently.

Question 41: What does a multi-stage Docker build primarily help achieve?

Faster container startup
Built-in service discovery
Automatic horizontal scaling
Smaller final image size (Correct answer)

Correct answer: Smaller final image size

Multi-stage builds discard build-time dependencies, producing a leaner final image.

Question 42: The Anti-Corruption Layer (ACL) primarily exists to do what?

Encrypt all traffic
Translate between a service's model and a legacy or external model (Correct answer)
Discover service endpoints
Cache query results

Correct answer: Translate between a service's model and a legacy or external model

An ACL isolates a service from foreign models by translating at the boundary.

Question 43: A development team has deployed a containerized microservice for processing user payments. During peak hours, the service experiences high load, leading to slow response times. The team needs a solution that automatically increases the number of running container instances based on CPU utilization and restarts any instances that become unresponsive. Which container orchestration features directly address these requirements?

Persistent Volume and StatefulSet
Dockerfile and Container Registry
Ingress Controller and Service Mesh
Horizontal Pod Autoscaler (HPA) and Liveness Probes (Correct answer)

Correct answer: Horizontal Pod Autoscaler (HPA) and Liveness Probes

The Horizontal Pod Autoscaler (HPA) is a Kubernetes feature that automatically scales the number of pod replicas in a deployment based on observed metrics like CPU utilization. Liveness probes are used by the orchestrator to check if a container is still running and responsive; if a probe fails, the container is restarted, ensuring self-healing.

Question 44: A microservice needs to handle cross-cutting concerns like collecting detailed logs and metrics without bloating the primary application's code. The team wants to deploy a separate, specialized container for these tasks alongside every instance of the main microservice, sharing the same network space and lifecycle. Which container design pattern is best suited for this scenario?

Strangler Fig Pattern
Blue/Green Deployment
Sidecar Pattern (Correct answer)
Ambassador Pattern

Correct answer: Sidecar Pattern

The Sidecar pattern involves co-locating a helper container with the main application container (often in the same Kubernetes Pod). This allows the sidecar to augment the main application by handling tasks like logging, monitoring, or acting as a proxy, without being tightly coupled to the application's code.

Question 45: What is the primary benefit of a canary release in a microservices system?

Exposing the new version to a small subset of users to limit blast radius (Correct answer)
Deploying to every instance simultaneously for speed
Avoiding any need to roll back
Eliminating the need for monitoring

Correct answer: Exposing the new version to a small subset of users to limit blast radius

Canary releases route a small percentage of traffic to the new version so problems affect few users before full rollout.

Question 46: What is the 'dual-write problem' in microservices data management?

Using two databases for backup
Writing the same file twice to disk
The risk of inconsistency when writing to a database and a message broker separately (Correct answer)
Writing logs in two formats

Correct answer: The risk of inconsistency when writing to a database and a message broker separately

Dual writes can fail partway, leaving the database and message broker out of sync without an atomic mechanism.

Question 47: What is the difference between monitoring and observability?

Monitoring requires no metrics
Observability only applies to databases
They are identical terms
Monitoring tracks known failure modes; observability helps explore unknown ones (Correct answer)

Correct answer: Monitoring tracks known failure modes; observability helps explore unknown ones

Monitoring watches predefined conditions, while observability lets you ask new questions about unexpected behavior.

Question 48: The Ambassador pattern typically handles what for a service?

Rendering HTML
Managing database schemas
Offloading network tasks like retries and routing to a proxy (Correct answer)
Persisting domain events

Correct answer: Offloading network tasks like retries and routing to a proxy

An ambassador proxy handles connectivity concerns on behalf of the main service.

Question 49: Which Kubernetes object stores sensitive data such as passwords in base64-encoded form?

ConfigMap
Ingress
Volume
Secret (Correct answer)

Correct answer: Secret

A Secret holds sensitive information like credentials and tokens.

Question 50: What is the purpose of a dead-letter queue in event-driven data flows?

To speed up message delivery
To store database backups
To delete all failed messages permanently
To hold messages that cannot be processed successfully for later inspection (Correct answer)

Correct answer: To hold messages that cannot be processed successfully for later inspection

A dead-letter queue captures unprocessable messages so they can be analyzed and retried without blocking the main flow.

Arcitura Certified Microservice Architect (S90.MSA)

The S90.MSA certification validates expertise in microservice architecture design patterns, containerization, data management, CI/CD deployment strategies, and API gateway management across cloud-native environments.

Questions

170 min

Time Limit

80%

To Pass

Checking for saved progress...

Exam Rules

You can skip questions and return to them later
Flag questions for review before submitting
No feedback shown until you submit the entire exam
Unanswered questions count as wrong — answer everything
10 pretest questions are mixed in and don't affect your score
Timer auto-submits when time runs out
Your progress is auto-saved every 30 seconds