CIS-CSM study guide: pass the Customer Service Management specialist exam
A working architect's guide to the CIS-CSM exam: the account, contact, and consumer model, the case lifecycle, the entitlement trap, and a six week plan with hands-on PDI labs.
If you've spent your ServiceNow career in ITSM, Customer Service Management feels familiar right up until the moment it doesn't. The forms look the same. The cases look like incidents wearing a different shirt. Then somebody asks whether a person should be a contact or a consumer, and whether the entitlement lives on the contract or the account, and the ITSM instincts you trusted for years quietly betray you.
That's exactly why the CIS-CSM certification is worth having. It tests the thing that actually sinks CSM projects: the data model decisions you make in week one, before a single case exists. I've been called in to rescue more than one CSM implementation, and every time the root cause was the same: someone modeled customers wrong at the start, and everything downstream inherited the damage.
Who is it for? Consultants and admins moving into customer workflows, ITSM people whose company just bought CSM, and anyone who wants to work on the side of ServiceNow that touches revenue. Honest value: it won't make you a customer service expert or teach you to negotiate with a client's VP of Support. It proves you understand the machinery well enough to implement it without the classic mistakes, and in the partner ecosystem that's a bankable signal, because CSM is growing faster than the pool of certified implementers.
The exam at a glance
The exam is a proctored, multiple choice affair delivered through Now Learning, online or at a test center. The blueprint groups questions into domains that look roughly like this:
| Domain | Approximate weight |
|---|---|
| CSM fundamentals and personas | ~10% |
| Core entities: accounts, contacts, consumers, products | ~20% |
| Case management and the case lifecycle | ~25% |
| Communication channels and self-service | ~15% |
| Contracts, entitlements, and SLAs | ~10% |
| Integrations with ITSM and other applications | ~10% |
| Reporting, surveys, and performance | ~10% |
Treat those weights as directional, not gospel. ServiceNow revises blueprints with releases, and question counts and duration shift too, so check the current exam blueprint on Now Learning before you book. What has stayed constant: the data model and case management together carry close to half the exam, so that's where your hours go.
Before you start
CSA comes first. The Certified System Administrator certification is the required prerequisite for every CIS track, this one included. If you don't have CSA yet, stop here and go get it. Nothing in this guide lands properly if forms, tables, ACLs, and flows aren't already second nature.
The implementation course. ServiceNow's published path runs through the relevant fundamentals and implementation courses on Now Learning. Requirements change, so verify the current prerequisites there rather than trusting a blog post, including this one.
A PDI with CSM activated. You can activate the Customer Service Management plugin on a personal developer instance, and you should. Every concept here gets ten times stickier once you've clicked through it. The labs later assume you have it.
Helpful but not required: some ITSM background, because the exam expects you to understand what happens when a case escalates to an incident, and a passing familiarity with Service Portal, because two portals feature heavily.
The concepts that actually matter
CSM vs ITSM: get the mental model right first
Here is the single sentence that unlocks the whole product: ITSM serves employees, CSM serves customers. That sounds trivial. It is not.
An ITSM incident is raised by someone inside your company, about your own services, and resolved by your own staff. Identity is simple: everyone is a sys_user in one directory. A CSM case is raised by someone at a different company (or a private individual), about a product they bought from you, under a commercial contract. Identity is suddenly hard: which company do they belong to, can they see their colleagues' cases, how much support did they actually pay for?
Every distinctive feature of CSM falls out of that one difference. Accounts exist because customers arrive in company-shaped groups. Entitlements exist because support is something customers purchase in measured quantities. The external portals exist because you cannot hand strangers your fulfiller UI. When an exam question feels ambiguous, ask "who is this person to the company running the instance?" and the answer usually surfaces.
The data model: accounts, contacts, and consumers
This is the heart of the exam and the heart of the product. Learn it until you can draw it on a napkin. Here's the conceptual map, showing what hangs off what (relationships, not strict table extension):
CSM data model
├── customer_account the customer company, extends core_company
│ ├── customer_contact a person at that company, extends sys_user
│ ├── child accounts account hierarchies for big enterprises
│ ├── ast_contract the commercial agreement
│ │ └── service_entitlement what support that agreement promises
│ ├── sold products / install base what the customer actually owns
│ └── sn_customerservice_case the work itself, extends task
└── csm_consumer an individual person (B2C), no account, own table
Walk through it. An account is a company you do business with, stored on customer_account, extending core_company. Accounts nest into hierarchies (a global parent, regional children) and carry account teams so the right account manager is always attached.
A contact is a person who works at an account. This is the crucial part: customer_contact extends sys_user. Contacts are real users of your instance. They log in to the portal, they have roles, they open cases on behalf of their company. B2B, always.
A consumer is a private individual with no account behind them, stored on csm_consumer, its own table rather than an extension of sys_user. Think of someone who bought your dishwasher at a retail store. B2C, always.
The exam adores this distinction. The answer to every "what record represents this person" scenario hinges on whether a company relationship exists. Company between you and the person: contact under an account. No company: consumer. Drill it until it's reflexive.
Rounding out the model: sold products and install base records track what a customer actually owns, so a case can point at the specific broken thing, and contracts hold the commercial terms that entitlements hang off.
Entitlements: the trap the exam sets for everyone
If the data model is the heart of the exam, entitlements are its favorite trick. An entitlement answers "how much support did this customer pay for, through which channels, for which products?" It might say: this account gets 50 cases per year via web and phone, on the premium product line, until the contract expires.
The machinery: entitlements are defined per account, per contract, or per product, and when someone tries to create a case, the platform runs an entitlement check: does this customer, through this channel, for this product, have coverage? No valid entitlement can block case creation through that channel entirely, or flag the case for special handling, depending on configuration.
Why a trap? Because ITSM people have no muscle memory for it. Nothing in incident management ever asked "is this employee allowed to have problems?" So when the exam asks why a contact cannot create a case from the portal, the ITSM-trained brain hunts for ACLs and roles, and never checks whether the entitlement ran out of units or the contract expired. Both matter.
When a case creation scenario fails in an exam question, resist the pure-ACL reflex. If the question mentions contracts, products, channels, or support volumes anywhere, the answer almost certainly involves entitlements.
Case management and the lifecycle
The case (sn_customerservice_case, extending task) is where daily work happens. Out of the box the lifecycle runs through states like New, Open, Awaiting Info, Resolved, and Closed, with Cancelled for the cases that shouldn't have existed. Here's the shape of a case's life:
Three case features earn their own exam questions. Special handling notes are pop-up alerts attached to accounts, contacts, or cases that smack an agent in the face when they open the record: "VIP account, executive escalation history, handle with care." They are visibility tools, not workflow tools, and the exam checks that you know the difference between a special handling note and a work note.
Major case management exists for the day your product breaks for two hundred customers simultaneously. Rather than two hundred disconnected cases, you designate (or promote a candidate into) a major case, relate the child cases to it, and communicate from the parent outward. One investigation, one communication stream.
Case types let different flavors of customer work carry different fields, flows, and playbooks: product support case, order case if you run Order Management, and whatever your implementation adds via record producers.
Roles and the two portals
CSM ships a bundle of roles in the sn_customerservice scope, and the exam expects you to know which side of the fence each lives on. Fulfiller side: the agent role (sn_customerservice_agent) works cases, the manager role (sn_customerservice_manager) runs queues and teams. External side: contacts carry the customer role, consumers carry the consumer role, and, my favorite, customer administrators (sn_customerservice.customer_admin) are contacts who manage their own company's contacts and see their company's cases from the portal, so you're not fielding a case every time the customer hires someone. Add the proxy pattern (internal users creating cases on behalf of a contact who phoned in) and the partner roles, and you have the full cast.
Two portals, and the pairing is pure exam bait: the Customer Service Portal serves B2B contacts, the Consumer Service Portal serves B2C consumers. Same platform, different audiences, different registration flows. Memorize the pairing in both directions, because the exam tests it in both directions.
Impersonation is your best study tool here. On your PDI, impersonate a contact, then a customer admin, then a consumer, and notice what each can see. Ten minutes of that beats an hour of reading role tables.
Channels, self-service, and getting work to people
Customers reach you through portal, email, chat, and phone. Portal intake typically flows through record producers, friendly forms that create cases (and different case types) with the right fields pre-shaped. Email creates and updates cases through inbound actions. Chat runs through Virtual Agent or live agents. Phone integrates through computer telephony integration (CTI), which pops the caller's account and open cases onto the agent's screen as the call connects. For the exam you need the channel map, not deep configuration of any single channel.
Once work arrives, someone has to catch it. Advanced Work Assignment (AWA) is the routing engine: work items flow into queues through service channels (cases, chats), assignment criteria decide eligibility, and agent capacity and availability decide who gets the next item. The key idea: AWA pushes work to available agents based on capacity, rather than agents cherry-picking from a list. Know the vocabulary: service channel, queue, assignment criteria, capacity, presence.
Self-service closes the loop on intake. Every case a customer solves themselves is a case your agents never see, and CSM leans hard into that. Knowledge bases can be exposed on the portals, with visibility controlled so external users see curated, customer-safe articles rather than your internal runbooks. Communities add peer-to-peer forums and Q&A where customers answer each other. The exam treats both as deflection infrastructure: expect questions about which capabilities reduce case volume and how article visibility differs for external audiences.
Playing with ITSM, workspaces, and measuring it all
CSM does not resolve everything by itself. When a case reveals a genuine defect or infrastructure issue, the agent escalates: create an incident, problem, or change from the case and relate the records. The critical principle, and a reliable exam question: the case remains the customer-facing record owned by customer service, while the incident is the internal record owned by IT. The customer never talks to the incident. When IT resolves their record, the agent closes the loop through the case. That separation of audiences is the entire point.
Agents live in the CSM Configurable Workspace: multi-tab case handling, customer context, agent assist, and playbooks that walk agents through multi-step processes as visual task sequences. Know that playbooks orchestrate case flows and the workspace is configurable through UI Builder, at the "what is this for" level.
Finally, measurement. CSAT comes from surveys triggered around case resolution and closure, and dashboards track the classics: case volume, first contact resolution, time to resolution, SLA compliance, satisfaction. Performance Analytics ships CSM content for trending these over time. The exam stays at "what would you use to measure X", so map metrics to mechanisms and you're covered.
A six week study plan
Week one: foundations and the data model. Take the fundamentals content on Now Learning, then spend lab time building accounts, contacts, and consumers by hand. Draw the data model from memory at the end of the week. If you can't, repeat until you can.
Week two: case management. Case lifecycle, case types, special handling notes, major case management. Create twenty cases on your PDI and push them through every state transition, including the unhappy paths: cancellation, reopening after resolution, auto-close.
Week three: channels and portals. Configure a record producer, walk both portals as their respective personas, set up a basic AWA queue and watch it route. Read up on CTI and chat at the conceptual level; you don't need a phone system to understand screen pop.
Week four: contracts, entitlements, integrations. Build contracts and entitlements on your PDI and break them on purpose: expire a contract, exhaust a channel, then try to create cases. Escalate a case to an incident and resolve the loop end to end.
Week five: the long tail plus weak spots. Knowledge for external audiences, communities, workspace and playbooks, CSAT and reporting. Then be honest about your two weakest domains and reread those, because the exam will find them even if you don't.
Week six: consolidation. Re-take the course knowledge checks, quiz yourself from the blueprint line by line, and do a full role-play lab: customer onboarded, contract signed, entitlement created, case raised on the portal, escalated, resolved, surveyed. If you can narrate every step and name every table involved, book with confidence.
Hands-on labs on your PDI
Activate the Customer Service Management plugin first. Then work through these in order; each builds on the last.
Lab 1: build the customer universe. Create an account with a parent account above it, three contacts (one flagged as customer admin), and one consumer. Look at the actual tables: confirm for yourself that the contact appears in sys_user and the consumer does not.
Lab 2: special handling notes. Add a note to your account ("Strategic customer, manager visibility on all P1s"). Open a case for that account as an agent and watch when and where the note appears.
Lab 3: contracts and entitlements. Create a contract for your account and an entitlement with a small number of case units on the web channel. Create cases until the units run out and observe what the platform does next. This single lab teaches more about entitlements than any course slide.
Lab 4: the portal experience. Impersonate a contact and create a case from the Customer Service Portal. Impersonate your customer admin and find your colleagues' cases. Impersonate the consumer on the Consumer Service Portal and notice everything that's different.
Lab 5: record producer for a new case type. Build a record producer that creates a case with a category preset and a couple of custom questions mapped to case fields. Publish it to the portal and create a case through it.
Lab 6: AWA routing. Configure a service channel and queue for cases, set assignment criteria, give two agent users different capacities, and watch AWA distribute new cases between them.
Lab 7: escalate to ITSM. Take an open case and create an incident from it. Resolve the incident as an ITSM user, then return to the case as a CSM agent and close the loop with the customer. Note which record carried the customer communication the whole time.
Lab 8: measure it. Attach a survey to case closure, close a few cases, submit responses, and build one report on case volume by account and one on satisfaction. Skim the Performance Analytics CSM content while you're there.
How the questions try to trick you
The CIS-CSM question writers have a few favorite moves. I've watched well-prepared people fall for every one of these.
The contact/consumer switcheroo. A scenario describes a person needing support, buries one clue about whether a company sits between them and you, and offers both "create a contact" and "create a consumer" as answers. Slow down and hunt for the company. No business relationship: consumer. Works for a customer company of yours, however small: contact under an account.
The entitlement misdirection. Case creation fails, and the answer choices include roles, ACLs, portal configuration, and entitlements. If the scenario mentions a contract, a channel, or "number of cases" anywhere, it's the entitlement. The question is testing whether you remember the check exists at all.
The wrong-portal pairing. "A consumer needs to register and raise a case, which portal?" Both portals will appear as answers, phrased plausibly. If you memorized the pairing only one direction, the reversed phrasing will get you.
The escalation ownership trap. A case was escalated to an incident, and the question asks who communicates the fix to the customer. The tempting answer is the incident's assignee. The right answer is the CSM agent through the case, because the case is the customer-facing record. Internal records never talk to customers.
Notes that sound alike. Special handling notes versus work notes versus additional comments. Special handling notes alert agents proactively; work notes are internal journal entries; additional comments are customer-visible. Three different jobs, one confusing family of names.
The scope-creep answer. Some questions offer a technically-possible-but-wrong answer, like customizing the case table where a case type or record producer would do. When two answers both "work," pick the one using the purpose-built CSM feature. This exam rewards knowing what the product already does.
Read every scenario twice before looking at the answers. The distinguishing detail in CIS-CSM questions is usually a single phrase: "purchased from a retailer", "the contract expired last month", "on behalf of the caller". Miss the phrase, miss the mark.
Exam week checklist
- Confirm your booking, exam rules, and blueprint version on Now Learning. If online proctored, test your machine, webcam, and network a few days early.
- Redraw the data model from memory one final time: account, contact, consumer, contract, entitlement, sold products, case. Both the boxes and the lines.
- Recite the pairings out loud: contact with Customer Service Portal, consumer with Consumer Service Portal. Silly, but it works.
- Rerun Lab 3 (entitlements) and Lab 7 (escalation) once more. Those two labs cover the two most heavily tricked topics.
- Skim the role list one last time, sorting each role into fulfiller-side or customer-side.
- The night before: stop. Cramming past this point trades accuracy for anxiety.
- During the exam: flag anything uncertain and move on. Unanswered questions score zero; flagged ones you revisit with a calmer brain.
After you pass
First, the housekeeping: CIS certifications stay current through delta exams tied to platform releases, so watch Now Learning and knock yours out when they appear. Letting a cert lapse over a skipped delta is a silly way to lose it.
Then put the paper to work. If you're at a partner, get onto a CSM implementation in any capacity, because the distance between certified and battle-tested is one real project's worth of messy customer data. If you're in-house, volunteer to own the data model conversations, since you now know more about accounts, contacts, and entitlements than most people in the room.
For the road ahead, CIS-CSM pairs naturally with Field Service Management if your world involves technicians in trucks, and the broader Implementation Specialist portfolio stacks nicely toward architect-track ambitions. And genuinely: write down what surprised you about the exam while it's fresh, and share it with the next person on your team who's booking. The ecosystem runs on that kind of generosity, and you just became someone worth asking.