KCNA Cloud Native Architecture Practice Question
Which THREE are typical characteristics of a cloud-native application?
⚠ Common exam trap
CNCF often tests the misconception that cloud-native apps are just 'apps in the cloud' rather than specifically requiring containerization, microservices, and horizontal scaling; candidates may mistakenly associate long startup times or fragility with cloud-native, when those are anti-patterns.
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
✓
Packaged as lightweight containers
Option C is correct because cloud-native applications are typically packaged as lightweight containers (e.g., Docker images orchestrated by Kubernetes), which enables portability, fast startup, and consistent deployment across environments. Option D is correct because cloud-native design favors horizontal scaling—adding more stateless instances behind a load balancer—rather than scaling up a single large server, allowing elasticity to match demand. Option E is correct because cloud-native applications are commonly built using a microservices architecture, where loosely coupled, independently deployable services communicate over lightweight protocols such as HTTP/REST or gRPC. Option A is not typical, since cloud-native apps aim for fast startup and rapid initialization to support scaling and resilience. Option B is not a characteristic but a risk; cloud-native patterns like circuit breakers, retries, and bulkheads are used specifically to prevent cascading failures.
Answer analysis
Option-by-option breakdown
For each option: why learners choose it and why it is or isn't the right answer here.
- ✗
Long startup times due to heavy initialization
Why it's wrong here
Cloud-native applications are designed for fast startup and rapid scaling, so heavy initialisation delaying startup contradicts the model. It tempts because some frameworks do carry warm-up costs, but that is an anti-pattern cloud-native design explicitly avoids through statelessness and small images.
- ✗
Vulnerable to cascading failures
Why it's wrong here
Cascading failures describe a resilience weakness, not a cloud-native characteristic; cloud-native design targets fault isolation, retries, and graceful degradation. It tempts because distributed microservices can propagate failures, but the characteristic sought is resilience, not vulnerability.
- ✓
Packaged as lightweight containers
Why this is correct
Lightweight containers bundle the application and its dependencies into a single immutable image, so it starts consistently across any host. This satisfies the stem's cloud-native expectation of rapid, portable deployment and horizontal scaling, unlike monolithic virtual machines that carry a full guest operating system.
- ✓
Designed for horizontal scaling
Why this is correct
Horizontal scaling lets cloud-native workloads add identical stateless instances across nodes rather than resizing a single machine, directly satisfying the stem's elasticity and resilience expectations. Kubernetes orchestrates these replicas, distributing load and replacing failed pods automatically, so capacity tracks demand without downtime.
- ✓
Built using microservices architecture
Why this is correct
Microservices architecture decomposes functionality into independently deployable services, each owning its data and lifecycle. This satisfies cloud-native expectations of loose coupling, horizontal scalability and resilience, since services scale and fail in isolation rather than as one monolithic unit. Kubernetes orchestrates such containers, matching the exam's emphasis on dynamic, distributed cloud-native design.
Go deeper
Related to this question
Learn chapter
Cluster Architecture and Lifecycle Management
Key term
ReplicaSet and Replication
A ReplicaSet ensures a specified number of identical pod instances are running at all times in Kubernetes, using replication to maintain availability and stability.
Key term
Microservices Architecture
Microservices architecture is a way of building software as a collection of small, independent services that each handle one specific business function and communicate over a network.
About these practice questions
This KCNA question is part of Courseiva's 930-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 by Johnson Ajibi, MSc IT Security
Senior Network & Security Engineer · founder of Courseiva
This KCNA practice question is part of Courseiva's free CNCF 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 KCNA exam.