# Service Catalog and Request Management

> Chapter 12 of the Courseiva SERVICENOW-CSA curriculum — https://courseiva.com/learn/servicenow-csa/service-catalog-and-request-management

**Official objective:** 3.3 — Manage the service catalog, catalog items, and request fulfillment.

## Introduction

How do you stop IT requests from getting lost in a sea of emails and informal messages? Service Catalog and Request Management gives employees a single, organised menu to request everything from a new laptop to software access, and gives IT a structured way to fulfil those requests without chaos. For the SNOW-CSA exam, this is a core topic because it tests how you build, configure, and manage this catalogue, and how you ensure requests are tracked from submission to completion.

## The Company Kitchen Analogy

When a company sets up a central kitchen, employees first realise they no longer need to bring their own lunch or negotiate with separate vendors for food. This leads to a standardised process where anyone can request a specific meal through a single menu, the kitchen then prepares and delivers it, and the finance team knows exactly how much each meal costs.

In this kitchen, the menu is your service catalogue, listing every available meal (laptop, software, access to a building) with clear descriptions, prices, and estimated prep time. The order form is your request for a specific meal, where you specify your requirements, like 'vegetarian' or 'no peanuts'. The kitchen staff receive your order and start the fulfilment process, which might involve cooking (provisioning a laptop) or simply handing over a pre-made salad (activating a software licence). The kitchen manager tracks every order from 'received' to 'completed', ensuring nothing is missed and that the customer is notified when their meal is ready.

If your order is urgent, the kitchen can prioritise it, just as an IT team can expedite a critical request. If the meal isn't available on the menu, the kitchen might offer a custom option through a 'request for something new' process. This whole system replaces chaotic, informal requests sent via email or shouted across the office, bringing order, transparency, and accountability to getting things done.

## Core explanation

Service Catalog and Request Management is the part of ServiceNow that turns scattered, ad‑hoc requests into a streamlined, trackable process. Imagine your company has fifty employees, each needing something different: a new mouse, access to a specific database, a visitor pass for a client. Without a system, they would email the IT helpdesk, who would reply asking for more details, then manually assign the task to a technician, who might forget about it. That is the old world.

ServiceNow replaces this chaos with a **service catalogue**, which is a centralised menu of all the standard services the IT department offers. Each item in the menu is called a **catalogue item**. When an employee wants to request something, they open the service catalogue, browse the available items, and fill out a **catalogue item form**, which is a structured set of fields asking for exactly the information IT needs to fulfil the request. For example, a catalogue item for 'New Laptop' might ask for the employee's name, department, preferred operating system, and whether they need a docking station.

Once the user submits the request, it becomes a **request** record in ServiceNow, which is a container for all the work required to fulfil what the user asked for. Inside that request, ServiceNow automatically creates one or more **requested items** (often called RITMs), each representing a specific deliverable. For the 'New Laptop' example, there might be one RITM for the laptop itself and another for the docking station. Each RITM then generates the actual tasks or **fulfilment tasks** (called **catalogue tasks** or **variable tasks**) that individual IT team members work on, such as 'order the laptop from the vendor', 'configure the laptop', and 'ship to the employee'.

This layered structure exists because it separates the user's view (a simple request) from the IT team's view (a set of tasks). The user can check the status of their request and see it progress from 'open' to 'fulfilled', while each technician sees only their assigned tasks. This prevents confusion and ensures accountability.

The system also handles **catalogue item variables**, which are the custom fields on the request form. These variables can be simple text fields, dropdowns, or even 'yes/no' checkboxes. Administrators configure these variables when building the catalogue item, and their values determine how the request is fulfilled. For instance, if a user selects 'macOS' as their preferred OS, a workflow rule might automatically skip the step for 'install Windows' and go straight to 'configure macOS settings'.

Service Catalog and Request Management also includes features like **request templates**, which let you pre‑fill common request forms for frequent scenarios (e.g., 'new hire onboarding'), and **order guides**, which allow a single request to include multiple catalogue items in one go. For example, a new hire might need a laptop, a phone, and software licences all at once. An order guide bundles these items together, so the user fills one form and gets everything they need.

Why does this exist? It replaces email, phone calls, and sticky notes with a digital, auditable trail. IT can measure how long requests take (fulfilment time), which items are most popular, and where bottlenecks occur. For the user, it provides transparency and a consistent way to ask for help. For the business, it ensures that every request is prioritised based on agreed service levels (SLAs) and that nothing falls through the cracks.

## Real-world context

Consider a large retail company with 5,000 employees. The IT team of 20 people handles everything from password resets to hardware provisioning. Without a service catalogue, the helpdesk receives dozens of emails daily with requests like 'Can I get a new monitor?' or 'I need access to the sales database'. Helpdesk agents spend hours clarifying what the user actually needs, manually assigning tasks, and chasing up technicians. This is inefficient and error-prone.

Now, the company implements ServiceNow Service Catalog and Request Management. The IT administrator builds a service catalogue with items such as: 'Request a New Monitor', 'Request Database Access', 'Reset Password', and 'New Employee Setup'. Each item includes a form with specific fields. For 'Request a New Monitor', the form asks: 'What size monitor?', 'Do you need a stand?', and 'Is this a replacement for an existing monitor?'. For 'Request Database Access', the form asks: 'Which database server?', 'What level of access (read-only, read-write, admin)?', and 'Manager approval required'.

A sales manager, Sarah, needs access to the sales database to build a quarterly report. She opens the service catalogue in the ServiceNow portal, finds the 'Request Database Access' item, fills in the form, and submits it. Here is what happens step by step:

- ServiceNow automatically creates a request record with a unique number (like REQ0012345) and links it to Sarah's user profile.
- Inside that request, it generates a requested item (RITM) for 'Database Access' with the details Sarah entered.
- Because the form included a field 'Manager approval required', ServiceNow sends an approval request to Sarah's manager, John. John receives an email with a link to approve or reject. He approves.
- Once approved, ServiceNow creates a catalogue task assigned to the database administrator, Maria, with instructions: 'Grant Sarah Read-Only access to SQLSVR01'.
- Maria sees the task in her work queue, executes the database change, and marks the task as 'Complete'.
- ServiceNow then updates the RITM status to 'Fulfilled', and Sarah receives an automated email saying her access is active.

If Sarah later needs a new monitor, she can track both requests from her portal dashboard, seeing which ones are still open, awaiting approval, or complete. The IT managers can run reports to see how many requests each team handles, which catalogue items are most requested, and whether any tasks are overdue. This data helps them plan resources and improve service delivery.

The IT team can also create **catalogue item variables** that conditionally show or hide questions based on previous answers. For instance, if a user selects 'Linux' as their operating system, a new field might appear asking for the specific distribution (Ubuntu, CentOS). This dynamic behaviour makes the form intelligent and reduces confusion.

In a real-world scenario, the Service Catalog and Request Management module also integrates with other ServiceNow modules. For example, if a request requires a software licence that is managed by the Software Asset Management module, the catalogue item can automatically create an asset record there. Or if the request involves a change to a production system (like adding a user to a critical server), a change request can be generated for approval, ensuring compliance with IT policies.

## Exam focus

The SNOW-CSA exam tests your understanding of the Service Catalog and Request Management module in several specific ways. Expect questions on the core components, the request lifecycle, and the administrative tasks you can perform as a ServiceNow administrator.

Here are the key topics and how they are tested:

- **Catalogue Items vs. Record Producers vs. Order Guides**: The exam loves to ask how they differ. A **catalogue item** is a standard service that generates a request for fulfilment by people (e.g., 'Install Software'). A **record producer** automatically creates a record in a specified table when a user submits the form (e.g., creating a new 'Hardware Asset' record directly from a form). An **order guide** groups multiple catalogue items and record producers into one guided request (e.g., 'New Employee Onboarding' bundles a laptop, phone, and software licences). Traps: They might word an option like 'record producer' when the scenario describes a fulfilment by a person, so you need to choose 'catalogue item'.

- **Request Lifecycle**: The stages are: Requested (submitted by user), Open (awaiting work), Work In Progress (assigned to a group/person), Fulfilled (work completed), Closed (all fulfilment tasks done and acknowledged). The exam may ask what happens when a user submits a catalogue item — the correct answer is that a request is created, along with one or more requested items (RITMs), and optionally catalogue tasks.

- **Variables and Variable Sets**: You need to know the types of variables (text, multiline text, choice, label, etc.) and how they are used to collect information. A **variable set** is a reusable set of variables that can be attached to multiple catalogue items (e.g., 'Personal Information' variable set used on both 'New Laptop' and 'Visitor Pass' items). The exam may ask which variable type to use for a yes/no question — the answer is boolean.\

- **Flow Designer vs. Workflow**: ServiceNow now uses **Flow Designer** for automation, but the exam may still reference legacy **Workflow**. Understand that both can be used to define the fulfilment process, including sending approvals, creating tasks, and updating records. Know that Flow Designer is the modern, graphical tool for building flows.

- **Approvals**: The exam tests how approvals are configured on catalogue items. Approvals can be set to one, two, or three levels, and can be assigned to a specific person, the user's manager, or a group. A common trap: a question says 'configure an approval for all new laptop requests' and the options include selecting a specific user, a reporting manager, or a group. The correct answer is often 'Manager' because it chains approvals for different requesters.

- **Request Templates**: These allow pre‑populating catalogue item forms with default values, used for common scenarios like 'New Hire with Standard Laptop'. The exam may ask what a request template does — it simplifies the request process by filling in fields automatically.

- **Service Portal vs. UI16**: The service catalogue appears on the Service Portal, which is the modern user interface. The exam might ask where users submit requests — the correct answer is the Service Portal (or the catalogue UI in older contexts, but default is Portal).

Trap pattern: The exam presents a scenario where a user needs to request multiple items (e.g., laptop, monitor, phone) at once. Options: create three separate catalogue items, use an order guide, use a record producer. The correct answer is 'order guide' because it groups multiple items into one request. Another trap: they say 'configure a variable set' vs. 'configure a single variable' — you need to understand that variable sets are for reusability across items.

Memorise these specific facts:
- A catalogue item uses the **Service Catalog** application module, not the Incident or Change modules.
- The user who submits a request is called the **requester** or **caller**.
- Fulfilment tasks are created based on the catalogue item's **catalogue task** definitions, which can be standard tasks or those defined in a workflow/flow.
- You can create **catalogue item categories** to organise items in the catalogue, making it easier for users to browse. These categories appear as sections in the portal.

## Step by step

1. **Define the service** — Identify a service you want to offer, such as 'Request a Cloud Server'. Decide what information you need from the user (e.g., server size, operating system, duration). This determines the variables you will create on the catalogue item form.
2. **Build the catalogue item** — In the Service Catalog module, create a new catalogue item. Give it a name, description, and assign it to a category. Add variables (text, dropdown, boolean) to capture user input. Optionally, set an order guide if the item is part of a bundle.
3. **Configure fulfilment flow** — Use Flow Designer (or legacy Workflow) to define what happens after the request is submitted. Set your flow to create catalogue tasks, send approvals, or update external systems. For a simple item, you might skip this and let fulfilment be manual.
4. **Set approval rules** — Decide whether the request needs approval. Configure approval rules on the catalogue item, such as requiring the requester's manager or a specific group to approve. You can set one, two, or three levels of approval.
5. **Publish the catalogue item** — Change the status of the catalogue item from 'Not Yet Available' to 'Available', and set the 'Display In' options to show it on the service portal. The item will now appear to users who can browse and submit it.
6. **Test the request lifecycle** — Submit the new catalogue item as a test user. Verify that the request, RITM, and any tasks are created correctly. Check that approvals are triggered as expected, and that the user receives notifications. Adjust the workflow or variables if needed.

## Comparisons

### Catalogue Item vs Record Producer

**Catalogue Item:**
- Creates a request (REQ) and one or more requested items (RITM) for human fulfilment.
- Used for services that need someone to perform a task (e.g., 'Install Software').
- Requires a workflow/flow to create fulfilment tasks or automate steps.

**Record Producer:**
- Directly inserts a record into a specified table (like 'Hardware Asset') with no request created unless configured.
- Used for automatically populating database records from a user form (e.g., logging a new 'Hardware Asset').
- Usually does not require a workflow; the record is created instantly.

### Variable vs Variable Set

**Variable:**
- A single custom field on a catalogue item form (e.g., a text box for 'Employee ID').
- Defined per catalogue item and not reusable across items unless duplicated.
- Changes to one variable do not affect other catalogue items.

**Variable Set:**
- A collection of one or more variables grouped together (e.g., 'Personal Information' set).
- Attachable to multiple catalogue items, ensuring consistent fields and values.
- Updating a variable set automatically updates all catalogue items using it.

### Order Guide vs Catalogue Item

**Order Guide:**
- A container that bundles multiple catalogue items and/or record producers into one request.
- User fills one form to request multiple deliverables (e.g., laptop, phone, software).
- Creates one request (REQ) with multiple requested items (RITMs).

**Catalogue Item:**
- A single service that a user can request, standing alone.
- User fills one form for one deliverable (e.g., just a laptop).
- Creates one request (REQ) with one requested item (RITM) typically.

### Flow Designer vs Legacy Workflow

**Flow Designer:**
- Modern, graphical automation tool in ServiceNow for building flows without code.
- Runs in real time and can be triggered by catalogue item submission.
- Recommended by ServiceNow for new implementations.

**Legacy Workflow:**
- Older tool that uses a flowchart-like interface for multi-step processes.
- Also triggered by catalogue item submission but harder to maintain for complex logic.
- Still supported but not recommended for new development.

## Diagram

_This diagram shows the lifecycle from a user submitting a catalogue item to the creation of a request, multiple requested items, and fulfilment tasks assigned to different teams._

```mermaid
flowchart TD
    U[User] -->|Submits form| C[Service Catalog]
    C -->|Creates| REQ[Request (REQ)]
    REQ -->|Contains| RITM1[Requested Item (RITM) - Laptop]
    REQ -->|Contains| RITM2[Requested Item (RITM) - Software]
    RITM1 -->|Generates| T1[Fulfilment Task - Order Laptop]
    RITM1 -->|Generates| T2[Fulfilment Task - Configure Laptop]
    RITM2 -->|Generates| T3[Fulfilment Task - Licence Activation]
    T1 -->|Assigned to| G1[Hardware Team]
    T2 -->|Assigned to| G1
    T3 -->|Assigned to| G2[Software Team]
```

## Common misconceptions

- **Misconception:** I can use the standard Approval module without any extra configuration to approve a request for a catalogue item. **Reality:** You must configure approval rules on the catalogue item itself or via a workflow/flow. The standard 'approval rule' on the table does not automatically apply to catalogue items unless set up. (Beginners often think approvals are a global setting, but ServiceCatalog items have their own approval conditions because each item may have different approval requirements (e.g., manager for hardware, director for software).)
- **Misconception:** When a user submits a catalogue item, only one record is created: the request. **Reality:** Submitting a catalogue item creates at least two records: a request (REQ) and one or more requested items (RITM). The RITM represents the specific deliverable, and the request is the container for the whole order. (Newcomers focus on the overall request and miss the layered structure, which is essential for tracking fulfilment at a granular level. The exam tests this distinction.)
- **Misconception:** Record producers and catalogue items are the same thing because both let users submit forms. **Reality:** They are different. A catalogue item creates a request that is fulfilled by human work; a record producer directly inserts a record into a specified table (like creating a new 'Hardware Asset' record) without generating a request if not configured to do so. (The names sound similar, and both appear in the service catalogue, so beginners confuse their purpose. The exam specifically asks to identify which one to use for a given scenario.)
- **Misconception:** If I delete a catalogue item from the catalogue, the already submitted requests for that item are also deleted. **Reality:** Deleting a catalogue item only removes it from the catalogue so new requests cannot be submitted. Existing requests and their fulfilment tasks remain intact. (Users sometimes think that deleting a menu item removes all orders already placed. This misconception leads to fear of deleting old items, but ServiceNow preserves data integrity.)
- **Misconception:** All catalogue items must have a workflow or a flow attached to them to be usable. **Reality:** A catalogue item can be simple and have no workflow attached at all. It will still create a request and a requested item, and the fulfilment is handled manually or via other automation. Workflows/flows are optional for complex automation. (Many tutorials show workflows with catalogue items, so beginners assume they are mandatory. However, many simple requests (like 'request a pen') need no automation; they just generate tasks for someone to fulfil manually.)

## Key takeaways

- The service catalogue is a centralised menu of IT services; each entry is a catalogue item that users submit to request something.
- When a user submits a catalogue item, ServiceNow creates a request (REQ) as a container and one or more requested items (RITM) for each deliverable.
- Catalogue items use variables (custom fields) to collect specific information from the requester, making fulfilment efficient and standardised.
- Approvals for catalogue items are configured on the item itself (or via a workflow/flow) and are not automatic; you must set approval rules per item.
- Record producers directly create records in a specified table (like a new 'Hardware' record), while catalogue items generate requests that require human fulfilment.
- Order guides allow users to request multiple catalogue items in a single submission, streamlining complex requests like new employee onboarding.
- Fulfilment tasks (catalogue tasks) are the individual work items assigned to technicians, and they can be created automatically by a workflow or manually.
- You can organise the service catalogue using categories and subcategories, making it easy for users to browse and find the right service.
- Request templates pre‑populate catalogue item forms with default values, saving time for repetitive requests like standard hardware setups.
- Variable sets allow you to reuse the same set of custom fields across multiple catalogue items, ensuring consistency and saving admin effort.

## FAQ

**What is the difference between a request and a requested item in ServiceNow?**

A request (REQ) is the overall order or container submitted by a user. A requested item (RITM) is a specific deliverable within that request, like 'laptop' or 'software licence'. One request can contain multiple RITMs.

**Do I need to use Flow Designer for every catalogue item?**

No. Flow Designer (or Workflow) is optional and used to automate fulfilment steps like creating tasks or sending approvals. Simple catalogue items can function without any flow; the request and RITM will still be created.

**Can I reuse the same set of custom fields on multiple catalogue items?**

Yes, create a variable set with common fields (like 'Employee Name', 'Department') and attach it to any catalogue item that needs them. This saves time and ensures consistency.

**How do I make a catalogue item visible only to certain users?**

You can restrict visibility by setting the 'Roles' field on the catalogue item to specific roles (e.g., only 'IT Admins'). Only users with that role will see the item in the catalogue.

**What happens if I delete a catalogue item that already has open requests?**

The catalogue item will be removed from the catalogue so no new requests can be submitted. Existing requests and their fulfilment tasks remain unaffected and can still be worked on.

**Can a user submit a request for multiple catalogue items at once?**

Yes, by using an order guide. The order guide bundles multiple catalogue items into one guided request. The user fills in a single form and submits, which creates one request containing multiple RITMs.

## Check your understanding

1. **When a user submits a catalogue item in ServiceNow, which two types of records are always created?**

   Answer: A request (REQ) and at least one requested item (RITM) are created. The request is the container, and the RITM represents the specific deliverable.

2. **What is the main difference between a catalogue item and a record producer?**

   Answer: A catalogue item creates a request that requires human fulfilment (like installing software), while a record producer directly creates a record in a specified table (like a new hardware asset record) without necessarily generating a request.

3. **How do you reuse the same set of custom fields across multiple catalogue items?**

   Answer: Create a variable set containing the fields, then attach that variable set to each catalogue item that needs them.

4. **If a user needs to request both a laptop and a monitor in one submission, which component should you use?**

   Answer: Use an order guide that bundles the 'Request Laptop' and 'Request Monitor' catalogue items into a single guided request.

5. **Where must you configure approvals for a catalogue item?**

   Answer: Approvals are configured on the catalogue item itself (in the 'Approval' section of the item record) or via the workflow/flow attached to the item. It is not automatic.

---

Interactive version with quiz and diagrams: https://courseiva.com/learn/servicenow-csa/service-catalog-and-request-management