I85PREP
⌘ K
IBM DevOps and Software Engineering study materials
IBM DevOps and Software Engineering study resources

IBM DevOps and Software Engineering practice questions

One question at a time. Build your IBM DevOps and Software Engineering understanding.

First 50 of 200 questions. Each one lists the choices, the correct answer, and an explanation. The checker at the top of this page saves progress in this browser when it is available.

Continue in the practice tool above to load more questions, 50 at a time.

Question 1DevOps and Software Engineering Fundamentals

A team practicing DevOps wants to shorten the time between committing code and having it run in production. Which practice most directly measures and improves that goal?

  1. Tracking lead time for changes and reducing batch size Correct answer.
  2. Increasing the number of manual test gates
  3. Separating development and operations into distinct reporting lines
  4. Requiring monthly change advisory board sign-off

Explanation

Lead time for changes is a core DORA metric that captures how long a commit takes to reach production. Reducing batch size shortens feedback loops and lowers integration risk, which directly improves that metric.

Question 2DevOps and Software Engineering Fundamentals

Which statement best captures the core idea of continuous integration?

  1. A nightly job packages the codebase once per day for QA
  2. Developers merge to a shared mainline frequently and each merge triggers automated build and tests Correct answer.
  3. Feature branches stay open for the length of a release cycle to avoid conflicts
  4. Operators deploy every build to production as soon as it compiles

Explanation

Continuous integration means integrating work into a shared mainline often, with automated build and test feedback on each integration. The frequent merge plus automated verification is what keeps integration problems small.

Question 3DevOps and Software Engineering Fundamentals

A pipeline fails at the unit test stage. According to shift-left principles, what is the primary benefit of catching this at that stage rather than in production?

  1. Test coverage becomes irrelevant once unit tests pass
  2. Defects are cheaper to fix the earlier they are detected Correct answer.
  3. The operations team can be eliminated from the release process
  4. Production monitoring tools are no longer needed

Explanation

Shift-left moves verification earlier in the lifecycle because the cost and risk of a defect grow the later it is found. A unit-test failure is fast and cheap to diagnose compared with an incident in production.

Question 4DevOps and Software Engineering Fundamentals

Which artifact is the primary output of a CI build that a later deployment stage consumes?

  1. A wiki page describing the architecture
  2. A developer's local working directory snapshot
  3. A screenshot of the passing test run
  4. An immutable build artifact stored in a repository with a unique version Correct answer.

Explanation

CI produces a versioned, immutable artifact that downstream stages promote unchanged. Immutability and unique versioning let you trace exactly what was tested and deployed.

Question 5DevOps and Software Engineering Fundamentals

A team adopts infrastructure as code. Which benefit most directly follows from storing environment definitions in version control?

  1. Application code no longer needs automated tests
  2. Environments become reproducible and changes are auditable Correct answer.
  3. Servers no longer require any configuration management
  4. Manual console changes become the preferred workflow

Explanation

Version-controlled infrastructure definitions make environments reproducible and give every change a reviewable history. That auditability and repeatability are the central advantages of infrastructure as code.

Question 6DevOps and Software Engineering Fundamentals

What distinguishes continuous delivery from continuous deployment?

  1. Continuous delivery requires no automated tests while continuous deployment requires full coverage
  2. Continuous delivery deploys to production automatically while continuous deployment requires human sign-off
  3. Continuous delivery keeps every change releasable but may require a manual approval to deploy; continuous deployment releases automatically Correct answer.
  4. Continuous delivery applies only to infrastructure while continuous deployment applies only to applications

Explanation

Both practices keep the mainline in a deployable state. Continuous delivery stops short of automatic production release, while continuous deployment removes the manual gate and releases every passing change.

Question 7DevOps and Software Engineering Fundamentals

An organization wants to reduce mean time to recovery for production incidents. Which DevOps practice most directly supports that outcome?

  1. Small, frequent, reversible deployments with automated rollback Correct answer.
  2. Removing observability tooling to simplify the stack
  3. Longer release cycles with larger batches
  4. Centralizing all deploys through a single weekly window

Explanation

Small reversible changes limit the blast radius of a failure, and automated rollback shortens recovery. Together they reduce the time to restore service after an incident.

Question 8DevOps and Software Engineering Fundamentals

A pipeline runs lint, unit tests, integration tests, and security scans. Which ordering best reflects an efficient feedback design?

  1. Run all stages in parallel regardless of dependencies
  2. Run integration tests before linting to validate real behavior first
  3. Run the fastest, cheapest checks first and gate slower stages on their success Correct answer.
  4. Run the slowest security scans first so they never block later stages

Explanation

Fast checks give quick feedback and fail early, so expensive stages only run when the cheap ones pass. This minimizes wasted compute and shortens the time a developer waits for a verdict.

Question 9DevOps and Software Engineering Fundamentals

A developer's change passes locally but fails in CI because of an environment difference. Which practice most directly prevents this class of failure?

  1. Allowing each developer to customize their CI runner
  2. Running builds and tests in containerized, version-pinned environments Correct answer.
  3. Skipping CI for changes that pass locally
  4. Storing secrets in the repository to simplify configuration

Explanation

Containerized, version-pinned build environments remove drift between local and CI execution. Consistent tooling versions make failures reproducible and attributable to the code.

Question 10DevOps and Software Engineering Fundamentals

Which practice best embodies the DevOps principle of cross-functional ownership?

  1. Development and operations share responsibility for running the service in production Correct answer.
  2. Quality assurance owns release decisions independently of both teams
  3. A separate team owns every deployment to enforce separation
  4. Operations owns all production issues while developers own only code

Explanation

DevOps dissolves the wall between building and running software by making teams jointly accountable for production outcomes. Shared ownership encourages designs that are operable and observable.

Question 11DevOps and Software Engineering Fundamentals

A team wants to detect configuration drift between the declared infrastructure state and what is actually running. Which approach fits best?

  1. Rebuild the entire environment only once per year
  2. Periodically compare live resources against the version-controlled definition and reconcile differences Correct answer.
  3. Disable change tracking to reduce pipeline noise
  4. Rely on engineers to remember which manual changes they made

Explanation

Drift detection compares actual state to declared state and surfaces or corrects divergence. Reconciliation keeps the running environment aligned with the reviewed source of truth.

Question 12DevOps and Software Engineering Fundamentals

Which DORA metric is calculated as the proportion of changes deployed that result in degraded service and require remediation?

  1. Deployment frequency
  2. Lead time for changes
  3. Change failure rate Correct answer.
  4. Time to restore service

Explanation

Change failure rate measures the share of deployments that cause impairment and need a fix, hotfix, or rollback. It complements throughput metrics by capturing stability.

Question 13DevOps and Software Engineering Fundamentals

A team wants trunk-based development to work while still allowing code review. Which practice supports this?

  1. Short-lived feature branches merged within a day or two, backed by feature flags Correct answer.
  2. Direct commits to production without any review
  3. Separate repositories per developer
  4. Long-lived branches that live for the whole quarter

Explanation

Trunk-based development relies on small, short-lived branches merged quickly into the mainline. Feature flags let incomplete work ship safely without long-lived branches.

Question 14DevOps and Software Engineering Fundamentals

An application must be resilient to a single availability zone failure. Which design choice most directly achieves that?

  1. Deploy instances across multiple availability zones behind a load balancer Correct answer.
  2. Increase the instance size in a single zone
  3. Run all instances in one zone but add more of them
  4. Take more frequent backups of the single zone

Explanation

Spreading instances across zones removes the single point of failure that a zone outage represents. A load balancer routes traffic to healthy instances in surviving zones.

Question 15DevOps and Software Engineering Fundamentals

Which practice best supports the DevOps goal of fast, safe feedback on code quality before merge?

  1. Relying on the author's self-assessment alone
  2. Requiring automated status checks on pull requests before merge is allowed Correct answer.
  3. Reviewing code only after it has been deployed
  4. Merging first and running tests on the mainline only

Explanation

Automated status checks on pull requests block merges when quality gates fail, giving feedback before code reaches the mainline. This keeps the shared branch healthy.

Question 16DevOps and Software Engineering Fundamentals

A pipeline stores database credentials as plain environment variables in the repository's CI config file. What is the most appropriate remediation?

  1. Rotate the credentials only after an incident occurs
  2. Base64-encode the credentials in the config file
  3. Move secrets to a dedicated secrets manager and inject them at runtime Correct answer.
  4. Commit the credentials but restrict repo access to the team

Explanation

Secrets belong in a dedicated manager that injects them at runtime and controls access and rotation. Keeping them out of version control prevents leakage through history and forks.

Question 17DevOps and Software Engineering Fundamentals

Which characteristic most clearly indicates that a service is observable in a DevOps sense?

  1. It emits structured logs, metrics, and traces that let engineers diagnose issues without redeploying Correct answer.
  2. It writes a single log line at startup
  3. It exposes only a health check endpoint
  4. It relies on engineers to reproduce issues locally

Explanation

Observability comes from correlated logs, metrics, and traces that support diagnosis of unseen conditions. Rich telemetry lets teams understand production behavior without guessing or redeploying.

Question 18DevOps and Software Engineering Fundamentals

A team's deployment frequency is high but change failure rate is also high. Which interpretation is most consistent with DORA guidance?

  1. Throughput is strong but stability is weak, so quality gates and smaller changes should be examined Correct answer.
  2. The team should stop deploying to improve stability
  3. Change failure rate is irrelevant when deployment frequency is high
  4. The team has achieved elite performance because deployment frequency is high

Explanation

DORA treats throughput and stability as complementary, so a high failure rate signals that speed is outpacing quality controls. The remedy is to strengthen automated testing, review, and change size rather than abandon frequent delivery.

Question 19DevOps and Software Engineering Fundamentals

A monolith is being split into services. Which outcome most directly supports independent deployability?

  1. Services call each other through in-process function calls
  2. Every service must be deployed together as one release unit
  3. All services share a single database schema that changes freely
  4. Each service owns its data and exposes a versioned contract to consumers Correct answer.

Explanation

Independent deployability requires that a service can change without forcing coordinated releases. Owning its data and publishing a versioned contract limits coupling to consumers.

Question 20DevOps and Software Engineering Fundamentals

A team wants to adopt canary releases. Which mechanism is essential to make a canary meaningful?

  1. Routing a small share of traffic to the new version while comparing health signals against the baseline Correct answer.
  2. Requiring a full rollback plan only after full rollout
  3. Disabling monitoring to avoid alert noise during rollout
  4. Deploying the new version to all users at once

Explanation

A canary exposes a small traffic slice to the new version and compares its health against the stable baseline. That comparison is what lets the team decide to promote or roll back.

Question 21DevOps and Software Engineering Fundamentals

A pipeline's integration test stage takes 40 minutes and runs on every commit, slowing feedback. Which change best balances speed and safety?

  1. Move all testing to manual QA after deployment
  2. Run the full integration suite twice on every commit
  3. Run fast unit and contract tests on every commit and schedule full integration suites on merge or a subset by risk Correct answer.
  4. Remove integration tests entirely to speed up the pipeline

Explanation

Tiering tests by cost and risk preserves fast per-commit feedback while retaining deeper verification at merge. This keeps safety without paying the full cost on every commit.

Question 22DevOps and Software Engineering Fundamentals

Which practice most directly reduces the risk of a failed deployment causing a prolonged outage?

  1. Removing health checks to avoid false positives
  2. Automated rollback triggered by health-check failure during rollout Correct answer.
  3. Increasing the deployment batch size to finish faster
  4. Requiring manual verification of each instance after full rollout

Explanation

Automated rollback detects unhealthy rollouts and restores the prior version quickly, limiting outage duration. Health checks provide the signal that triggers the reversal.

Question 23DevOps and Software Engineering Fundamentals

Which statement best describes the role of a value stream map in a DevOps transformation?

  1. It visualizes the flow of work from idea to customer and exposes wait times and handoffs Correct answer.
  2. It documents only the final production architecture
  3. It lists the salaries of team members by role
  4. It replaces the need for automated testing

Explanation

A value stream map traces work from request to delivery and highlights where time is lost to waiting and handoffs. Those insights guide where to remove bottlenecks.

Question 24DevOps and Software Engineering Fundamentals

Which practice best reflects the DevOps idea of blameless postmortems?

  1. Identify the individual at fault and record it in their review
  2. Skip the review when the incident was resolved quickly
  3. Focus on systemic causes and corrective actions rather than punishing individuals Correct answer.
  4. Restrict incident details to management only

Explanation

Blameless postmortems assume people act reasonably given their context and target systemic fixes. This encourages honest reporting, which improves future reliability.

Question 25DevOps and Software Engineering Fundamentals

A team uses blue-green deployment. What is the key advantage over an in-place update?

  1. It eliminates the need for any testing before release
  2. It guarantees zero defects in the new version
  3. It requires only one environment to exist at a time
  4. Traffic can be switched back to the previous environment quickly if the new one misbehaves Correct answer.

Explanation

Blue-green keeps the prior environment intact so traffic can be redirected back if the new version fails. That fast switch is the core benefit for reducing risk.

Question 26DevOps and Software Engineering Fundamentals

In DevOps, what does the term 'shift left' most specifically refer to?

  1. Transferring operational duties from developers to a dedicated ops team
  2. Delaying release decisions until a change advisory board approves them
  3. Moving quality, security, and testing activities earlier in the software lifecycle Correct answer.
  4. Moving production workloads to a secondary region for resilience

Explanation

Shift left means performing quality, security, and testing activities as early as possible in the delivery lifecycle, close to where code is written. This shortens the time between introducing a defect and detecting it, reducing rework cost. It does not mean relocating workloads or deferring decisions to later gates.

Question 27DevOps and Software Engineering Fundamentals

Which statement best captures the core distinction between DevOps and traditional siloed IT delivery?

  1. DevOps eliminates the need for production monitoring because defects are prevented earlier
  2. DevOps replaces all manual approvals with automated change management tickets
  3. DevOps requires every organization to adopt a single vendor toolchain for CI/CD
  4. DevOps merges development and operations into one team with shared accountability for delivery and runtime Correct answer.

Explanation

DevOps breaks down the wall between development and operations so the same team is accountable for both shipping and running software. Shared accountability, not a particular tool or ticket process, is the defining shift. Monitoring remains essential because production behavior is part of that responsibility.

Question 28DevOps and Software Engineering Fundamentals

A team measures lead time for changes as the period from code committed to code running in production. Which DevOps outcome does this metric most directly reflect?

  1. The stability of the production environment under load
  2. The throughput of the delivery process from commit to customer Correct answer.
  3. The completeness of the team's automated test coverage
  4. The efficiency of the incident escalation process

Explanation

Lead time for changes measures how long a committed change takes to reach production, which is a throughput measure of the delivery pipeline. It tells you how quickly work flows from commit to the customer. It does not measure reliability, test coverage, or incident handling.

Question 29DevOps and Software Engineering Fundamentals

In a CI/CD context, what is the primary purpose of a build artifact repository?

  1. To provide a dashboard of pipeline pass and fail rates
  2. To host immutable, versioned build outputs that pipelines can promote across environments Correct answer.
  3. To store source code history and branch metadata
  4. To run automated tests against each incoming commit

Explanation

An artifact repository stores the versioned, immutable outputs of a build, such as packages or container images, so the same binary can be promoted from one environment to the next. This guarantees that what was tested is what gets deployed. Source history, test execution, and dashboards belong to other tools.

Question 30DevOps and Software Engineering Fundamentals

Which description correctly characterizes infrastructure as code (IaC)?

  1. Manually documenting server configuration in a shared wiki for operators to follow
  2. Using a graphical console to configure each server individually
  3. Relying on a golden image that is never rebuilt or updated
  4. Defining infrastructure in version-controlled files that tooling applies repeatably Correct answer.

Explanation

IaC means infrastructure is described in machine-readable, version-controlled files and applied by tooling, making environments reproducible and reviewable. Changes flow through the same review and pipeline process as application code. Manual consoles and static wiki pages do not give this repeatability.

Question 31DevOps and Software Engineering Fundamentals

A team wants every pull request to be reviewed by at least one other engineer before merge. Which DevOps-aligned practice does this describe?

  1. Canary analysis
  2. Chaos engineering
  3. Continuous deployment
  4. Peer code review as a quality gate Correct answer.

Explanation

Requiring another engineer to review a pull request before merge is peer code review acting as a quality gate. It catches defects and spreads knowledge before code reaches the main branch. Continuous deployment, canary analysis, and chaos engineering concern release and runtime behavior, not pre-merge review.

Question 32DevOps and Software Engineering Fundamentals

What is the main role of a container image registry in a DevOps pipeline?

  1. To store and distribute versioned container images by tag or digest Correct answer.
  2. To terminate TLS for inbound production traffic
  3. To schedule containers across a cluster of hosts
  4. To compile application source into executable binaries

Explanation

A registry stores container images and serves them to pipelines and runtime platforms, addressed by tag or digest. It is the distribution point between build and deploy stages. Compilation, scheduling, and TLS termination are performed by other components.

Question 33DevOps and Software Engineering Fundamentals

Which statement best describes the purpose of a blameless culture in DevOps incident response?

  1. It encourages people to report mistakes and details so systemic causes can be fixed Correct answer.
  2. It guarantees that no incident will recur after the first review
  3. It transfers accountability for incidents to the tooling vendor
  4. It removes the need to record what happened during an incident

Explanation

A blameless culture encourages honest reporting of mistakes and full incident details so the team can find and fix systemic causes. It does not remove the need for records or guarantee recurrence is impossible. Accountability stays with the team and its systems, not a vendor.

Question 34DevOps and Software Engineering Fundamentals

A CI pipeline currently runs the full regression suite, including slow end-to-end tests, on every commit. Which change best preserves fast feedback while keeping adequate coverage?

  1. Increase the number of manual approvals required before tests run
  2. Move all testing to production so real users surface defects
  3. Run fast unit and static checks on every commit and schedule the slow end-to-end suite less frequently or in parallel Correct answer.
  4. Remove the end-to-end tests entirely to speed up the pipeline

Explanation

Fast feedback comes from running quick checks on every commit while slower, broader suites run on a schedule or in parallel. This keeps the commit path short without abandoning coverage. Deleting tests or pushing testing to production sacrifices safety.

Question 35DevOps and Software Engineering Fundamentals

A team defines its infrastructure with a declarative tool and applies changes only through the pipeline. A developer edits a running server by hand to fix a hotfix. What is the most likely consequence?

  1. The server will automatically export the change back into version control
  2. The next pipeline apply will revert the manual change, causing configuration drift to be corrected Correct answer.
  3. The pipeline will refuse to run because it detects unauthorized users
  4. The declarative tool will adopt the manual change permanently without any action

Explanation

Declarative IaC converges the real environment toward the declared state, so an out-of-band manual edit is overwritten on the next apply. This is how drift is corrected, but it also means hotfixes must go through code. Declarative tools do not silently adopt manual changes or auto-commit them.

Question 36DevOps and Software Engineering Fundamentals

A service must remain available during rolling deployments without dropping in-flight requests. Which combination most directly achieves this?

  1. Disabling health checks so instances are never marked unhealthy
  2. Deploying all instances simultaneously during a maintenance window
  3. Using readiness probes plus graceful connection draining before old instances are removed Correct answer.
  4. Increasing the number of replicas without changing the deployment strategy

Explanation

Readiness probes ensure new instances receive traffic only when ready, and connection draining lets in-flight requests finish on old instances before they are terminated. Together they prevent dropped requests during a rolling update. Simultaneous replacement and disabled health checks increase disruption.

Question 37DevOps and Software Engineering Fundamentals

A team's change failure rate is low but its mean time to recovery is high. Which improvement most directly targets the weak metric?

  1. Investing in faster detection, rollback automation, and runbooks for incidents Correct answer.
  2. Reducing automated test coverage to speed up releases
  3. Adding more manual approval gates before deployment
  4. Increasing deployment frequency to ship more changes

Explanation

Mean time to recovery measures how quickly service is restored after a failure, so faster detection, automated rollback, and clear runbooks directly reduce it. Deployment frequency and pre-deployment gates affect other metrics. Cutting test coverage would likely worsen reliability.

Question 38DevOps and Software Engineering Fundamentals

A team wants secrets used by its pipeline to be rotated automatically and never stored in plaintext in the repository. Which approach best meets this requirement?

  1. Sharing secrets through a private chat channel before each release
  2. Storing secrets in a dedicated secrets manager and injecting them at runtime with short-lived credentials Correct answer.
  3. Embedding secrets in container images built by the pipeline
  4. Committing encrypted secrets alongside the pipeline definition

Explanation

A dedicated secrets manager centralizes storage, access control, and rotation, and injecting short-lived credentials at runtime limits exposure. Secrets never land in the repository or image layers. Encrypted files in the repo and chat sharing still spread the secret and complicate rotation.

Question 39DevOps and Software Engineering Fundamentals

Which scenario best demonstrates the DevOps principle of 'you build it, you run it'?

  1. Developers hand off releases to a release manager who owns post-deployment issues
  2. The team that writes a service also carries its on-call rotation and owns its production health Correct answer.
  3. A separate operations group is paged for all production alerts while developers only write code
  4. A vendor is responsible for all production incidents involving the team's service

Explanation

'You build it, you run it' means the team that writes a service also operates it, including on-call and production health. This closes the feedback loop between code and its runtime behavior. Handing operations to a separate group, vendor, or release manager breaks that ownership.

Question 40DevOps and Software Engineering Fundamentals

A team adopts trunk-based development and wants to keep the main branch always releasable while features are still in progress. Which practice best supports this?

  1. Long-lived feature branches merged only at release time
  2. Freezing the main branch until all features are complete
  3. Feature flags that hide incomplete work in production Correct answer.
  4. Requiring every commit to pass a manual review board

Explanation

Feature flags let incomplete functionality ship to production while remaining hidden or disabled, keeping the trunk releasable. Long-lived branches and freezes delay integration and increase merge risk. Manual review boards slow delivery rather than enabling continuous integration.

Question 41DevOps and Software Engineering Fundamentals

A team wants to verify that a newly deployed version behaves correctly under real traffic before routing all users to it. Which practice fits best?

  1. Canary release with automated comparison of error rates and latency against the baseline Correct answer.
  2. Rolling back to the previous version immediately after deployment
  3. Blue-green switch with no post-switch monitoring
  4. Big-bang cutover of all traffic to the new version

Explanation

A canary release sends a small share of real traffic to the new version and compares its health signals against the baseline before full rollout. This limits blast radius and validates behavior under real conditions. Big-bang cutover and unmonitored switches expose all users at once.

Question 42DevOps and Software Engineering Fundamentals

A pipeline builds a container image tagged only as 'latest'. Why is this a problem for promotion across environments?

  1. The 'latest' tag prevents the image from being pulled at all
  2. The tag is mutable, so different environments may run different images under the same name Correct answer.
  3. Registries reject images without a semantic version
  4. The 'latest' tag cannot be pushed to a registry

Explanation

A mutable tag like 'latest' can point to different images over time, so environments promoted with the same tag may actually run different content. Immutable tags or digests guarantee that what was tested is what is deployed. Registries do accept 'latest', which is precisely why the ambiguity arises.

Question 43DevOps and Software Engineering Fundamentals

A team wants to detect regressions in a service's internal behavior without relying only on user-facing symptoms. Which practice best supports this?

  1. Instrumenting the service with distributed tracing and structured logs correlated by request ID Correct answer.
  2. Reviewing code manually after each incident
  3. Waiting for customers to report problems before investigating
  4. Collecting only CPU and memory metrics from hosts

Explanation

Distributed tracing and correlated structured logs expose internal request flows and dependencies, letting teams detect and diagnose regressions before users notice. Host metrics alone are too coarse. Waiting for customer reports and post-incident reviews are reactive rather than proactive detection.

Question 44DevOps and Software Engineering Fundamentals

Which statement best explains why small, frequent deployments generally reduce risk compared with large, infrequent releases?

  1. Deployment frequency has no relationship to change failure rate
  2. Frequent deployments eliminate the need for automated testing
  3. Smaller changes are easier to review, test, and roll back, limiting the blast radius of any defect Correct answer.
  4. Large releases are inherently free of defects because they are tested longer

Explanation

Smaller changes are easier to review, test in isolation, and revert if something goes wrong, which narrows the blast radius of any defect. Frequent small releases also shorten the feedback loop. This does not remove the need for testing, and research associates higher frequency with lower failure rates.

Question 45DevOps and Software Engineering Fundamentals

An organization wants to reduce handoff delays between development and operations. Which structural change most directly addresses this?

  1. Increasing the size of the operations team to handle more tickets
  2. Adding a formal sign-off step between the two groups
  3. Forming cross-functional product teams that own a service end to end Correct answer.
  4. Outsourcing operations to a managed service provider

Explanation

Cross-functional teams that own a service from code to production remove the handoffs that cause delay and miscommunication. Adding sign-offs or enlarging a separate ops team preserves the boundary. Outsourcing moves the handoff rather than eliminating it.

Question 46DevOps and Software Engineering Fundamentals

A team wants to enforce that no code reaches the main branch unless all automated checks pass. Which mechanism most directly enforces this?

  1. A post-merge notification to the team channel
  2. A written policy that developers should run tests locally
  3. A weekly meeting to review test results
  4. Branch protection rules that require status checks before merge Correct answer.

Explanation

Branch protection rules with required status checks make the pipeline a gate: merges are blocked until checks pass. This enforces the policy mechanically rather than relying on discipline. Local habits, meetings, and post-merge notifications do not prevent failing code from merging.

Question 47DevOps and Software Engineering Fundamentals

A team is choosing between a monolithic deployment and microservices for a system with strict independent scaling needs per component. Which analysis is most sound?

  1. Independent scaling is impossible in any architecture
  2. Microservices allow each component to scale independently, at the cost of added operational complexity Correct answer.
  3. A monolith always scales better because it has fewer moving parts
  4. Microservices eliminate the need for service discovery and monitoring

Explanation

Microservices let each component scale on its own resource profile, which suits strict per-component scaling needs, but they introduce distributed-system complexity such as discovery, monitoring, and network failure handling. A monolith scales as a unit. No architecture removes the need for operational tooling.

Question 48DevOps and Software Engineering Fundamentals

A pipeline deploys to production on every merge to main and has a high change failure rate. Which response best reflects sound DevOps reasoning?

  1. Abandon continuous deployment and return to quarterly releases
  2. Strengthen automated testing, add progressive delivery such as canaries, and use fast rollback to reduce failure impact Correct answer.
  3. Increase deployment frequency further to overwhelm the failure rate
  4. Remove monitoring so failures are detected less often

Explanation

A high failure rate alongside frequent deployment points to insufficient quality gates and release safety, not to frequency itself. Strengthening automated tests, adding progressive delivery, and enabling fast rollback reduce both failure likelihood and impact. Reverting to quarterly releases sacrifices the throughput gains without fixing root causes.

Question 49DevOps and Software Engineering Fundamentals

A team claims to practice continuous integration, but developers merge to a shared branch only once every two weeks after long-lived feature work. Which assessment is most accurate?

  1. This satisfies continuous integration as long as automated tests run after each merge
  2. This is not continuous integration because integration happens infrequently and late, so defects surface slowly Correct answer.
  3. This is continuous delivery because releases are scheduled
  4. This is continuous integration because a shared branch exists

Explanation

Continuous integration requires developers to integrate into the shared trunk frequently, typically at least daily, so conflicts and defects surface quickly. Merging every two weeks after long-lived branches is batch integration, which delays feedback. A shared branch or tests alone do not constitute CI.

Question 50DevOps and Software Engineering Fundamentals

An organization measures lead time from idea approval to production and finds most delay occurs in a review queue between stages. Which action best follows from value stream analysis?

  1. Optimize only the fastest stage to improve the average
  2. Add more work in process to keep every stage busy
  3. Increase batch sizes so fewer reviews are needed
  4. Reduce queue time by limiting work in process and removing the approval bottleneck Correct answer.

Explanation

Value stream analysis identifies where elapsed time is consumed; when delay sits in a queue, the fix is to reduce work in process and remove or parallelize the bottleneck. Optimizing already-fast stages or increasing batch sizes does not address the queue and can worsen it.