Sequence Generators

This guide explains how to create and manage sequence generators in Tagnet Enterprise & Cloud. Sequence generators automatically create unique identifiers for your items and RFID tags, ensuring consistency and preventing duplicates. They live on the Sequence Generators tab of the Items page, next to the item types that use them; create one from that page's Add menu.

Overview

Every item and RFID tag in your system needs a unique identifier. Manually creating these IDs is error-prone and time-consuming. Sequence generators solve this by:

• Automatically generating the next ID in a sequence
• Enforcing consistency with configurable formats
• Preventing duplicates through centralized control
• Adding validation with check digits to catch data entry errors

Understanding Sequence Types

Tagnet supports two types of sequences:

Type	Purpose	Example
Instance ID	Human-readable identifier for inventory items	LAPTOP-0001234-7
Tag ID	96-bit hexadecimal value written to RFID tags	540010001000000000001A3

Instance IDs

Instance IDs identify physical items in your inventory. They're designed to be:

• Human-readable and easy to type
• Printable on labels and barcodes
• Searchable in the system

Tag IDs

Tag IDs are written directly to RFID tags. They follow the EPC (Electronic Product Code) standard:

• 96 bits = 24 hexadecimal characters
• Optimized for RFID reader/writer operations
• Can embed metadata like scope and partition codes

Encoding Schemes

An encoding scheme defines the structure and format of generated IDs. Tagnet offers several built-in schemes plus a fully customizable option.

Scheme Comparison

Scheme	Type	Format	Best For
Custom	Both	User-defined prefix + number + suffix	Legacy system compatibility
Instance Simple	Instance	Zero-padded number	Easy onboarding, simple tracking
Instance with Check Digit	Instance	Number + Luhn check digit	Error-resistant manual entry
Instance Typed	Instance	Type prefix + number + check digit	Multi-category inventory
Instance Dated	Instance	Date + number + check digit	Date-based tracking
Instance Partitioned	Instance	T + scope + serial + CRC-8	Scope-aware with validation
Tag Partitioned	Tag	Header + scope + partition + serial + CRC-8	Standard RFID tagging
Tag Signed	Tag	Prefix + scope + serial + CRC-16	Tamper-resistant tagging

---

Instance ID Schemes

Instance Simple

The simplest option: just a zero-padded sequential number with no additional formatting.

Structure: [Zero-Padded Number]

Example: 0000000001, 0000000002, 0000000003

Configuration:

Setting	Description
Max Length	Total digits (default: 10)

Use Cases:

• Getting started quickly
• Simple sequential tracking
• Environments where IDs are always scanned (no manual entry concerns)
• When you just need unique numbers

This is the default scheme for new installations.

---

Custom

The most flexible option. You define the format using prefix, suffix, and padding.

Structure: [Prefix][Padded Number][Suffix]

Example Configuration:

Setting	Value	Result
Prefix	INV-
Max Length	12
Start Value	1	INV-00000001

Use Cases:

• Simple sequential numbering
• Matching existing ID formats from legacy systems
• Department-specific prefixes (e.g., IT-, MFG-, WHSE-)

---

Instance with Check Digit

Adds a Luhn check digit to catch manual entry errors.

Structure: [Padded Number]-[Check Digit]

Example: 00012345-2

The check digit (the final 2) is mathematically calculated from the preceding numbers. If someone mistypes 00012345-2 as 00012346-2, the system will reject it because the check digit doesn't match.

Use Cases:

• High-volume manual data entry
• Barcode scanning with manual fallback
• Environments where typos are costly (medical, financial)

How the Check Digit Works: The Luhn algorithm detects:

• Single-digit errors (typing 5 instead of 6)
• Transposition errors (typing 12 instead of 21)

This catches ~90% of common data entry mistakes.

---

Instance Typed

Embeds a type code to identify the category at a glance.

Structure: [Type Prefix]-[Padded Number]-[Check Digit]

Example: LAPTOP-0001234-7

Configuration:

Setting	Description
Type Prefix	Category identifier (e.g., LAPTOP, TOOL, PALLET)
Total Length	Overall length including prefix and check digit

Use Cases:

• Mixed inventory where visual identification helps
• Warehouse operations (staff can see item type without scanning)
• Reporting and filtering by category

Examples by Industry:

Industry	Type Prefixes
IT Assets	LAPTOP, MONITOR, DOCK, PHONE
Tools	DRILL, SAW, METER, WRENCH
Medical	PUMP, BED, CART, SCOPE

---

Instance Dated

Embeds the creation date for time-based tracking.

Structure: [YYYYMMDD]-[Padded Number]-[Check Digit]

Example: 20260122-00001-3

The date portion uses the current date when the ID is generated.

Use Cases:

• Batch tracking in manufacturing
• Warranty tracking (date of entry = date of receipt)
• Seasonal inventory management
• Compliance requiring date traceability

---

Instance Partitioned

Human-readable equivalent to Tag Partitioned. Embeds scope information with CRC-8 validation.

Structure:

┌────────┬───────┬─────────┬───────┐
│ Prefix │ Scope │ Serial  │ CRC-8 │
│   T    │ 0001  │ 0000001 │  A3   │
│  (1)   │  (4)  │   (7)   │  (2)  │
└────────┴───────┴─────────┴───────┘
       Example: T0001-0000001-A3

Segment	Length	Description
Prefix	1	Fixed "T" for Tagnet
Scope	4	Auto-filled from assigned access scope (decimal)
Serial	Variable	Sequential number (based on max length)
CRC-8	2	Checksum for error detection (hex)

Configuration:

Setting	Description
Total Length	Overall length including all segments (default: 16)

Use Cases:

• Multi-site operations where scope identification matters
• Environments needing both human readability and validation
• When you want the benefits of Tag Partitioned but for instance IDs
• Scenarios where IDs may be manually entered but need error detection

---

Tag ID Schemes

Tag ID schemes generate 96-bit (24 hex character) identifiers suitable for writing to RFID tags.

Custom (Tag)

Same as Instance Custom, but outputs hexadecimal and defaults to 24 characters.

Use Cases:

• Matching existing tag formats
• Simple sequential hex numbering

---

Tag Partitioned

A structured 96-bit format with embedded metadata and error detection.

Structure:

┌────────┬───────┬───────────┬───────────────┬───────┐
│ Header │ Scope │ Partition │    Serial     │ CRC-8 │
│   54   │  001  │   0001    │ 0000000000001 │   A3  │
│  (2)   │  (3)  │    (4)    │     (13)      │  (2)  │
└────────┴───────┴───────────┴───────────────┴───────┘
         Total: 24 hex characters (96 bits)

Segment	Length	Description
Header	2	Fixed identifier (54 = Tagnet)
Scope	3	Auto-filled from assigned access scope
Partition	4	User-defined category code
Serial	13	Sequential number (~4.5 quadrillion values)
CRC-8	2	Checksum for error detection

Configuration:

Setting	Description
Partition Code	4 hex characters to categorize tags (e.g., 0001 for raw materials, 0002 for finished goods)

Use Cases:

• Standard RFID deployments
• Multi-site operations (scope identifies origin)
• Category-based filtering at the tag level

Example Partition Strategy:

Partition	Category
0001	Raw Materials
0002	Work in Progress
0003	Finished Goods
0004	Equipment

---

Tag Signed

Similar to Partitioned, but uses a stronger checksum with a secret salt for tamper resistance.

Structure:

┌────────┬───────┬─────────────────┬─────────┐
│ Prefix │ Scope │     Serial      │ CRC-16  │
│   A0   │  001  │ 000000000000001 │   B2F4  │
│  (2)   │  (3)  │      (15)       │   (4)   │
└────────┴───────┴─────────────────┴─────────┘
         Total: 24 hex characters (96 bits)

Segment	Length	Description
Prefix	2	Configurable identifier (default: A0)
Scope	3	Auto-filled from assigned access scope
Serial	15	Sequential number (~1 quadrillion values)
CRC-16	4	Salted checksum for tamper detection

How the Salt Works: A secret salt (auto-generated when you create the generator) is used when calculating the CRC-16. This means:

• Only your system can generate valid tag IDs
• You can verify if a tag was created by your system
• Forged tags will fail validation

Use Cases:

• Environments where tag authenticity matters
• Supply chain anti-counterfeiting
• High-security asset tracking
• Situations where tags might be read by untrusted parties

---

Creating a Sequence Generator

1. Open the Items page and choose its Sequence Generators tab
2. Choose Sequence Generator from the Add menu in the page header
3. Fill in the configuration (see below)
4. Review the ID Structure Preview to verify the format
5. Click Create

Configuration Fields

Basic Settings

Setting	Description
Name	Descriptive name (e.g., "IT Asset Instance IDs")
Description	Optional notes about usage
Sequence Type	Instance ID or Tag ID
Encoding Scheme	Format structure (see schemes above)
Access Scope	Which scope owns this generator. By default this routes to the shared system scope with no prompt; if your deployment enables the Scoping > Site Catalog policy (disabled by default, see Policies), this becomes an Availability choice so a site can own its own generator. See Access Scopes.

Sequence Settings

Setting	Description	Default
Start Value	First number in the sequence	1
Increment	Step between values	1

Scheme-Specific Settings

Depending on the selected scheme, additional fields appear:

Scheme	Additional Settings
Custom	Prefix, Suffix, Max Length, Output Type (Decimal/Hex)
Instance with Check Digit	Total Length
Instance Typed	Type Prefix, Total Length
Instance Dated	Total Length
Tag Partitioned	Partition Code
Tag Signed	Prefix

Setting a Default Generator

Check Set as default generator for this type and scope to make this generator the automatic choice for new items in the specified scope.

Each scope can have one default generator per sequence type (Instance ID and Tag ID).

---

Collision Warnings

As you configure a generator's format (scheme, prefix, suffix, partition code, access scope, salt), Tagnet checks it against every other generator of the same sequence type (Instance ID or Tag ID) and shows inline warnings in the Format section of the create and edit forms:

Severity	Meaning
🔴 High	Two generators can mint identical values right now, or their counter ranges are close enough (within roughly 10 million generated values) that they will start colliding soon.
🟡 Medium	Two generators share a value space in a way that isn't an immediate risk, for example the same scheme and length with far-apart counter positions, or two Tag Partitioned generators that differ only in salt. Overlapping values are skipped at mint time rather than reused, but they still waste sequence capacity.

The check looks at what actually gets rendered into the value, not just whether the scheme name matches, and compares text case-insensitively (a prefix of abc counts as the same as ABC). Generators with distinct prefixes, partition codes, or access scopes don't warn even when they share a scheme, because those differences make the rendered values structurally incapable of colliding, for example a Tag Partitioned generator's scope and partition code are embedded directly in every value it mints, so two generators in different scopes (or with different partition codes) can never produce the same value. Two Tag Partitioned generators that share a scope and partition but carry different salts get a Medium warning instead: only the check digit differs between them, so roughly 1 in 256 serials overlaps (a copied generator gets a fresh salt automatically and lands in this category until you change its partition). Two generators with an identical rendered format only warn when their counter ranges sit within roughly 10 million generated values of each other; the distance accounts for each generator's Increment, and ranges staggered far enough apart are treated as practically unreachable and stay silent.

If warnings are still showing when you save, Tagnet asks you to confirm, listing every warning and its severity, before creating or updating the generator. This applies to both create and edit; it does not block the save.

---

Using Generators

Generators are assigned at the Item Type level, not on individual catalog items. Every item of a given type inherits that type's strategy and generator. To change which generator is used, edit the Item Type on the Item Types tab of the Items page.

Scope Default Resolution

When an inventory item is commissioned or created for an item type that uses the Sequence Generator strategy, Tagnet resolves the generator to use in this order:

1. Pinned generator. If the item type has a specific generator selected (not Scope default), that generator is always used, regardless of which scope the inventory item is created in.
2. Scope default. If the item type's selection is left on Scope default, Tagnet uses the default generator for that sequence type (Instance ID or Tag ID) in the new inventory item's own access scope, the site or scope the item is actually being created or commissioned into. This is not necessarily the item type's own access scope.
3. The next value is atomically generated and assigned, preventing duplicates even under concurrent creates.

There is no fallback to the system scope. If a type is left on Scope default and the inventory item's scope has no default generator for that sequence type, creating the item fails: the create form shows an error, a Commission API row fails with a message naming the missing generator, and generating a tag from the item's tag action returns an error. See Shared Catalog with Scope Default below for how to set this up correctly across sites.

Choosing a Generator on an Item Type

When creating or editing an Item Type, select Sequence Generator as the Instance ID Strategy (or Tag ID Strategy). A generator dropdown appears with Scope default as the first option, followed by the generators available in the item type's own access scope plus the system scope. This strategy is selectable even if no generators exist yet in scope.

• Scope default (the default selection): no generator is pinned. Each inventory item resolves its generator from the default generator of its own scope at creation time, as described above.
• A specific generator: every inventory item of this type always uses that one generator, no matter which scope the inventory item is created in.

Note: The dropdown only lists generators from the item type's own access scope and the system scope, it never lists another site's generators. To have a single item type resolve a different generator per site, leave the selection on Scope default and give each site its own default generator, rather than trying to pin one from this dropdown.

Generating Values

Values are generated when:

• An inventory item is commissioned via the Commission API
• A new inventory item is created manually
• Bulk operations create multiple inventory items

Each generation atomically increments the counter, preventing duplicates even under high concurrency.

---

Managing Generators

The Sequence Generators list can be filtered by Sequence Type (Instance ID or Tag ID) in addition to the search box, useful once you have generators for both kinds of identifier in the same scope.

Viewing Generator Details

Click a generator to open its detail page at a stable, shareable URL. The Overview tab is a stack of sections:

Section	Shows
Basics	Name, sequence type, encoding scheme, whether it's the scope default, and the description
Format	Output type, length, prefix, suffix, and partition code
Numbering	Start value, increment, the last value generated, and how many values the generator has produced so far
Used by	Every item type that pins this generator by name and which strategy it's pinned for (Instance ID, Tag ID, or both), each linking to that item type's own page

If the generator is a scope default, a note under Used by clarifies that it also serves item types left on Scope default in that scope, in addition to the item types listed as explicit pins.

The Preview tab shows the ID structure, the next value, its total length, and how many more values the format can hold (Available), then the Upcoming values the generator would produce next: 10 by default, with a Show dropdown for 25, 50, or 100, and Copy all to put them on the clipboard. Previewed values are not reserved or used up.

Editing a Generator

Click Edit from the generator's actions menu (or from its detail page) to open an edit page pre-filled with its current values, with a section navigation rail and a sticky footer showing unsaved-changes state. You can modify:

• Name and description
• Start value and increment
• Scheme-specific settings (prefix, partition code, etc.)
• Default status

Caution: Changing format settings (prefix, scheme, etc.) on a generator that's already in use may create inconsistent IDs in your system. See Collision Warnings above for how Tagnet flags configurations that risk overlapping with another generator.

Deleting a Generator

Generators can only be deleted if no items are using them. If items reference a generator, you must:

1. Reassign those items to a different generator, or
2. Delete the items first

---

Best Practices

Planning Your ID Strategy

Before creating generators:

1. Map your categories - List all item types you'll track
2. Choose consistency - Use the same scheme across similar items
3. Plan for growth - Ensure sufficient serial number length
4. Consider operations - Will staff read IDs visually? Use typed schemes.

Recommended Configurations by Use Case

Use Case	Sequence Type	Recommended Scheme
Getting started / simple tracking	Instance	Instance Simple
Manual data entry environments	Instance	Instance with Check Digit
Multi-category inventory	Instance	Instance Typed
Manufacturing batches	Instance	Instance Dated
Multi-site with validation	Instance	Instance Partitioned
Standard RFID tags	Tag	Tag Partitioned
High-security applications	Tag	Tag Signed
Legacy system compatibility	Both	Custom

Naming Conventions

Do	Don't
IT Assets - Laptops	Gen1
Warehouse A - Pallets	Pallet generator
Manufacturing - WIP Tags	tags

Include the scope/location and purpose in the name.

Scope Strategy

Pattern	Setup
Centralized	One generator in the system scope for all sites
Distributed	Each site has its own generator in its scope
Hybrid	System scope defaults with site-specific overrides

Centralized ensures unique IDs across your entire organization. Distributed allows sites to operate independently (useful for offline scenarios).

Note: The Distributed and Hybrid patterns place generators in individual site scopes, which requires the Scoping > Site Catalog policy. That policy is disabled by default, so new generators route to the shared system scope with no scope prompt until an administrator enables it (see Policies).

Shared Catalog with Scope Default

A common multi-site pattern combines one shared item type with a per-site default generator, so you don't need to duplicate item types just to get site-specific sequences:

1. Create the item type once, in the system scope, with Instance ID Strategy and/or Tag ID Strategy set to Sequence Generator and the generator selection left on Scope default.
2. In each site scope, create a generator for the sequence type(s) you need and check Set as default generator for this type and scope.
3. As each site creates or commissions inventory items of that type, Tagnet automatically mints from that site's own default generator, no per-site item types required.

Give each site's default generator a distinct prefix, type prefix, or partition code (for example, a site code like DC1-, DC2-). Instance IDs and Tag IDs must be unique across your entire Tagnet instance, so if two sites' default generators produce identically formatted values, they will eventually collide on the same values.

---

Validation and Error Detection

Check Digits (Instance Schemes)

The Luhn check digit catches:

• Single digit errors (~90% detection)
• Adjacent transposition errors

When someone enters an ID manually, the system validates the check digit and rejects invalid entries.

CRC Checksums (Tag Schemes)

Scheme	Checksum	Detection Rate
Tag Partitioned	CRC-8	~99.6% of random errors
Tag Signed	CRC-16	~99.998% of random errors

CRCs detect:

• Bit errors from RF interference
• Corrupted reads
• Truncated data

Validating Tag Authenticity (Tag Signed)

For Tag Signed scheme only:

• The system can verify if a scanned tag was generated by your system
• Tags with invalid CRCs are flagged as potentially counterfeit or corrupted
• This requires the generator's salt, which is only stored in your system

---

Frequently Asked Questions

Q: Can I change a generator's scheme after creation? A: Yes, but this only affects newly generated IDs. Existing items keep their current IDs.

Q: What happens if a generator reaches its maximum value? A: The system will show an error and refuse to generate more values. You'll need to create a new generator with a larger capacity. You can see this coming on the generator's detail page: once a generator is exhausted, the Preview tab's Next value reads "Exhausted (maximum reached)" instead of a value, and Upcoming values stops early with a message explaining how many more values (if any) remain before the format's capacity runs out.

Q: Can two generators produce the same ID? A: Yes, if they render to the same format and their counter ranges are close enough to overlap. See Collision Warnings for how Tagnet detects and flags this. To ensure uniqueness, use different prefixes, partition codes, salts, or access scopes, or use a single centralized generator.

Q: How do I migrate from a legacy ID system? A: Create a Custom scheme generator matching your existing format, and set the Start Value to continue from your last used number.

Q: Can I reset a generator's counter? A: Administrators can reset the current value, but this risks creating duplicate IDs if previous values were already assigned to items.

Q: Why can't I delete a generator? A: Generators with items assigned to them cannot be deleted. Reassign or delete the items first.

Q: Why did creating or commissioning an inventory item fail with an error about a missing default generator? A: The item type's Instance ID or Tag ID strategy mints from a generator (Sequence Generator, or Sequence Generator with supplied Tag ID wins for a row that supplied no Tag ID) with the selection left on Scope default, and the scope you're creating the item in has no default generator for that sequence type. Create a generator in that scope and check Set as default generator for this type and scope (see Shared Catalog with Scope Default), or pin a specific generator on the item type instead.

Q: What's the difference between CRC-8 and CRC-16? A: CRC-16 provides stronger error detection and, when combined with a salt, provides basic tamper resistance. Use CRC-16 (Tag Signed) when tag authenticity matters.

Q: Do I need different generators for different item types? A: Not necessarily. You can use:

• One generator with a neutral prefix for all items
• Instance Typed scheme with the type embedded in each ID
• Separate generators per category for complete isolation