← All posts

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:

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:

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:

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:

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

  1. 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.
  2. 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.
  3. 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.
  4. 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.
  5. 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.