A ServiceNow record producer sends new records to the target table set in its configuration, not automatically to sc_req_item. Learn how this flexibility supports tables such as Incident and custom tables, and why catalog-related records may follow a different path.

Multiple Choice

All records created using a record producer are inserted in the sc_req_item table.

Record producers create new records in a table you specify. The target table is set on the producer, so the produced record isn’t forced to be in a single table. While many catalog-related producers create records in the sc_req_item table to represent a requested catalog item, you can configure a producer to insert into any table—such as incident, a custom table, or even another ServiceNow table. Because of this flexibility, not every record produced will go into sc_req_item.

Record Producers in ServiceNow: Where Do the Records Go?

A record producer gives people a simple way to create a record in ServiceNow. They fill out a form, submit it, and the platform creates a record behind the scenes. But that record doesn’t always land in the same place. Its destination depends on how the producer is configured.

That detail matters when building applications, designing service experiences, or tracing a record through the platform. A producer may look like a catalog form to the person using it, yet the record it creates could be an incident, a custom application record, or another supported table. The form is the front door; the target table is where the new record actually lives.

A familiar form, with a flexible destination

A record producer is a type of Service Catalog item. It collects information from a user and uses that information to create a record in a selected table. The producer’s configuration includes a target table, which tells ServiceNow where to insert that record.

For instance, an organization might create a record producer called “Report a broken monitor.” The user sees a clear form with fields for the location, device details, and description. Behind the scenes, the producer can create an incident record—or a record in an asset-support table built for that organization.

The person submitting the form doesn’t need to know the table name. They just need a sensible, easy-to-use way to report the issue. Application developers, though, should know the destination. It affects what fields are available, which business rules run, and how the record appears in lists and workflows.

This separation between the user-facing form and the stored record is one of the useful ideas to grasp in ServiceNow application development. A form can present familiar language while the platform handles the data structure behind it.

Why sc_req_item isn’t the automatic destination

The sc_req_item table stores requested catalog items. When someone orders a catalog item through the service catalog, ServiceNow creates a request and related records that track what was requested. A requested item is commonly represented in sc_req_item.

Record producers also appear in the Service Catalog, so it’s easy to assume that anything submitted from one must become a requested-item record. But the similar user experience can hide an important difference: a record producer creates a record in its configured target table. It isn’t automatically required to create a record in sc_req_item.

That distinction is easier to see with two examples:

  • A catalog item might let an employee request a new monitor. The request is tracked as a requested catalog item.

  • A record producer might let an employee report a broken monitor. It can create an incident or a record in a facilities table.

Both experiences may start from the same catalog interface. Their purposes and data destinations differ.

This is more than a technical footnote. If a producer is expected to create incidents but its target is set incorrectly, the resulting records may not show up where support staff expect them. The form might submit without an obvious error, yet the operational handoff can go sideways. Knowing the target table helps prevent that sort of quiet mismatch.

How fields connect to the destination table

A producer’s questions are usually presented as variables. These give the form its user-friendly shape: “What happened?”, “Where is the equipment?”, or “How urgent is this?” When the record is created, scripts or field mappings can use those answers to populate fields on the target record.

For example, a producer targeting the Incident table could map a description variable to the incident’s description field. It might set a category, assign a group, or add details to the short description. A custom table would have its own fields and may require different mappings.

That means the target table should be chosen with care. Ask what kind of record the organization needs, what information it must store, and which platform features should apply. A table isn’t just a label. It shapes how the data can be managed.

Developers should also consider access and data quality. Does the user have permission to submit the information? Are required fields being set? Should a script validate an answer or derive a value? Do existing business rules affect the new record? These questions help ensure that the producer creates useful data, not merely a row in a database.

The producer’s script: useful, but not a substitute for design

Record producers can use scripts to control how submitted information becomes a record. A script may set field values, apply conditional logic, or handle details that don’t fit a simple one-to-one mapping. In ServiceNow, the record being created is often accessed through the current object in the producer script.

For a straightforward producer, field mapping may be enough. For a more tailored experience, a script can help. Still, more code isn’t automatically better. If the same result can be achieved with clear configuration, that’s often easier for another developer to understand and maintain.

A good design keeps the relationship between the form and the record clear. Use variable names that make sense to people. Map values deliberately. Avoid hidden assumptions, such as relying on a field being populated by an unrelated process. These small choices make later troubleshooting less like detective work.

It’s also worth remembering that a producer is not a general-purpose replacement for every data-entry tool. The user experience, access model, and workflow should fit the task. A short form for reporting an issue is a natural use. A complicated administrative interface with many interdependent fields may call for a different design.

Building a producer that fits the job

When developing an application in ServiceNow, begin with the record you want to create—not with the form layout. Identify the business process, then select or design a table that represents the information properly. Once the destination is clear, build the producer around the fields users can reasonably provide.

A few design checks can make a noticeable difference:

  • Confirm the target table. Make sure it reflects the type of record the producer should create.

  • Keep the form focused. Ask only for information that supports the process or helps the next person act.

  • Map fields intentionally. Check that each submitted value reaches the right field, with the right format.

  • Review permissions and rules. Roles, business rules, and required fields can affect whether a record is created as expected.

  • Test the full flow. Submit the producer, then inspect the created record and any downstream behavior.

That final check is especially useful. A successful form submission doesn’t tell the whole story. The record may be missing a key value, land in an unexpected list, or trigger a workflow that wasn’t part of the plan. Looking at the created record helps confirm that the design works from the user’s first click through to the operational outcome.

A small distinction with real impact

Record producers and requested catalog items both belong to the Service Catalog experience, but they don’t serve the same data purpose. A requested item is tracked in the catalog-request structure, including the sc_req_item table. A record producer creates a record in the table selected for that producer.

That flexibility is valuable. It lets teams use a familiar form-based experience to create records across ServiceNow—whether they need an incident, a custom application record, or another suitable record type. The key is to make the destination explicit and make the form reflect what that destination needs.

Once that idea clicks, record producers become easier to reason about. The catalog is the doorway. The configured target table decides where the new record goes.