I85PREP
⌘ K
JNCIA-DevOps study materials
JNCIA-DevOps study resources

JNCIA-DevOps practice questions

One question at a time. Build your JNCIA-DevOps 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 1Automation and Scripting

On a Junos device, which statement correctly describes the purpose of the commit script configured under [edit system scripts commit]?

  1. It translates CLI commands into NETCONF RPCs sent to a remote controller
  2. It schedules periodic configuration backups to a remote server
  3. It replaces the need for a rescue configuration on the device
  4. It validates or modifies the candidate configuration before it becomes active Correct answer.

Explanation

Commit scripts are XSLT or SLAX programs that run at commit time against the candidate configuration. They can inspect the configuration and reject it with an error or emit changes that are applied before the commit completes. This makes them a server-side enforcement mechanism for configuration policy.

Question 2Automation and Scripting

An event script is defined with the policy [edit event-options policy P1] and the trigger "event ui_mgd_netcfg_change". What does this configuration accomplish?

  1. It runs the referenced script when a commit script rejects a configuration
  2. It runs the referenced script every time a user logs in to the device
  3. It runs the referenced script only when the routing process restarts
  4. It runs the referenced script when the device detects a configuration change event Correct answer.

Explanation

Event policies in event-options match system log events and then execute the actions and scripts listed in the policy. The event ui_mgd_netcfg_change is raised when the configuration is changed, so the script runs in response to that event. This is the standard server-side automation hook for reacting to state changes.

Question 3Automation and Scripting

Which Junos on-box scripting language is an XPath-based alternative to XSLT that is often preferred for readability when writing commit and op scripts?

  1. SLAX Correct answer.
  2. Bash
  3. Perl
  4. YAML

Explanation

SLAX is a Junos scripting language that uses a syntax similar to C and shell, and it operates on the configuration through XPath expressions. Junos converts SLAX scripts to XSLT before execution, so both languages have equivalent capability. Many engineers choose SLAX because it is easier to read and maintain than XSLT.

Question 4Automation and Scripting

In a SLAX commit script, which function is used to emit an error and stop the commit when a policy violation is detected?

  1. expr jcs:syslog()
  2. expr jcs:emit-change()
  3. expr jcs:emit-error() Correct answer.
  4. expr jcs:output()

Explanation

The jcs:emit-error() function generates an error message and causes the commit to fail. This is how a commit script enforces policy by refusing a configuration that violates requirements. The message text is returned to the user who issued the commit.

Question 5Automation and Scripting

Which PyEZ class is used to load a configuration snippet into the candidate configuration and later commit it on a Junos device?

  1. jnpr.junos.utils.start_shell.StartShell
  2. jnpr.junos.op.arp.ArpTable
  3. jnpr.junos.utils.sw.SW
  4. jnpr.junos.utils.config.Config Correct answer.

Explanation

The Config utility class provides methods such as load(), commit(), rollback(), and diff() that operate on the candidate configuration. It supports merge, replace, and override load actions. This class is the standard way to perform configuration changes programmatically with PyEZ.

Question 6Automation and Scripting

A PyEZ script calls dev.rpc.get_interface_information(terse=True). What type of result does this call return?

  1. A Python dictionary parsed from JSON output
  2. A list of interface objects created by the table framework
  3. An lxml element containing the XML response from the device Correct answer.
  4. A plain text string of the CLI output

Explanation

Direct RPC calls through dev.rpc return the raw XML reply as an lxml element. The script can then use XPath to extract values from that element. The table and view framework is a separate layer used to convert XML into Python objects.

Question 7Automation and Scripting

Which statement describes how the Junos XML API differs from screen-scraping CLI output in an automation script?

  1. The XML API returns data only for the default routing instance
  2. The XML API requires the script to parse fixed-width columns of text
  3. The XML API returns structured data that is stable across releases and easier to parse Correct answer.
  4. The XML API is only available when the device is in maintenance mode

Explanation

The Junos XML API returns hierarchical, tagged data instead of formatted text, so scripts can select values with XPath or equivalent parsing. Because the structure is defined by the data model, it is more resilient to cosmetic CLI output changes. Screen-scraping text is fragile because column widths and headers change between releases.

Question 8Automation and Scripting

Which NETCONF operation should a script use to retrieve the device's configuration and operational data?

  1. <edit-config>
  2. <get-config> Correct answer.
  3. <lock>
  4. <copy-config>

Explanation

The NETCONF <get-config> operation retrieves configuration data from a specified datastore, and <get> retrieves both configuration and state data. These are the read operations defined by the NETCONF protocol. Write and lock operations do not return the requested data.

Question 9Automation and Scripting

When using ncclient to change a Junos configuration, which sequence correctly applies a change safely?

  1. Lock the candidate, edit-config, validate, commit, then unlock Correct answer.
  2. Validate, unlock the candidate, edit-config, then commit
  3. Edit-config, commit, lock the candidate, then validate
  4. Commit, lock the candidate, edit-config, then unlock

Explanation

The safe NETCONF workflow locks the candidate datastore to prevent concurrent changes, loads the edit, validates it, commits it, and then releases the lock. Locking first avoids race conditions with other management sessions. Unlocking at the end ensures the datastore is not left locked if the script completes normally.

Question 10Automation and Scripting

A commit script uses the expression <xsl:if test="not(../interfaces/interface[name='ge-0/0/0'])"> to emit a change. What is the effect of this logic?

  1. It renames ge-0/0/0 to the first configured interface name
  2. It adds a ge-0/0/0 interface stanza only when that interface is not already present Correct answer.
  3. It always rejects the commit when ge-0/0/0 exists
  4. It removes the ge-0/0/0 interface from the configuration

Explanation

The test condition is true only when no interface named ge-0/0/0 exists in the configuration. When true, the enclosed emit-change content is applied, which inserts the missing stanza. This pattern enforces a required baseline without duplicating existing configuration.

Question 11Automation and Scripting

Why should an op script that makes changes be configured with the 'allow-commit' attribute rather than run without it?

  1. Without it the script cannot send output to the user
  2. Without it the script cannot read operational state from the device
  3. Without it the script cannot be invoked from the CLI
  4. Without it the script is prevented from committing configuration changes Correct answer.

Explanation

By default an op script runs in a restricted mode that cannot modify or commit configuration. The allow-commit attribute grants the script permission to make configuration changes. Scripts that only read state or produce output do not need this permission.

Question 12Automation and Scripting

Which statement about the Junos REST API is correct for a script that needs to retrieve interface status?

  1. It requires an SSH session and cannot use HTTPS
  2. It can only be used to commit configuration changes
  3. It requires the script to run on the device itself
  4. It accepts HTTP requests with the Accept header set to application/json or application/xml Correct answer.

Explanation

The Junos REST API exposes RPCs over HTTPS, and the client selects the response format with the Accept header. Requests can be sent from an external host, so the script does not need to run on the device. This makes REST a convenient option for lightweight integrations.

Question 13Automation and Scripting

In a PyEZ table/view definition, what is the role of the view?

  1. It specifies the commit script to run after loading configuration
  2. It defines the NETCONF port used to connect to the device
  3. It defines the XPath expressions that map XML fields to Python object attributes Correct answer.
  4. It stores the device password in an encrypted form

Explanation

A view maps elements of the XML reply to named fields on the resulting Python objects using XPath expressions. The table defines which RPC to call and how to iterate over the returned items. Together they let a script work with structured objects instead of raw XML.

Question 14Automation and Scripting

A script needs to load a configuration snippet so that the listed hierarchy replaces the existing hierarchy at that level. Which PyEZ load action should be used?

  1. replace=True Correct answer.
  2. overwrite=True
  3. update=True
  4. merge=True

Explanation

The replace load action replaces the configuration at the specified hierarchy level with the supplied content. Merge combines the snippet with existing configuration, while overwrite replaces the entire configuration. Choosing replace avoids removing unrelated configuration outside the target hierarchy.

Question 15Automation and Scripting

Which Junos feature allows a device to be managed by a centralized controller using a data model such as OpenConfig or native YANG?

  1. Junos YANG-based management with NETCONF Correct answer.
  2. Unified ISSU
  3. Junos Telemetry Interface
  4. Virtual Chassis

Explanation

Junos supports YANG data models and NETCONF, enabling model-driven configuration and state retrieval by a controller. OpenConfig and native YANG models describe both configuration and operational data. This model-driven approach is the basis for controller-based automation.

Question 16Automation and Scripting

What is the primary purpose of Junos PyEZ in a network automation workflow?

  1. To compile SLAX scripts into native machine code
  2. To provide a Python library for managing Junos devices over NETCONF and the XML API Correct answer.
  3. To replace the Junos CLI with a graphical dashboard
  4. To provide a YANG compiler for building device images

Explanation

PyEZ is a Python library that abstracts NETCONF and the Junos XML API for device management. It offers utilities for configuration, operational tables, software upgrades, and file transfer. Scripts use it to perform repeatable tasks against many devices.

Question 17Automation and Scripting

A script uses the Jinja2 template {{ hostname }} to generate configuration. What must be done to ensure the variable is replaced with a value?

  1. The script must run on the device rather than externally
  2. The variable must be declared in the Junos configuration first
  3. The script must pass a context dictionary containing the key hostname to the template render call Correct answer.
  4. The variable must be wrapped in XPath syntax

Explanation

Jinja2 templates resolve variables from a context provided at render time, usually a dictionary of key-value pairs. If the key is missing, the template typically renders an empty string or raises an error depending on settings. The device configuration is not involved in template rendering.

Question 18Automation and Scripting

Which statement best explains why idempotent automation is important when applying configuration to many Junos devices?

  1. It guarantees the script will run faster on each device
  2. It eliminates the need to validate configuration before commit
  3. It ensures repeated runs converge to the same state without unintended changes Correct answer.
  4. It removes the need for version control of templates

Explanation

Idempotent automation produces the same result whether run once or many times, so re-running a playbook does not create duplicate or drifting configuration. This property makes automation safe to retry after failures. It does not remove the need for validation or version control.

Question 19Automation and Scripting

In an Ansible playbook targeting Junos devices with the juniper.device collection, which connection method is commonly used?

  1. snmp version 3
  2. network_cli with telnet
  3. local execution with a serial console
  4. netconf over SSH Correct answer.

Explanation

Junos modules in the juniper.device collection typically use NETCONF over SSH to communicate with devices. This provides structured XML-based interaction rather than screen-scraping CLI output. The connection is defined by the ansible_connection setting, usually netconf.

Question 20Automation and Scripting

A commit script must verify that a specific interface has a description before allowing the commit. Which approach correctly implements this check?

  1. Emit a change that removes the interface when the description is missing
  2. Use a conditional test for the description element and call jcs:emit-error() when it is absent Correct answer.
  3. Log a warning with jcs:syslog() and allow the commit to proceed
  4. Rely on the CLI to prompt the user for a description during commit

Explanation

A validation commit script tests for the required element and calls jcs:emit-error() when the requirement is unmet, which aborts the commit. This enforces the policy at the device rather than relying on operator discipline. Logging alone does not prevent noncompliant configuration.

Question 21Automation and Scripting

Which Python construct is most appropriate for iterating over a list of devices and applying the same configuration task to each one?

  1. A while loop with an unconditional break
  2. A single device object created once and reused for all devices
  3. A try/except block without a loop
  4. A for loop over the device list Correct answer.

Explanation

A for loop iterates over the collection of devices and executes the task against each one in turn. This is the standard pattern for applying consistent configuration across an inventory. Handling errors inside the loop lets the script continue when one device fails.

Question 22Automation and Scripting

What is the purpose of the Junos 'commit check' command in a validation workflow?

  1. It commits the candidate configuration and saves a rollback file
  2. It compares the running configuration with the rescue configuration
  3. It archives the configuration to a remote server
  4. It verifies the candidate configuration syntax without activating it Correct answer.

Explanation

commit check validates the candidate configuration and reports errors without making it the active configuration. It is useful in automation to confirm a change is syntactically valid before committing. This reduces the risk of pushing a broken configuration to a device.

Question 23Automation and Scripting

Which statement correctly describes how a Junos op script returns output to the CLI user?

  1. It writes output only to the system log
  2. It writes to a file that the user must open manually
  3. It sends the output only through SNMP traps
  4. It uses the jcs:output() function to place text in the command output Correct answer.

Explanation

Op scripts use jcs:output() to return text that is displayed to the user who invoked the script. This is how custom operational commands present results. Writing to a file or syslog does not display output in the CLI session.

Question 24Automation and Scripting

A team wants to store device configuration templates in a repository and track every change with a review process. Which practice best supports this goal?

  1. Storing templates only in local home directories
  2. Editing templates directly on each device through the CLI
  3. Emailing template files to team members for approval
  4. Using version control with branches and pull requests for template changes Correct answer.

Explanation

Version control with branches and pull requests provides an auditable history and a review gate before changes reach production. This supports rollback and collaboration across the team. Manual distribution methods lack traceability and consistency.

Question 25Automation and Scripting

In a PyEZ script, what is the effect of calling dev.close() after completing operations?

  1. It deletes the device's rollback files
  2. It reloads the device configuration from the rescue file
  3. It releases the NETCONF session and frees associated resources Correct answer.
  4. It commits any uncommitted candidate configuration

Explanation

Closing the Device object ends the NETCONF session and releases resources associated with the connection. Failing to close sessions can leave stale sessions on the device. Closing does not commit configuration or alter device state.

Question 26Automation and Scripting

A Python script running on a Linux server needs to connect to a Junos device over NETCONF. Which port and transport does the Junos NETCONF service use by default?

  1. TCP port 23 with Telnet as the transport
  2. UDP port 161 with SNMP as the transport
  3. TCP port 443 with HTTPS as the transport
  4. TCP port 830 with SSH as the transport Correct answer.

Explanation

Junos enables the NETCONF service over SSH, and the standard IANA-assigned port for NETCONF over SSH is 830. A script using ncclient or PyEZ therefore targets port 830 unless the configuration is changed. Port 22 carries the interactive CLI/SSH service, not the NETCONF subsystem by default.

Question 27Automation and Scripting

An automation script must detect that a Junos device rejected a configuration load because of a syntax error. Which signal from the device should the script check?

  1. The SSH session closes without any reply
  2. The RPC reply contains a commit error tag or a non-ok load result Correct answer.
  3. The device returns an SNMP trap
  4. The script's local log file grows in size

Explanation

Junos returns structured RPC replies in which errors are reported inside the reply element, for example a load-configuration result with errors or a commit-results element containing an error. A script must parse that payload rather than assume success. Library helpers such as PyEZ exceptions wrap these signals, but the underlying indicator is the RPC-level error content.

Question 28Automation and Scripting

A script loads a configuration with the 'replace' operation on a specific hierarchy level. What effect does this action have on that hierarchy?

  1. It merges the new statements with the existing ones, keeping both
  2. It validates the configuration without applying it to the candidate
  3. It only creates statements that do not already exist and ignores conflicts
  4. It deletes the existing hierarchy at that level and replaces it with the loaded content Correct answer.

Explanation

The replace operation removes the existing configuration at the targeted hierarchy and substitutes exactly what the script loads. This makes the result deterministic regardless of what was previously configured at that level. Merge is the default behavior and behaves differently.

Question 29Automation and Scripting

A developer wants a reusable Python function that reads a list of device hostnames from a YAML inventory file and returns it as a Python list. Which approach fits this requirement?

  1. Use json.dump() to write the file before reading it back
  2. Use a Jinja2 template to render the hostnames into the file
  3. Use subprocess to run 'show configuration' on each device
  4. Use yaml.safe_load() on the file contents and index the resulting dictionary Correct answer.

Explanation

yaml.safe_load() parses YAML text into native Python objects such as dictionaries and lists, which the script can then index to obtain the hostnames. safe_load is preferred over load because it refuses to construct arbitrary Python objects. JSON dumping, CLI execution, and templating do not parse an existing YAML inventory.

Question 30Automation and Scripting

A team wants a script to be safely re-runnable so that running it twice leaves the device in the same state. Which design choice best supports this?

  1. Compute the desired state and apply only the differences from the current configuration Correct answer.
  2. Require an operator to delete the configuration manually before each run
  3. Append the full configuration block on every run so nothing is missed
  4. Restart the routing process before each run to clear state

Explanation

Idempotent automation compares desired state with current state and changes only what differs, so repeated runs converge on the same result. Blindly appending configuration creates duplicates or commit errors on the second run. Manual pre-cleanup defeats the purpose of automation.

Question 31Automation and Scripting

A script uses ncclient to edit a Junos configuration. Which ncclient operation is designed to send configuration edits to the candidate datastore?

  1. get_config
  2. lock
  3. close_session
  4. edit_config Correct answer.

Explanation

edit_config carries the configuration payload to the target datastore, which for Junos is typically the candidate. get_config only retrieves configuration, while lock and close_session manage session state. After edit_config, a separate commit RPC is required to activate the change.

Question 32Automation and Scripting

A PyEZ script must run several RPCs against one device. Which pattern correctly manages the connection lifecycle?

  1. Create a new Device object for each RPC and never close them
  2. Rely on the garbage collector to close sessions at process exit
  3. Call dev.open() inside a loop before every RPC
  4. Open the Device with a context manager so the session closes even if an exception occurs Correct answer.

Explanation

Using Device as a context manager guarantees that open() and close() are paired, including when an exception interrupts the script. Reusing one session for several RPCs is efficient and avoids leaking NETCONF sessions on the device. Leaving sessions open consumes device resources and can hit session limits.

Question 33Automation and Scripting

A Jinja2 template for interface configuration must fail loudly if the 'description' variable is missing. Which template construct achieves this?

  1. Use the 'lower' filter on the variable name
  2. Use the 'default' filter to substitute an empty string
  3. Wrap the variable in a comment block
  4. Reference the variable without a default and enable StrictUndefined in the environment Correct answer.

Explanation

Jinja2's default Undefined silently renders as an empty string, which can produce incomplete configuration. Configuring StrictUndefined causes an exception when the variable is absent, so the script stops before generating bad config. The default filter does the opposite by masking the missing value.

Question 34Automation and Scripting

An op script written in SLAX must print a message to the CLI user who invoked it. Which statement is correct?

  1. The script writes output through the jcs:output() function, which returns text to the CLI Correct answer.
  2. The script writes directly to /var/log/messages for the user to read
  3. The script uses syslog to send the message to the invoking terminal
  4. The script must modify the candidate configuration to display text

Explanation

Junos op scripts use the jcs:output() extension function to return text to the CLI session that ran the script. The output appears as script results rather than as a configuration change. Writing to logs or syslog does not deliver output to the invoking CLI.

Question 35Automation and Scripting

A commit script needs to block a commit when an interface lacks a description. Which mechanism should the script use to reject the commit?

  1. Modify the candidate configuration to add a default description
  2. Emit a warning or error element through the script's results so the commit is aborted Correct answer.
  3. Write the problem to a file and exit successfully
  4. Return an empty result tree so the commit proceeds

Explanation

Commit scripts influence the commit by returning result elements; an error-level result causes the commit to fail and is shown to the user. Warnings are displayed but allow the commit to proceed. Silently exiting or rewriting configuration does not enforce the policy.

Question 36Automation and Scripting

A script must retrieve only the operational output of 'show version' in XML form from a Junos device. Which PyEZ method is appropriate?

  1. dev.cu.load()
  2. dev.commit()
  3. dev.rpc.get_software_information() Correct answer.
  4. dev.facts_refresh()

Explanation

PyEZ exposes Junos RPCs as methods on dev.rpc, and get_software_information corresponds to the software version RPC. Calling it returns an XML object that the script can parse. The other methods load configuration, commit, or refresh facts rather than returning the version RPC reply.

Question 37Automation and Scripting

An Ansible playbook uses the juniper.device collection to push configuration to Junos devices. Which inventory variable tells the modules how to reach the device?

  1. ansible_user set to root with no connection variable
  2. ansible_python_interpreter pointing at the device
  3. ansible_connection set to the collection's NETCONF connection plugin Correct answer.
  4. ansible_become enabled for privilege escalation

Explanation

The juniper.device collection provides a NETCONF-based connection plugin, selected with ansible_connection, so modules can speak NETCONF to Junos. Credentials and host are supplied through inventory variables such as ansible_user and ansible_host. Privilege escalation and interpreter settings do not establish the Junos connection.

Question 38Automation and Scripting

A script needs to convert the XML reply from a Junos RPC into a Python dictionary so fields can be accessed by name. Which approach is appropriate?

  1. Use the XML object as a dictionary key
  2. Call str() on the XML object and split on whitespace
  3. Parse the XML with a library such as xmltodict and convert the result Correct answer.
  4. Pass the XML object directly to json.dumps()

Explanation

Junos RPC replies are XML, so a conversion step is needed before dictionary-style access. Libraries such as xmltodict turn the element tree into nested dictionaries keyed by tag name. String splitting and JSON serialization do not understand XML structure.

Question 39Automation and Scripting

A developer must decide between using the Junos REST API and NETCONF for a script. Which statement correctly distinguishes them?

  1. NETCONF uses HTTPS and REST uses Telnet
  2. REST uses HTTPS with JSON or XML payloads, while NETCONF uses SSH with XML-encoded RPCs Correct answer.
  3. REST uses SSH with XML, while NETCONF uses HTTPS with JSON
  4. Both use UDP and differ only in port number

Explanation

The Junos REST API is reached over HTTPS and accepts or returns JSON or XML, which suits scripts in environments where HTTPS is preferred. NETCONF runs over SSH and exchanges XML-encoded RPCs in a persistent session. The two differ in transport and encoding, not merely in port.

Question 40Automation and Scripting

A script must confirm that a configuration is syntactically valid before committing it to the active configuration. Which Junos operation should the script invoke?

  1. A request to reboot the device
  2. A rollback of the candidate configuration
  3. A clear of the system commit history
  4. A commit check on the candidate configuration Correct answer.

Explanation

Commit check validates the candidate configuration against syntax and commit script rules without making it active. If validation fails, the script can correct the candidate before committing. Rollback discards changes and reboot or history clearing do not validate configuration.

Question 41DevOps Culture and Practices

In a DevOps culture, what is the primary purpose of a blameless postmortem after a production incident?

  1. To identify the individual who caused the outage so management can act
  2. To produce a document that assigns financial liability to a team
  3. To satisfy auditors by recording which engineer approved the change
  4. To understand systemic causes and improve processes and tooling Correct answer.

Explanation

Blameless postmortems focus on systemic and process causes rather than punishing individuals, because blame suppresses the honest reporting needed to find real root causes. The output is concrete action items that improve automation, monitoring, or procedures so the same failure is less likely to recur.

Question 42DevOps Culture and Practices

A team wants to reduce the time between committing code and running it in production. Which DevOps metric directly measures this?

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

Explanation

Lead time for changes measures how long a committed change takes to reach production, which is exactly the commit-to-deploy interval. Deployment frequency counts how often releases happen but says nothing about the elapsed time for any single change.

Question 43DevOps Culture and Practices

An engineer needs to roll back a failed production release quickly. Which practice most directly supports fast, low-risk rollback?

  1. Versioned, immutable deployment artifacts that can be redeployed Correct answer.
  2. Manual reconfiguration of each server by an on-call operator
  3. Longer change advisory board review cycles before release
  4. Larger release batches that combine many features at once

Explanation

Immutable, versioned artifacts let you redeploy a previously known-good build quickly and identically, which is the foundation of reliable rollback. Large batches and manual per-server edits increase risk and slow recovery.

Question 44DevOps Culture and Practices

What does infrastructure as code primarily change about how environments are managed?

  1. Environments are rebuilt only when a hardware failure occurs
  2. Environment definitions are stored in version control and applied repeatably Correct answer.
  3. Environment changes require a ticket approved by the network team
  4. Environments are configured by hand and documented in a wiki

Explanation

Infrastructure as code treats environment definitions as versioned files that tools apply consistently, so environments become reproducible and reviewable. This replaces hand configuration and undocumented drift with an auditable, repeatable process.

Question 45DevOps Culture and Practices

Which statement best describes the role of continuous integration in a DevOps workflow?

  1. It replaces the need for code review by relying on automated merges
  2. It merges every developer's changes into a shared branch frequently and verifies them automatically Correct answer.
  3. It schedules nightly builds that run once per day regardless of commits
  4. It deploys every commit directly to production without any testing

Explanation

Continuous integration means developers integrate work into a shared mainline frequently, with automated builds and tests validating each integration. This surfaces integration defects early instead of letting them accumulate.

Question 46DevOps Culture and Practices

A team adopts a trunk-based development model. What behavior does this model require?

  1. Developers integrate small changes into the main branch at least daily Correct answer.
  2. Developers keep long-lived feature branches open for several weeks
  3. Developers avoid merging until a release manager approves a batch
  4. Developers release only from a dedicated stabilization branch

Explanation

Trunk-based development keeps a single shared mainline and requires short-lived branches with frequent integration, typically at least daily. This minimizes merge conflicts and keeps the mainline continuously releasable.

Question 47DevOps Culture and Practices

What is the main cultural benefit of cross-functional teams in a DevOps organization?

  1. Change requests are routed through more approval layers
  2. Operations staff are excluded from design discussions
  3. Teams own a service end to end, including build, run, and support Correct answer.
  4. Work is handed between specialized silos in a strict sequence

Explanation

Cross-functional teams that own a service end to end reduce handoffs and align incentives between development and operations. Ownership of build, run, and support encourages shared responsibility for reliability.

Question 48DevOps Culture and Practices

Why does DevOps culture favor small, frequent releases over large periodic ones?

  1. Small releases reduce the scope of change and make failures easier to isolate Correct answer.
  2. Small releases remove the need for monitoring in production
  3. Small releases eliminate the need for automated testing
  4. Small releases guarantee that no defects reach production

Explanation

Smaller releases change less at once, so when something breaks the cause is easier to find and the rollback is less disruptive. Frequent small releases also shorten feedback cycles and reduce deployment risk overall.

Question 49DevOps Culture and Practices

A platform team publishes a self-service pipeline template that product teams can adopt and customize. Which DevOps principle does this best illustrate?

  1. Eliminating all automation in favor of manual steps
  2. Treating the platform as an internal product with users Correct answer.
  3. Centralized gatekeeping of all deployment decisions
  4. Requiring every team to build identical pipelines from scratch

Explanation

Treating the platform as a product means the platform team serves internal developer users, offering reusable self-service capabilities with a good experience. Reusable templates reduce duplicated effort while allowing teams to adapt to their needs.

Question 50DevOps Culture and Practices

An organization wants to shift security left in its delivery pipeline. Which change best reflects that goal?

  1. Assigning all security review to a separate team after release
  2. Documenting known vulnerabilities in a spreadsheet for later review
  3. Adding automated dependency and static analysis checks to the CI pipeline Correct answer.
  4. Running security scans only during the annual audit

Explanation

Shifting security left means detecting security issues early in the development lifecycle, such as automated dependency and static analysis checks on every commit. Early detection is cheaper and faster to fix than post-release discovery.