Splunk Core Certified Power User

Exam SPLK-1002. Validates that you can build and use Splunk knowledge objects and write intermediate SPL — transforming commands, fields, tags, event types, macros, workflow actions, data models, pivot, and the Common Information Model. This page is a fast overview plus a thorough, domain-by-domain guide.

65 questions 60 minutes pass ~70% $130 USD No prerequisite
⚡ Open the 1-page Cram Jam sheet

Part 1 — High-Level Overview

What & Why

The Power User is the second rung of the Splunk Core track (after the entry Core Certified User, SPLK-1001). It proves you can go beyond basic searching to create the reusable "knowledge objects" that make Splunk data useful for a team: extracted fields, tags, event types, macros, data models, and normalized data via the CIM.

Prerequisite myth Older posts claim you must pass SPLK-1001 first. The current official blueprint states there are NO prerequisite exams — SPLK-1001 is a recommended stepping stone, not a gate. Anyone can register for SPLK-1002 directly. Full detail in §1.

Exam at a Glance

AttributeValue
Exam codeSPLK-1002
Questions65 multiple choice / multiple response
Time60 minutes (includes ~3 min agreement → ~57 min to answer)
Passing scoreNot officially published; community estimate ~70%
Cost$130 USD per attempt
DeliveryPearson VUE — online proctored or test center
PrerequisiteNone (SPLK-1001 recommended)
Validity3 years

→ Deep dive: §1 Exam Details

The 10 Domains

Splunk publishes exact weightings. Correlating Events (15%) is the single biggest domain and hides the most-tested trap (transaction vs stats). Almost everything else is a flat 10%.

#DomainWeightDeep dive
1Transforming commands for visualizations (chart, timechart)5%→ §3
2Filtering & formatting results (eval, search/where, fillnull)10%→ §4
3Correlating events (transaction vs stats)15%→ §5
4Creating & managing fields (Field Extractor)10%→ §6
5Field aliases & calculated fields10%→ §7
6Tags & event types10%→ §8
7Macros10%→ §9
8Workflow actions (GET/POST/Search)10%→ §10
9Data models10%→ §11
10Common Information Model (CIM) add-on10%→ §12

SPL Snapshot

Transforming

chart, timechart, stats, top, rare — build result tables for viz. →

Filter / eval

search, where, eval, fillnull — refine & compute. →

Correlate

transaction (maxspan/maxpause) vs stats … by. →

Enrich

rex, erex, lookup, field aliases, calculated fields. →

Knowledge objects

tags, event types, macros, workflow actions. →

Model

data models → pivot; accelerate → tstats; CIM normalization. →

Recommended Materials (community consensus)

The consensus stack: "Splunk Zero to Power User" (Udemy) as the #1 structured course → Splunk's free official eLearning modules to reinforce → hands-on in a free Splunk instance with the tutorial data / Boss of the SOC → Splunk Docs (Search Reference) to fill gaps → optional practice questions (verify every answer against docs). Avoid braindumps.

→ Full breakdown with sources (§14)

Study Plan (Quick Version)

  1. Map to weightings: put extra time on Correlating Events (15%) and the abstract topics (data models, CIM).
  2. Learn by doing: work the free eLearning modules and build every knowledge object yourself in a free Splunk instance.
  3. Active recall: after each topic, reproduce the search from memory; drill the confusable pairs (alias vs calc field, tags vs event types, transaction vs stats).
  4. Practice + docs: take practice questions, verify answers in Splunk Docs, patch gaps, then book.

→ Detailed retention-based plan (§15) · ⚡ Cram Jam

Part 2 — Thorough Study Guide

1 · Exam Details

  • 65 questions in 60 minutes (about 3 minutes goes to the exam agreement, leaving ~57 minutes). That's ~52 seconds per question — pace yourself and flag-and-return on hard ones.
  • Multiple choice & multiple response. Some questions have more than one correct answer; read the stem for "select two."
  • $130 per attempt, delivered via Pearson VUE online-proctored or at a test center. Certification is valid 3 years.
  • No prerequisite exam. Splunk recommends the free Core Certified User path first, and about a year of hands-on Splunk use, but nothing blocks you from registering.
  • Splunk does not publish the exact cut score; community consensus is around 70% (miss ~18–20 of 65).

2 · Search Fundamentals

  • The search pipeline: SPL flows left-to-right through pipes (|). Each command transforms the results and passes them on.
  • Index-time vs search-time: most Power User work (field extraction, aliases, calculated fields, tags, event types) happens at search time — it's schema-on-read, applied when you run the search, not when data is indexed.
  • Time is king: the time range picker bounds every search; _time is the default time field. Narrowing time is the biggest performance lever.
  • Fields: default fields include _time, host, source, sourcetype, index. sourcetype classifies the data format and drives extractions.
  • Knowledge objects = reusable artifacts you create to enrich/categorize data: saved searches/reports, extracted fields, aliases, calculated fields, tags, event types, macros, workflow actions, data models, lookups.

3 · Transforming Commands for Visualizations 5%

Transforming commands order results into a statistical table (rows/columns) that Splunk can turn into a chart. The transforming commands: chart, timechart, stats, top, rare, contingency. (table, fields, and eval are not transforming.)

CommandBehavior
chartBuilds a 2-D table: chart <func> over <fieldA> by <fieldB>. One over + one by max. over sets the x-axis.
timechartx-axis is always _time; buckets by time with span=; only one split by field allowed.
statsThe workhorse aggregation: stats <func> by <field>. No implicit time axis.
top / rareMost/least common values; top auto-adds count & percent; default limit=10.

Common stats functions: count, sum, avg, min, max, values (unique, multivalue), list (all, ordered), dc/distinct_count, first, last, stdev, perc95.

  • Worked examples: ... | timechart span=1h count by status (hourly trend, one line per status) vs ... | chart count over host by status (hosts on x-axis, one series per status) vs ... | stats avg(bytes) by host, status (plain table, two group-by fields — something chart/timechart can't split twice).
  • values() returns unique values (deduped, lexicographic); list() returns all values in event order (up to 100) — a favorite distinction.
  • bin (alias bucket) manually groups a numeric/time field into buckets when you want stats-style control: ... | bin _time span=5m | stats count by _time.
Exam signal Trend over time → timechart. Compare one field split by another → chart … over … by. Aggregate without a time axis → stats.

4 · Filtering & Formatting Results 10%

  • eval — computes a new (or overwrites a) field with an expression. Functions include if(), case(), coalesce(), round(), len(), lower()/upper(), tostring(), strftime(). eval does not filter — it creates fields.
  • search — matches keywords/literal terms; can appear again mid-pipeline to filter results.
  • where — evaluates a boolean eval expression. It's the one that can compare field-to-field (e.g. | where bytes_in > bytes_out) and use eval functions like like(), cidrmatch(), isnull().
  • fillnull — replaces null values; default replacement is 0. Override: | fillnull value="N/A"; limit to specific fields: | fillnull value="-" status host.

eval patterns you should be able to read

  • | eval speed = round(bytes/1024, 2) — arithmetic + rounding.
  • | eval level = if(status>=500, "error", "ok") — two-way branch; case() for multi-way: case(status>=500,"error", status>=400,"warn", true(), "ok") (the true() arm is the catch-all).
  • | eval user = coalesce(username, userid, "unknown") — first non-null wins (great for merging inconsistent fields).
  • Strings concatenate with a period: | eval endpoint = host . ":" . port.
search vs where Use search to match values/keywords; use where to compare two fields or use eval functions. "Keep events where field A > field B" → where. Also: search treats bare terms case-insensitively; where field values are case-sensitive comparisons.

5 · Correlating Events 15% — biggest domain

Grouping related events (e.g. all events of one session/transaction). The central decision is transaction vs stats.

transaction

  • Groups events into a single multivalue event. Key options: maxspan (max total duration), maxpause (max gap between events), startswith / endswith (boundary conditions).
  • Auto-creates two fields: duration (first→last event) and eventcount.
  • Resource-expensive and does not scale well.

stats

  • stats … by <id> groups by a common field and is far faster / scalable.

The same question, both ways

  • Session duration with transaction: ... | transaction JSESSIONID maxpause=15m | table JSESSIONID duration eventcount
  • Equivalent with stats: ... | stats range(_time) as duration, count as eventcount by JSESSIONID — same numbers, far cheaper. Being able to rewrite one as the other is exactly what the 15% domain tests.
  • Example with boundaries (where transaction IS right): ... | transaction clientip startswith="login" endswith="purchase" — start/end conditions can't be expressed with stats.
  • Other transaction behaviors: events must share the transaction field(s); results are returned with the events reverse-time-ordered inside each transaction; orphaned/incomplete groups can be kept or discarded (keepevicted).
The #1 exam trap Prefer stats for performance. Use transaction ONLY when you truly need to: (a) keep the raw event text, (b) group by start/end conditions, or (c) constrain a group by time (maxspan/maxpause). Otherwise stats ... by is the correct answer.

6 · Creating & Managing Fields 10%

The Field Extractor (FX) creates search-time field extractions with two methods:

MethodUse forInline SPL
Regular ExpressionUnstructured data — highlight sample values and Splunk builds the regex.rex (and erex for example-based)
DelimitersStructured data — pick a delimiter (comma/tab/space/pipe) then name the fields.—
  • rex field=_raw "(?<user>\w+)" extracts on the fly with a named capture group (?<name>pattern) — the group name becomes the field name. rex defaults to _raw if no field is given; it can also mode=sed to mask/replace values.
  • erex lets you give example values and generates the regex for you — then shows the regex so you can reuse it with rex (more efficient).
  • The FX is reached from Settings ▸ Fields ▸ Field extractions, or straight from search results ("Extract New Fields"). Extractions are tied to a sourcetype (or source/host).

Lookups — enriching events with external data

  • A lookup adds fields from an external table (usually a CSV) to your events — e.g. map status=404 → description="Not Found", or product IDs → names/prices.
  • Setup order: upload the lookup table file (CSV) → create a lookup definition (names it for SPL) → optionally make it an automatic lookup (applied to a sourcetype at search time, no SPL needed).
  • | lookup products product_id OUTPUT product_name price — enrich events by matching product_id.
  • | inputlookup products.csv — read the table itself (starts a search from the file, no events needed). | outputlookup mytable.csv — write search results to a lookup file (build/refresh reference tables from searches).
  • The lookup's matching field doesn't have to share the event field's name — map it in the lookup command/definition. Case sensitivity is configurable in the definition.

Knowledge object permissions

  • Every knowledge object (extraction, alias, tag, event type, macro, lookup, data model) has a sharing level: Private (owner only) → App (users of that app) → Global (all apps).
  • The Power role can create and share knowledge objects at the app level — that's the role this cert maps to; regular Users create only private objects by default. Admins manage global sharing and reassign orphaned objects.

7 · Field Aliases & Calculated Fields 10%

Field AliasCalculated Field
What it doesGives an alternate name for an existing fieldCreates a new field from an eval expression
New data?No — same values, another nameYes — computed at search time
Examplesrc_ip ⇄ clientipbandwidth = bytes/1024
Remember Alias = rename an existing field. Calculated field = eval a new field. A calculated field is essentially a saved eval applied automatically.

8 · Tags & Event Types 10%

Event TypeTag
DefinitionA saved search string that categorizes events; matches get an eventtype field value.A label applied to a field=value pair (or to an event type).
CardinalityEssentially a named search (no time range, no pipes/transforming cmds).One field=value can carry many tags; one-to-many.
UseClassify events, e.g. eventtype=failed_login.Normalize across sources, e.g. tag all auth events authentication.
Trap Event type = a search that names events. Tag = a label on a field/value. Event types can't contain pipes or transforming commands or a time range.

9 · Macros 10%

  • A macro is reusable SPL saved under Settings ▸ Advanced Search ▸ Search macros (backed by macros.conf).
  • Invoke with backticks: `mymacro` or with arguments `mymacro(arg1,arg2)`.
  • Arguments are referenced inside the definition as $argname$. Set the number of args in the macro name, e.g. mymacro(2).
  • Macros can include a validation expression to check argument values before running (with a custom error message on failure).
  • Worked example: define convert_bytes(1) as eval mb = round($field$/1024/1024, 2), then call `convert_bytes(bytes)` in any search. Change the definition once and every search using it updates — the whole point of macros.
  • Preview what a macro expands to before running: expand the search with Ctrl+Shift+E (Cmd+Shift+E on Mac) in the search bar.
  • Macros can contain full or partial SPL — a filter fragment, an eval, or an entire base search shared across dashboards.
Signals Backticks = a macro call. $arg$ = a macro argument placeholder. Macro name foo(2) means it takes two arguments.

10 · Workflow Actions 10%

Configured under Settings ▸ Fields ▸ Workflow actions; scoped to specific fields/sourcetypes. Three types:

TypeDoes
GETOpens a URL/link, passing field values in the query string (e.g. look up an IP on a threat-intel site).
POSTSends an HTTP POST request with field values.
SearchLaunches a secondary Splunk search built from field values.
  • Field values are inserted with $field$ tokens — e.g. a GET action opening https://whois.example.com/lookup?ip=$clientip$, or a Search action running index=security src=$src$ over a chosen time range.
  • Actions appear in the event actions / field-value dropdown in search results; you scope where they show (which fields/event types) and whether they open in a new window.
  • Classic exam scenario: "analyst clicks an IP in results and it opens an external threat-intel page" → GET. "…submits the value to an internal ticketing API" → POST. "…pivots to a second search for that value" → Search.

11 · Data Models & Pivot 10%

  • A data model is a hierarchical, semantic mapping of your data, made of datasets/objects (types: event, search, transaction) with attributes (auto-extracted, eval-based, lookup, regex, or geo-IP). Child objects inherit the parent's constraints.
  • Pivot is the point-and-click reporting/visualization UI that runs on top of a data model — no SPL required.
  • The relationship (heavily tested): a data model is required to use Pivot; Pivot is the front-end for the model.
  • Acceleration builds a high-performance summary; accelerated models are queried with tstats for speed (e.g. | tstats count from datamodel=Web by Web.status).
  • Acceleration trade-offs: it consumes disk/CPU to maintain the summary, and an accelerated model can't be edited without disabling acceleration first. Only event and search-rooted datasets accelerate — not transaction-rooted ones.
  • Build hierarchy: root dataset defines the base constraint (e.g. index=web sourcetype=access_*); child datasets narrow it (e.g. "purchases" = parent + action=purchase) and inherit all parent attributes.
Trap You cannot use Pivot without a data model. Object types are event, search, transaction. Acceleration → query with tstats; editing requires disabling acceleration.

12 · Common Information Model (CIM) 10%

  • The CIM (Splunk_SA_CIM add-on) is a shared, standardized set of field names + tags + prebuilt data models (e.g. Authentication, Network Traffic, Web, Malware).
  • Purpose: normalize data at search time so dashboards and apps (like Enterprise Security) work across many different data sources.
  • You make data CIM-compliant by mapping your fields to CIM field names (via aliases/calculated fields/extractions) and applying the CIM tags (via event types) — all search-time, so no re-indexing is ever needed.
  • Example mapping: your firewall logs call the source src_ip, the CIM's Network Traffic model expects src → create a field alias; then an event type + tags (network, communicate) make the events land in the model.
  • The add-on ships ~20+ predefined data models — common ones: Authentication, Network Traffic, Web, Malware, Endpoint, Email, Change, Intrusion Detection. Each model documents its required fields and tags.
  • CIM data models are disabled/unaccelerated by default; you constrain them to relevant indexes and accelerate the ones your dashboards use.
Why it matters CIM = a common vocabulary. Normalize once, and any CIM-aware dashboard/app understands your data regardless of its original format.

13 · Knowledge Object Search-Time Order

Search-time operations apply in a set order — a favorite exam topic:

Field extraction → Field aliases → Calculated fields (eval) → Lookups → Event types → Tags

Why order matters An alias exists before calculated fields run, so a calculated field can reference an aliased name; tags are applied last, on top of everything (including event types).

14 · Study Materials (community consensus)

Reddit (r/Splunk) is hard to crawl, so this is triangulated from the official Splunk Community forum, two detailed first-hand "how I passed" write-ups, and the official blueprint — which all converge on the same advice.

TL;DR: "Splunk Zero to Power User" (Udemy) is the #1 training pick — it takes you from beginner through exactly what SPLK-1002 tests. Back it with Splunk's free official eLearning modules, hands-on in a real Splunk instance, and Splunk Docs. Practice questions help, but verify every answer against docs and avoid braindumps.

1 · Training / courses

  • #1Splunk Zero to Power User (Udemy) — the top community training pick: a single structured course that takes you from no Splunk experience through the full Power User blueprint (SPL, knowledge objects, field extractions, data models, CIM), with hands-on demos you can follow in your own instance. Grab it on a Udemy sale like any Udemy course.
  • Splunk's free official eLearning modules — the free backbone, and the same modules the blueprint lists. Work through: Intro to Knowledge Objects, Creating Knowledge Objects, Creating Field Extractions, Statistical Processing, Comparing Values, Working with Time, Result Modification, Correlation Analysis, Data Models, and Search Under the Hood. All free & self-paced — great on their own or as reinforcement alongside Zero to Power User.
  • Naming note: older posts say "do Splunk Fundamentals 1 & 2" — that series was retired and replaced by individual free modules + "Fast Start" bundles. Same content.
  • Pluralsight — "Splunk Core Certified Power User (SPLK-1002)" path (~9 hrs, 7 courses) as an alternative structured-video option.
  • YouTube: the official Splunk How-To channel (recommended in the blueprint) and community favorite "Splunk With Praveen" (called out for workflow actions & macros).

2 · Practice questions

Use with caution. Practice questions are great for gauging style and finding weak spots, but community stance is firm: braindumps (ExamTopics "actual questions", etc.) are often outdated or wrong and using them to memorize is cheating that undermines the cert. Named paid banks: Udemy SPLK-1002 practice tests, Gururo. Independently verify every answer against Splunk Docs — sample banks contain errors.

3 · Hands-on (everyone's #1 tip after the free courses)

  • Build a real Splunk instance: Splunk Enterprise free license (500 MB/day) or a Splunk Cloud free trial. Load the official tutorial data.
  • Boss of the SOC (BOTS) datasets (GitHub) — the community's favorite realistic SPL playground.
  • Do-it-yourself checklist: create a regex FX, a delimiter FX, a field alias, a calculated field, a tag, an event type, a macro (with and without arguments), all three workflow-action types, and a data model — then run a transaction with maxspan/maxpause and reproduce it with stats.

4 · Free reference

  • Splunk Docs (docs.splunk.com), especially the Search Reference — the go-to for any SPL command gap.
  • Official Test Blueprint + Splunk Certification Study Guide — map your time to the weightings.
  • Splunk How-To YouTube, Splunk4Rookies workshops, community office hours.

5 · Notes / cheat sheets

  • No book is commonly recommended (course-driven exam). Use the SPL Quick Reference / cheat sheet from Splunk Docs and build your own notes on the confusable pairs — the Cram Jam here is exactly that.

Sources

15 · Study Plan (Retention-Based, ≈2–4 weeks)

Splunk is a skill, not trivia — which makes it perfect for evidence-based, hands-on learning. Passive video-watching is the weakest approach here; doing the searches yourself is both the fastest way to pass and the way to actually retain SPL.

PrincipleHow to apply it to Splunk
Learn by doing (generation effect)For every concept, build it in a live instance — don't just watch. Typing the SPL yourself encodes it far better.
Active recallAfter each module, write the search from memory, then check. Quiz yourself on the confusable pairs.
Spaced repetitionRe-drill older commands daily (5–10 min) before new material; flashcard the pairs (alias/calc, tags/eventtype, transaction/stats).
InterleavingMix domains in practice rather than finishing one 100% before the next — mirrors the exam.
Elaboration (Feynman)Explain out loud why stats beats transaction, or what CIM is for. Stumbles = restudy targets.
PhaseFocusActions
Week 1Search + transforming + filteringStart Zero to Power User (or the free eLearning) for basics, chart/timechart/stats, eval/where/fillnull. Load tutorial data; reproduce every example yourself.
Week 2Correlation + fields + knowledge objectsDeep-dive Correlating Events (15%): build transactions and stats equivalents. Create FX extractions, aliases, calculated fields, tags, event types, macros, workflow actions.
Week 3Data models, pivot, CIMBuild a data model + pivot; explore the CIM add-on and map fields. These are the most abstract topics — hands-on makes them concrete.
Week 4Practice + gaps + taperPractice questions (verify vs docs), interleaved review, re-drill weak areas. Light review + good sleep before exam day; skim the Cram Jam.

Typical prep: daily Splunk user 1–2 weeks · regular user 2–3 weeks · newer 3–5 weeks. Compress/stretch the phases accordingly.

Readiness bar You're ready when you can, from memory, write a stats that replaces a given transaction, explain alias vs calculated field and tag vs event type, and describe what a data model gives Pivot.

16 · Tips & Common Traps

  • transaction vs stats — the #1 trap. Default to stats; use transaction only for raw text / start-end / time-bounded grouping. Know maxspan, maxpause, startswith, endswith, and the auto fields duration & eventcount.
  • Field alias vs calculated field — rename existing vs eval-a-new-field.
  • Tags vs event types — label-on-value vs named-search categorization.
  • Workflow actions — GET (link/URL) vs POST (HTTP POST) vs Search (secondary search).
  • Macros — backtick invocation, $arg$ placeholders, arg count in the name name(2).
  • Data models & pivot — pivot requires a data model; object types are event/search/transaction; accelerate → tstats.
  • chart vs timechart vs stats — timechart's x-axis is always _time; chart uses over … by.
  • search vs where — where compares field-to-field & uses eval functions.
  • Pace: ~52 sec/question. Flag-and-return; don't stall.
Ignore "Guaranteed pass" dump sites (validexamdumps, certempire, dumpsgate, itexams, etc.) — outdated content and a cert-integrity risk. Official free training + Docs + hands-on is the reliable path.

↑ back to top