All About CI Types
Ask ten MSP engineers what a CI is and you'll get a shrug, a "that's the thing in the CMDB", and one person who quotes the ITIL definition from memory. It's one of those terms that gets used constantly in service management and explained almost never. This post covers what a configuration item actually is, where the name comes from, why they're sorted into types and sub-types, and how that sorting relates to the product catalogue you quote and invoice from. The two look alike and are easy to confuse, but they answer different questions.
What is a CI?
A configuration item, or CI, is any component that has to be managed in order to deliver an IT service. The ISO/IEC 20000 service management standard defines it in almost those words: an element that needs to be controlled to deliver a service. ITIL 4 uses the same idea as the base unit of its Service Configuration Management practice.
The important word is managed, not owned and not physical. A CI is whatever you'd need to know about to keep a client's service running, or to work out what's affected when something breaks. That includes the obvious things:
- a server, a laptop, a firewall, a switch
- a piece of software or a licence
- a cloud tenancy or a SaaS subscription
It also includes things that aren't kit at all. ITIL lists documentation, people, locations and the services themselves as legitimate CIs, and for an MSP a warranty, a lease or a support contract is just as much a thing you need to track, because it has a renewal date and someone will ask about it.
The collection of CIs, and the relationships between them, lives in a configuration management database, the CMDB. ITIL v2 introduced the idea around 2000, and ITIL v3 in 2007 broadened it into a configuration management system. In ITIL 4 the CMDB is part of the Service Configuration Management practice rather than a practice of its own.
Where the name comes from
"Configuration item" didn't start in IT. It comes from configuration management, an engineering discipline that grew up in US defence and aerospace in the 1950s and 60s, where the problem was very concrete: when a missile or an aircraft is made of thousands of parts, built by dozens of contractors, and changed continuously over a decades-long life, someone has to know exactly what is in each unit, which version of each part, and what changed when. The US Department of Defense formalised this through its 480 series of standards, later folded into MIL-STD-973 and then MIL-HDBK-61.
In that world a configuration item was a component, hardware, software or a combination, designated for separate configuration management. The key idea is designated: you don't track every screw. You pick the level at which it's worth controlling changes, and that level becomes your CI.
ITIL, first published in the late 1980s by the UK government, borrowed the discipline for IT and the term came along with it. Sources disagree on exact dates and I haven't traced the term to a single primary document, so treat the 1950s-to-60s dating as the broad picture rather than a precise citation. The lineage itself, defence engineering first and IT second, is well documented.
The lesson carries straight across. The hard part of a CMDB isn't the database, it's deciding what counts as a CI. Without that decision you constantly struggle with what to put in it, and the CMDB either bloats with noise or goes missing the things that matter.
Why do CIs have types?
A CMDB with a thousand CIs and no types is a long list of names. Types are what make it usable, for three reasons.
Different things need different information. A server has RAM, an operating system and a hostname. A warranty has a start date, an end date and a provider. A SaaS subscription has a seat count and a tenant URL. ISO 20000 guidance says every CI should carry a unique identifier and its type, and the type is what tells you which other attributes make sense. Without types, you either show every field on every record (most of them blank and irrelevant) or you cram everything into a notes box that can't be searched or reported on.
Different things behave differently. Some CIs need an asset tag and a printed label because they're physical objects someone will walk up to. Some can be remotely connected to and others can't. Some have a renewal date that drives a conversation with the client, and some have none. These are properties of the kind of thing, so they belong on the type, set once, rather than being decided again for every record.
You need to ask questions of the whole estate. "How many servers does this client have?" "Which firewalls are out of warranty?" "What's the cloud footprint across all my clients?" Those are all queries by type. The type is also what makes a dashboard or a client report meaningful instead of a dump.
Why types and sub-types?
A single flat level of types runs into trouble quickly. Too few types and they're meaningless ("Hardware" covering a laptop, a router and a printer). Too many and nobody can remember which one to pick, so you get inconsistency, which is worse than coarseness.
The two-level approach splits the job:
- The type is the broad kind of thing. It's a small, stable list, and it decides what information you record and how the item behaves.
- The sub-type (a sub-category) is the finer grouping within it, used for finding and reporting. Router, Switch and Firewall are all Network; Desktop, Laptop and Tablet are all PC.
That split matters because the two have different rates of change. The things that drive record-keeping, such as fields, asset tags and remote access, barely change. The groupings you want to report on change whenever your business does. Keeping them on separate levels means you can add a "Wi-Fi Access Point" sub-type tomorrow without touching how a Network CI is recorded.
It also keeps the pick-list honest. Choosing between seven types is a two-second decision, and choosing a sub-type within one is another. Choosing between forty flat types is where people give up and pick the first one.
How MSP Pulse does it
MSP Pulse gives every account a starter set of seven types, each with a few starter sub-types:
| Type | Starter sub-types |
|---|---|
| PC | Desktop, Laptop, Tablet |
| Server | Physical Server, Virtual Server, NAS / Storage |
| Hardware | Printer, Monitor, Peripheral |
| Network / Connectivity | Router, Switch, Firewall, Wi-Fi Access Point |
| Software / Licences | Operating System, Line of Business Application, Utility |
| Cloud / SaaS | SaaS Application, Infrastructure (IaaS), Backup / DR |
| Service Contracts | Support Contract, Warranty, Lease |
None of it is locked. An admin can rename types, add sub-types or add entirely new types in Settings → Service Delivery → CI Types. The principle described above is built in:
- The fields on a CI follow its type, not its sub-type. A server shows server fields whichever sub-type it has.
- Each type has its own switches. Whether it supports remote access (which controls the Connect button), and whether it gets an automatic asset tag. PC, Server, Hardware and Network get tags to start with; software, cloud and contracts don't, because there's nothing to stick a label on.
- The sub-type is optional. If you can't decide, leave it blank and the CI is still correctly typed.
CI types and product types: related, not the same
This is the point that trips people up, because MSP Pulse has both, and both have a "type" and a finer grouping beneath it. They look like the same idea. They aren't.
| CI types | Product categories | |
|---|---|---|
| Question answered | What is this thing, and how do we look after it? | What do we sell, and how do we price and account for it? |
| Lives in | The CMDB, per client | The product catalogue, per MSP |
| Structure | Type → Sub-type | Category → Sub-category → Item |
| Drives | Fields, asset tags, remote access, renewal tracking | Prices, billing type, income account on invoices |
| A record is | One specific thing at one client (this firewall, with this serial number) | A thing you can sell, in general (the firewall model, with a price) |
The clearest way to see the difference is that one product and one CI are not the same size of thing. A quote line for two laptops is one catalogue item with a quantity of two, and it should become two CIs, because each laptop has its own serial number, hostname, warranty date and life. Going the other way, plenty of products never become a CI at all: a USB cable is something you sell and never track, and a labour item is something you bill but there's nothing to put in a CMDB.
The category structures don't line up either, and they shouldn't. A catalogue is organised around how you sell and book things, for example Hardware, Managed Services and Licences, because that's what your accounts and margins follow. A CMDB is organised around how you operate things. A recurring monthly licence is a product in the catalogue, billed on a schedule, and a Software or Cloud CI in the CMDB, with a renewal date and a client who depends on it. Forcing the two into one hierarchy would make one of them worse.
Where they meet
They are related, though, and in a few places MSP Pulse connects them, deliberately and with a person in the loop:
- From a quote to the CMDB. When a quote on a ticket is approved for hardware, the AI assistant offers to add the devices to the client's CMDB. It picks the real devices out of the quote lines and skips cables and other accessories, suggests a CI type for each, creates one CI per unit as Pending (ordered but not yet delivered), and records the quote number and date in the notes without copying any prices across. The engineer reviews the names and types before anything is created.
- There is no hard link underneath. A catalogue category isn't mapped to a CI type, which is exactly why the assistant has to judge a suggestion and why you confirm it. A "Servers" sub-category in your catalogue and a "Server" CI type are the same word describing two different things.
If you set both up with the right question in mind, the catalogue for "what do we sell and book it to" and CI types for "what do we look after and what do we need to know about it", you'll find the connection is useful precisely because the two stay independent. Change how you price or organise your catalogue and your CMDB doesn't move. Change how you classify the estate and your invoices don't move.
A few practical rules
- Keep types few and broad, put the detail in sub-types. If you're tempted to add a type, first ask whether it would have different fields or different behaviour. If not, it's a sub-type.
- Decide on a CI before you decide on a type. Don't create CIs for every cable and mouse. Track what you'd need to know about to fix, renew or replace something, or to understand what a failure affects.
- Choose the type by how you'll operate the thing, not how you bought it. A router bought as a product and a router managed as a CI are the same router, but the type belongs to the second view.
- Use consistent sub-types before you chase detail. A CMDB where every firewall is under Firewall is more useful than one with finely graded sub-types used half the time.
- Let renewal dates do some work. Warranties, licences and contracts are CIs precisely because they expire. Set the date and you've turned an asset list into something that tells you what's coming.
The takeaway
A configuration item is a deliberately chosen thing worth managing, a name borrowed from decades of engineering practice about knowing exactly what you've built and what has changed. CI types exist so that each kind of thing records the right information and behaves the right way, and sub-types exist so you can find and report on them without the structure collapsing. Product categories look similar but answer a different question: what you sell, not what you look after. Keep the two separate, connect them with judgement, and each stays simple.