A carrier signs an agency, and the agency brings every producer it has. Each producer quotes, binds, and submits from a slightly different setup, so the carrier’s integration team opens one onboarding per producer. The first few go live. The rest wait in a queue behind them.

That queue is the problem. The agency is one business with one contract, but the carrier treats it as many separate senders, each with its own mapping, its own test cycle, and its own go-live date.

This article explains how a carrier onboards the whole agency at once. It covers what to collect before day one, how to map once for every producer, how to test before real data arrives, and what to expect after go-live.

How Do P&C Carriers Onboard All the Producers at a Newly Signed Agency at Once?

Carriers onboard every producer at once by treating the agency as one sender. The agency’s payload is mapped once, a person reviews that mapping once, the agency tests once, and every producer goes live on the same mapping.

The sections below walk through why the producer-by-producer approach stalls and what the one-pass sequence looks like.

Why Producer-by-Producer Onboarding Stalls

Each producer looks like a new connector request. The carrier’s Guidewire team scopes the request, builds the mapping, tests it, and schedules the release. Multiply that by every producer in the agency and the agency’s launch date depends on the slowest build.

The cost of maintaining a connector compounds here. Every producer-specific connector is one more thing to retest when Guidewire ships a release.

What “One Pass” Means

One pass means the agency’s data arrives in one shape, even though many producers create it. The producers share the same source system or the same agency-approved format, so one mapping covers them all.

The producer is identified by data inside the payload, such as a producer code, and not by a separate integration. Adding the fifteenth producer is a data change, not a new build.

The One-Pass Agency Onboarding Sequence

The table shows the six steps in order, with who owns each one.

What Does the Carrier Need From the Agency Before Day One?

The carrier needs two things: a complete picture of the agency and a complete list of its producers. Gathering both before any mapping starts prevents the rework that comes from discovering a producer midway.

Underwriting operations and the agency’s program manager own this step together.

Agency-Level Facts

Start with what is true for the whole agency. This includes the systems that produce its submissions, the lines of business it will send, and whether it sends policy, claims, or billing data.

These facts decide which Guidewire application receives the data. Inbound exchange covers PolicyCenter, ClaimCenter, and BillingCenter, so the carrier knows up front where each payload lands.

Producer-Level Facts

Next, collect one row per producer. Each row holds the producer’s name, producer code, and the lines of business that producer writes.

A producer who writes a line the others do not is the usual source of mapping gaps. Finding that producer during the roster step is far cheaper than finding the gap on a rejected submission.

Where the Agency’s Data Comes From

Agencies rarely send from one place. Some producers work in the agency management system, while others use a comparison rater or a spreadsheet.

The carrier’s job is to confirm which of these feeds the single payload the agency will map. The agency’s job is to decide whether every producer submits through that one path. Carriers that already take submission intake from several senders know how quickly differing paths multiply the work.

How Do You Map Once for a Whole Agency?

You map the agency’s payload one time against the carrier’s Guidewire format, and every producer’s submission reuses that mapping. The mapping covers the fields in the payload, so it does not change when a different producer sends.

This is the step that removes the per-producer build.

One Payload, One Mapping

The agency maps its payload fields to the carrier’s Guidewire fields once. The system then translates each incoming payload into the carrier’s format, whichever producer created it.

For senders such as MGAs, TPAs, and brokers, this is the same logic behind sending submission data into Guidewire PolicyCenter without building a connector. The agency is simply a sender with more producers behind it.

A Person Reviews Every Mapping

LiLa, the InsOps insurance-trained model, assists with the mapping by proposing how each agency field lines up with a Guidewire field. A person then reviews every mapping before it is used.

The reviewer is usually a carrier integration analyst. The reviewer approves each field, corrects any proposal that does not match the carrier’s rules, and signs off before the mapping reaches a test.

Handling Producers That Differ From the Rest

Some producers send fields the others do not. The carrier handles this inside the same mapping by adding the extra fields once, so the producers who need them are covered without splitting the agency into separate onboardings.

Mapping is tenant-specific, so one agency’s mapping stays separate from another agency’s mapping and never overlaps with it.

How Do You Test Every Producer Before Real Submissions Arrive?

You test in a sandbox, where the agency sends sample payloads for each producer and sees exactly how the carrier’s side responds. Real submissions start only after the samples pass.

Testing each producer, not just the agency as a whole, is what makes one pass safe.

Use the Sandbox for Every Producer

The sandbox gives the agency a place to send test data before any real submission is sent. A test harness lets the agency run sample payloads and read the results.

The agency sends one sample per producer, using that producer’s code and line of business. A mapping that works for the agency’s first producer but fails for the third shows up here, before go-live.

Let Gap Rejection Catch Incomplete Data

Guidewire requires certain fields, and a payload that arrives without them cannot become a valid record. Incomplete data is rejected and returned to the sender, so the gap is fixed at the source.

Rejections during testing are useful. Each one names a field the agency still has to supply, and the agency fixes it once for all producers.

Confirm the Mapping Before Release

When every producer’s sample passes, the carrier’s reviewer confirms the final mapping. The agency then sends real data on the same mapping that passed in the sandbox.

Nothing about the mapping changes between test and release. The carrier is releasing what it tested.

What Happens After Go-Live When Producers Join, Leave, or Guidewire Changes?

After go-live, the mapping keeps working without a new build for each change. A new producer is added as data, and a change to the payload or to Guidewire is handled in one place.

This is where one-pass onboarding keeps paying off, long after launch week.

Adding a New Producer Later

A producer who joins the agency after launch sends the same payload with a new producer code. The carrier adds the producer to the roster, and the producer starts sending.

There is no second connector, no second test cycle for the mapping, and no second release. This is the difference between onboarding one agency and onboarding the same agency’s self-service intake channels one at a time.

Handling Payload and Guidewire Release Changes

When the agency changes its payload, or Guidewire ships a release, the mapping is updated once and a person reviews the change. Every producer then sends on the updated mapping.

Carriers on a release cadence of several Guidewire releases a year feel this most, because every release is one update instead of one update per producer.

Sending Large Payloads

An agency with many producers sends large batches at renewal time. Large payloads are sent by file location instead of inside the request, so a heavy submission does not slow the exchange for other producers.

Agencies that grow through agency acquisitions see the same pattern, because acquired producers join an existing mapping instead of starting over.

Who Else Is Affected When a Carrier Onboards in One Pass?

Onboarding in one pass changes the work for three groups: underwriting operations, the agency, and the carrier’s integration team.

Each group stops doing repeated work and starts doing a single, reviewed piece of work.

Underwriting Operations

Underwriting operations receive submissions from every producer in the same structure. The team reads one format, not one format per producer.

That consistency matters for the carrier’s distribution partners as a whole. A carrier that onboards agencies in one pass can take on the next partner without a queue.

The Agency and Its Program Manager

The agency maintains one mapping and one test cycle. Its program manager tracks one go-live date for every producer, not a set of staggered dates.

When a producer asks why they are not live yet, the answer is the same one the whole agency has.

The Carrier’s Integration Team

The integration team reviews one mapping per agency. Its attention goes to reviewing and approving, and not to scoping, building, and scheduling a connector for each producer.

Workbench vendors that send into a carrier’s Guidewire instance face the same shift, which is covered in the guidance for underwriting workbench vendors.

How InsOps Helps

InsOps built Yazh (Yaal), the InsOps Integration Gateway for carriers that receive data from many senders. An agency maps its payload once, and Yazh translates it to the carrier’s Guidewire format for every producer. LiLa assists with the mapping, and a person reviews every mapping before it is used.

Yazh connects to Guidewire PolicyCenter, ClaimCenter, and BillingCenter, so submissions, claims, and billing data arrive in the carrier’s own structure. It includes a self-service portal for senders, a test harness, and a sandbox, so each producer is tested before real data is sent. Incomplete payloads are rejected back to the sender.

Yazh is not Guidewire’s own Integration Gateway, which is a developer framework. It adds the sender-side mapping, testing, and review that a carrier would otherwise build for each partner. You can read more about data exchange for insurance on our site.

If you are evaluating how to bring a new agency and all its producers live without a separate build for each one, contact us to talk through what this looks like for your operation.

Frequently Asked Questions

What does onboarding an agency in one pass mean?

It means the carrier treats the agency as one sender. The agency maps its payload once, a person reviews the mapping once, and every producer goes live on that mapping together.

Why does onboarding producer by producer slow a carrier down?

Each producer becomes its own connector request with its own scoping, build, test, and release. The agency’s launch date then depends on the slowest of those builds.

How does a carrier tell producers apart if they share one mapping?

Each producer is identified by data in the payload, such as a producer code. The mapping covers the fields, so the producer’s identity does not require a separate integration.

What should the carrier collect before mapping starts?

Collect the agency’s source systems, the lines of business it will send, and one row per producer with name, producer code, and lines written. A complete roster prevents rework later.

How do producers test before real submissions arrive?

The agency sends sample payloads to a sandbox, one per producer, and reads the results from the test harness. Incomplete payloads are rejected, so each gap is fixed before release.

Does a person review the mapping, or does the AI approve it?

A person reviews every mapping. LiLa assists by proposing how fields line up, and the carrier’s reviewer approves or corrects each one before the mapping is used.

What happens when a producer joins the agency after launch?

The carrier adds the producer to the roster, and the producer sends the same payload with a new producer code. No new connector or release is required.

What happens when the agency’s payload or Guidewire changes?

The mapping is updated once and a person reviews the change. Every producer then sends on the updated mapping, so one change covers the whole agency.