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 prerequisitePart 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.
Exam at a Glance
| Attribute | Value |
|---|---|
| Exam code | SPLK-1002 |
| Questions | 65 multiple choice / multiple response |
| Time | 60 minutes (includes ~3 min agreement → ~57 min to answer) |
| Passing score | Not officially published; community estimate ~70% |
| Cost | $130 USD per attempt |
| Delivery | Pearson VUE — online proctored or test center |
| Prerequisite | None (SPLK-1001 recommended) |
| Validity | 3 years |
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%.
| # | Domain | Weight | Deep dive |
|---|---|---|---|
| 1 | Transforming commands for visualizations (chart, timechart) | 5% | → §3 |
| 2 | Filtering & formatting results (eval, search/where, fillnull) | 10% | → §4 |
| 3 | Correlating events (transaction vs stats) | 15% | → §5 |
| 4 | Creating & managing fields (Field Extractor) | 10% | → §6 |
| 5 | Field aliases & calculated fields | 10% | → §7 |
| 6 | Tags & event types | 10% | → §8 |
| 7 | Macros | 10% | → §9 |
| 8 | Workflow actions (GET/POST/Search) | 10% | → §10 |
| 9 | Data models | 10% | → §11 |
| 10 | Common Information Model (CIM) add-on | 10% | → §12 |
SPL Snapshot
Knowledge objects
tags, event types, macros, workflow actions. →Recommended Materials (community consensus)
Study Plan (Quick Version)
- Map to weightings: put extra time on Correlating Events (15%) and the abstract topics (data models, CIM).
- Learn by doing: work the free eLearning modules and build every knowledge object yourself in a free Splunk instance.
- 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).
- Practice + docs: take practice questions, verify answers in Splunk Docs, patch gaps, then book.
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;
_timeis the default time field. Narrowing time is the biggest performance lever. - Fields: default fields include
_time,host,source,sourcetype,index.sourcetypeclassifies 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.)
| Command | Behavior |
|---|---|
chart | Builds a 2-D table: chart <func> over <fieldA> by <fieldB>. One over + one by max. over sets the x-axis. |
timechart | x-axis is always _time; buckets by time with span=; only one split by field allowed. |
stats | The workhorse aggregation: stats <func> by <field>. No implicit time axis. |
top / rare | Most/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(aliasbucket) manually groups a numeric/time field into buckets when you want stats-style control:... | bin _time span=5m | stats count by _time.
4 · Filtering & Formatting Results 10%
eval— computes a new (or overwrites a) field with an expression. Functions includeif(),case(),coalesce(),round(),len(),lower()/upper(),tostring(),strftime().evaldoes 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 likelike(),cidrmatch(),isnull().fillnull— replaces null values; default replacement is0. 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")(thetrue()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 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) andeventcount. - 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).
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:
| Method | Use for | Inline SPL |
|---|---|---|
| Regular Expression | Unstructured data — highlight sample values and Splunk builds the regex. | rex (and erex for example-based) |
| Delimiters | Structured 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.rexdefaults to_rawif no field is given; it can alsomode=sedto mask/replace values.erexlets you give example values and generates the regex for you — then shows the regex so you can reuse it withrex(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 matchingproduct_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 Alias | Calculated Field | |
|---|---|---|
| What it does | Gives an alternate name for an existing field | Creates a new field from an eval expression |
| New data? | No — same values, another name | Yes — computed at search time |
| Example | src_ip ⇄ clientip | bandwidth = bytes/1024 |
eval applied automatically.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)aseval 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.
$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:
| Type | Does |
|---|---|
| GET | Opens a URL/link, passing field values in the query string (e.g. look up an IP on a threat-intel site). |
| POST | Sends an HTTP POST request with field values. |
| Search | Launches a secondary Splunk search built from field values. |
- Field values are inserted with
$field$tokens — e.g. a GET action openinghttps://whois.example.com/lookup?ip=$clientip$, or a Search action runningindex=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
tstatsfor 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.
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 expectssrc→ 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.
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
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.
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
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
transactionwithmaxspan/maxpauseand reproduce it withstats.
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
- Official Test Blueprint PDF · Splunk free courses · Splunk Community forum
- First-hand write-ups: Hacktivities · Pritesh Dammani · difficulty/tips guide
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.
| Principle | How 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 recall | After each module, write the search from memory, then check. Quiz yourself on the confusable pairs. |
| Spaced repetition | Re-drill older commands daily (5–10 min) before new material; flashcard the pairs (alias/calc, tags/eventtype, transaction/stats). |
| Interleaving | Mix 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. |
| Phase | Focus | Actions |
|---|---|---|
| Week 1 | Search + transforming + filtering | Start Zero to Power User (or the free eLearning) for basics, chart/timechart/stats, eval/where/fillnull. Load tutorial data; reproduce every example yourself. |
| Week 2 | Correlation + fields + knowledge objects | Deep-dive Correlating Events (15%): build transactions and stats equivalents. Create FX extractions, aliases, calculated fields, tags, event types, macros, workflow actions. |
| Week 3 | Data models, pivot, CIM | Build a data model + pivot; explore the CIM add-on and map fields. These are the most abstract topics — hands-on makes them concrete. |
| Week 4 | Practice + gaps + taper | Practice 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.
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 fieldsduration&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 namename(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 usesover … by. - search vs where — where compares field-to-field & uses eval functions.
- Pace: ~52 sec/question. Flag-and-return; don't stall.