KCNA Cloud Native Architecture Practice Question
Which TWO of the following are principles of the 12-factor app? (Choose two.)
⚠ Common exam trap
CNCF often tests the 12-factor app principles by pairing a correct principle like 'Config' with a plausible-sounding but incorrect option like 'Stateful sessions', exploiting the common misconception that statefulness is acceptable in cloud-native apps when in fact it must be externalized.
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
✓
Config
Config is a core principle of the 12-factor app methodology, which mandates strict separation of configuration from code. Configuration (such as database URLs, credentials, or hostnames) must be stored in environment variables, not hardcoded in the application source. This allows the same codebase to be deployed across different environments (development, staging, production) without modification, adhering to the principle of config-driven behavior.
Answer analysis
Option-by-option breakdown
For each option: why learners choose it and why it is or isn't the right answer here.
- ✗
Monolithic deployment
Why it's wrong here
Not a principle.
- ✗
Stateful sessions
Why it's wrong here
Statelessness is preferred.
- ✓
Config
Why this is correct
Config is a 12-factor principle.
- ✓
Disposability
Why this is correct
Disposability is a 12-factor principle.
- ✗
Manual provisioning
Why it's wrong here
Automation is preferred.
Go deeper
Related to this question
About these practice questions
Courseiva writes every KCNA question from scratch — 930 in total, each with an explanation and a wrong-answer breakdown. None are copied from real exams or dumps. Learn why practice questions differ from exam dumps →
Same concept, more angles
2 more ways this is tested on KCNA
These questions test the same concept from different angles. Work through them to make sure you can recognise it however the exam phrases it.
Variation 1. Which TWO of the following are core principles of the 12-factor app? (Choose 2.)
medium- A.Shared state
- B.Manual deployment
- ✓ C.Dependencies
- D.Singleton processes
- ✓ E.Config
Why C: Option C (Dependencies) is correct because the 12-factor app's Dependencies principle requires applications to explicitly declare and isolate all dependencies via a dependency declaration manifest (e.g., requirements.txt, Gemfile, package.json) and a dependency isolation tool (e.g., virtualenv, Bundler), so the app never relies on implicit system-wide packages. Option E (Config) is correct because the Config principle mandates storing configuration in environment variables rather than in code or checked-in files, keeping config strictly separate from the codebase so the same build can be deployed across environments. The unmarked options do not belong: Shared state (A) contradicts the stateless processes principle, which requires sharing nothing between processes and externalizing state to backing services; Manual deployment (B) contradicts the Build/Release/Run and CI/CD automation principles; and Singleton processes (D) contradicts the concurrency principle, which favors scaling out via multiple stateless processes rather than relying on a single long-lived instance.
Variation 2. Which TWO of the following are principles of the 12-factor app methodology? (Choose two.)
medium- A.Perform manual deployment to avoid automation errors
- B.Maximize robustness through stateful sessions
- ✓ C.Ensure fast startup and graceful shutdown (disposability)
- D.Build monolithic applications for simplicity
- ✓ E.Store configuration in environment variables
Why C: Option C is correct because the 12-factor methodology's Disposability factor explicitly requires processes to start fast and shut down gracefully, enabling rapid scaling, quick deployment of new code, and resilience to sudden termination. Option E is correct because the Config factor mandates storing configuration in the environment (environment variables) rather than in code, so the same build can be deployed across environments without modification. Option A is wrong because 12-factor apps favor automated, repeatable deployments and CI/CD, not manual deployment. Option B is wrong because 12-factor apps should be stateless processes, storing any needed state in backing services such as databases or caches, not in sticky sessions. Option D is wrong because 12-factor apps are typically decomposed into smaller, independent services rather than built as a single monolith.
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.