Skip to main content

Cortex XSOAR Engineer Exam: A Playbook-First Study Guide for the Palo Alto Networks Certification

Updated 12 min readMarkdown
Cortex XSOAR Engineer Exam: A Playbook-First Study Guide for the Palo Alto Networks Certification

The Cortex XSOAR Engineer exam is the test for the Palo Alto Networks Certified XSOAR Engineer certification. It checks whether you can deploy, configure, integrate, manage and troubleshoot Cortex XSOAR, Palo Alto Networks' security orchestration, automation and response (SOAR) platform. The blueprint has five domains, and playbook development is the largest at 30%. That makes it one of the most hands-on, developer-friendly exams in the Palo Alto Networks catalogue.

If you write Python, think in JSON and like automating repetitive SOC work, XSOAR suits you. This guide breaks down the official blueprint, shows the context data, scripting and filtering concepts the exam keeps coming back to, and finishes with a six-week study plan.

Cortex XSOAR Engineer exam at a glance

Item Detail
Exam Palo Alto Networks XSOAR Engineer
Certification Palo Alto Networks Certified XSOAR Engineer
Product Cortex XSOAR
Domains 5 (playbook development is the largest, at 30%)
Language English, with a 30-minute extension by default in non-English-speaking countries
Delivery Pearson VUE
Recommended training Digital learning path, plus the instructor-led course "Cortex XSOAR: Engineering Security Automation Solutions"
Key skills Python scripting, JSON, REST APIs, incident response, MITRE ATT&CK

The blueprint, audience and skills in this guide come from Palo Alto Networks' official XSOAR Engineer certification page and the XSOAR Engineer datasheet (August 2025 edition). Check the current exam length, question count and fee when you register with Pearson VUE, since Palo Alto Networks does not list them in the datasheet.

Who should take the XSOAR Engineer exam?

Palo Alto Networks aims the certification at people who build and run XSOAR rather than just work tickets in it:

  • Security operations and SOC engineers
  • Automation engineers and playbook developers
  • XSOAR specialists and security architects
  • Support engineers who troubleshoot XSOAR deployments

The datasheet's skills list explains why. It expects working knowledge of Python (and, to a lesser extent, JavaScript and PowerShell), REST APIs, JSON and data transformation, log parsing, common SOC tools such as SIEM, EDR and threat intelligence platforms, and MITRE ATT&CK. If you have ever written glue code between a SIEM and a ticketing system, you are the target audience.

What are the five XSOAR Engineer exam domains?

Domain Weight
1. Planning, Installation, and Maintenance 14%
2. Use Case Planning and Development 22%
3. Playbook Development 30%
4. Incident Interactions and Reporting 16%
5. Threat Intelligence Management 18%

Playbook development and use case planning together make up over half of the exam. NWExam's XSOAR Engineer syllabus page repeats the full task list for each domain, which is handy as a study checklist.

Domain 1: How do you plan, install and maintain XSOAR? (14%)

This domain covers the platform rather than the content running on it:

  • Authentication and authorization: users, roles, and single sign-on
  • Engines: when and how to deploy them
  • Development and production environments
  • Marketplace content packs and version updates
  • Integration instances: configuring and troubleshooting them
  • System maintenance and troubleshooting

Engines are the topic most candidates need to study. An engine is a small component installed inside a network segment that the XSOAR server cannot reach directly. Integrations run through the engine, so XSOAR can talk to an on-premises firewall or Active Directory without opening inbound access. Know why you would deploy several engines in a load-balancing group, and how to tell whether an integration failure is an engine problem or a credentials problem.

Dev/prod deployments let you build and test content on a development tenant and push it to production through a content repository, instead of editing live playbooks. Know the workflow and why it matters: a broken playbook in production can stop incidents from being processed.

Marketplace packs bundle integrations, playbooks, scripts, layouts and other content. Expect questions on installing, updating and handling dependencies between packs, and on what happens to content you have customised when its pack is updated.

Domain 2: How do you plan and build an XSOAR use case? (22%)

A use case, such as phishing, malware alerts or impossible-travel logins, needs data structures before it needs a playbook. This domain covers:

  • Incident and indicator lifecycles
  • Fields and layouts
  • Classifiers and mappers
  • Incident creation methods
  • Pre-processing and post-processing
  • Incident types, with their playbooks, layouts and SLAs
  • Lists

Classifiers and mappers cause the most confusion. A classifier looks at the raw event from an integration and decides which incident type it becomes. A mapper then copies values from the raw JSON into incident fields. An incoming mapper fills XSOAR fields from the source, and an outgoing mapper sends field values back to the source system for two-way mirroring.

Incident creation methods include fetching from an integration (the most common), a mail listener, the REST API, jobs and manual creation. Pre-processing rules run before an incident is created and can drop, deduplicate, link or close incoming events, or run a script. They are the right tool when a question describes duplicate alerts flooding the system. Post-processing runs when an incident closes, for example to require a close reason or to update the source ticket.

Lists store reusable data, such as allow lists, VIP users or config values, that playbooks can read without hard-coding it.

Domain 3: What do you need to know about XSOAR playbook development? (30%)

This is the largest domain, and the best way to study it is to build playbooks. The topics are:

  • Task inputs, outputs and results
  • Referencing and manipulating context data
  • Playbook task types
  • Sub-playbooks (inputs, outputs and looping)
  • Filters and transformers
  • The playbook debugger
  • Built-ins, commands and scripts
  • Creating automation scripts
  • Jobs

How does context data work?

Every incident has a context, a JSON document where command results are stored. Playbook tasks read inputs from it and write outputs to it. After an IP enrichment command, the context might contain:

{
  "IP": [
    { "Address": "203.0.113.10", "Geo": { "Country": "NL" } },
    { "Address": "198.51.100.7", "Geo": { "Country": "US" } }
  ],
  "DBotScore": [
    { "Indicator": "203.0.113.10", "Score": 3, "Vendor": "VirusTotal" }
  ]
}

Tasks reference this with context paths such as ${IP.Address}. XSOAR's selector syntax can also filter inline. This returns only the addresses of IPs located in the Netherlands:

${IP(val.Geo.Country == 'NL').Address}

Being able to read a context tree and predict what a path returns is one of the most useful skills for the exam.

Filters, transformers and task types

Filters decide which values pass, for example only indicators with a score of 3. Transformers change values, for example splitting a string, converting to lower case, counting items or extracting a domain from a URL. You can chain them in the task input editor without writing code, and the exam expects you to know when a transformer is enough and when you need a script.

Know the task types: standard tasks run a command or script, conditional tasks branch on a value or ask an analyst a question, data collection tasks gather input (including by email from people outside XSOAR), and section headers organise the flow. Sub-playbooks take inputs and return outputs, and they can loop, either once per input item or until a condition is met, with a maximum number of iterations.

What does an XSOAR automation script look like?

Scripts are mostly Python and follow a standard structure built on the demisto object and the CommonServerPython helpers:

import demistomock as demisto
from CommonServerPython import *

INTERNAL_SUFFIXES = (".corp.example.com", ".internal")


def main():
    domain = demisto.args().get("domain", "").lower()
    is_internal = domain.endswith(INTERNAL_SUFFIXES)
    return_results(CommandResults(
        outputs_prefix="DomainCheck",
        outputs_key_field="Domain",
        outputs={"Domain": domain, "IsInternal": is_internal},
        readable_output=tableToMarkdown(
            "Domain check", {"Domain": domain, "Internal": is_internal}
        ),
    ))


if __name__ in ("__main__", "__builtin__", "builtins"):
    main()

The key pieces are demisto.args() for the inputs, CommandResults to write outputs into the context under DomainCheck, and readable_output for what the analyst sees in the War Room. If you call integration commands from a script, you use demisto.executeCommand. Know the difference between a script (custom logic you write), a built-in (a command that ships with the platform) and an integration command (an action against an external product).

The playbook debugger lets you run a playbook against a test incident, set breakpoints, skip tasks and override inputs. It is the expected answer for questions about troubleshooting a playbook without affecting live incidents. Jobs run playbooks on a schedule or when a threat intel feed changes, which is how you automate tasks such as daily indicator clean-up.

Domain 4: What incident interaction and reporting topics are tested? (16%)

  • Incident states and actions
  • War Room activities
  • Incident relationships
  • Dashboards and reports

The War Room is each incident's activity log and command line. Analysts run commands there with a ! prefix:

!ip ip=203.0.113.10
!setIncident severity=3 owner=analyst1
!Print value=${incident.name}

Know that entries can be marked as evidence, that notes and chats are recorded alongside command results, and that every action becomes part of the audit trail. For incident relationships, understand linking related incidents and how duplicate incidents are found and closed. For dashboards and reports, know the widget types and data sources and how scheduled reports are delivered.

Domain 5: How does XSOAR handle threat intelligence? (18%)

Threat Intelligence Management (TIM) treats indicators as first-class objects with their own lifecycle:

  • Creation: auto-extraction from incidents, threat intel feeds, manual entry and the API
  • Configuration: indicator types, fields and layouts
  • Relationships: for example, a domain resolves to an IP, or malware is used by a threat actor, in line with MITRE ATT&CK
  • Enrichment and source reliability: when several feeds disagree, the more reliable source wins
  • Sharing: exporting indicators to external tools, such as a list consumed by a firewall
  • Exclusion lists: stopping known-good values, such as your own domains, from becoming indicators

A common exam scenario has an internal domain being flagged as malicious, and the answer is the exclusion list, not deleting the indicator. If you also work on the network side of Palo Alto Networks, sharing indicators with firewalls ties XSOAR to the rest of the platform. Our Palo Alto SD-WAN Engineer study guide covers another engineer-level exam from the same certification family.

A six-week Cortex XSOAR Engineer study plan

This plan assumes 6 to 8 hours a week, basic Python and access to an XSOAR lab, such as one from the course or a development tenant.

Week Focus
1 Datasheet blueprint, architecture, users and roles, engines, dev/prod, Marketplace packs
2 Incident types, fields, layouts, classifiers and mappers, pre- and post-processing, lists
3 Playbook basics: task types, inputs and outputs, context paths, filters and transformers
4 Sub-playbooks and loops, automation scripts in Python, the debugger, jobs
5 War Room, incident relationships, dashboards and reports, threat intelligence management
6 Full blueprint review and timed practice questions

Follow the Palo Alto Networks digital learning path, and take the instructor-led "Cortex XSOAR: Engineering Security Automation Solutions" course if you can. In the last week, practise reading scenarios quickly. NWExam's XSOAR Engineer sample questions are a good test of whether you can pick between a classifier, a mapper, a pre-processing rule and a playbook change from a short description.

What mistakes cost candidates the XSOAR Engineer exam?

  • Reading about playbooks without building any. Domain 3 alone is 30% of the exam.
  • Mixing up classifiers and mappers. One picks the incident type; the other fills its fields.
  • Writing a script when a transformer or filter would do, or the other way round.
  • Ignoring engines and dev/prod because they seem like administrator topics.
  • Treating threat intelligence as a feed setting. Indicator relationships, source reliability and exclusion lists are all tested.

Frequently asked questions

What is the Cortex XSOAR Engineer exam?

It is the Palo Alto Networks XSOAR Engineer certification exam. It validates the skills to deploy, configure, manage, integrate and troubleshoot Cortex XSOAR in security operations environments.

Which domain is the most important?

Playbook Development, at 30%. Use Case Planning and Development (22%) is next, followed by Threat Intelligence Management (18%), Incident Interactions and Reporting (16%), and Planning, Installation, and Maintenance (14%).

Do I need to know Python for the XSOAR Engineer exam?

Yes, at a working level. The datasheet lists Python as the main scripting language for automation scripts, with JavaScript and PowerShell to a lesser extent. You should be able to read a script and understand its inputs, outputs and context.

Is there extra time for non-native English speakers?

Yes. The exam is delivered in English, and candidates testing in non-English-speaking countries get a 30-minute extension by default.

How should I prepare for the XSOAR Engineer exam?

Use the official datasheet as your checklist, follow the digital learning path, build playbooks in a lab, and finish with timed practice questions.

Final thoughts

The Cortex XSOAR Engineer exam rewards people who have automated real SOC work. Learn how data flows from a fetched event through a classifier and a mapper into an incident, how playbooks read and write context, and how indicators are created, enriched and shared. Build one complete use case, such as phishing, from start to finish in a lab, and most of the blueprint will feel familiar on exam day.

About the author

  • Embark on this exciting adventure with us and unlock the doors to a world of possibilities. Your networking success story begins here – let's embark on this collaborative journey toward expanding horizons and achieving your goals, one connection at a time.

No comments yet. Be the first to comment.