Two Definitions of the Same Hour: Feeding Client-Owned Time Data Into UKG Pro WFM

At a large automotive engineering services firm, the engineers do not clock in on their employer’s system. They clock in on the customer’s, which makes UKG Pro WFM time system integration a daily payroll issue.

The firm’s staff work inside a major automaker’s facilities, and the contract requires project hours to be logged in the automaker’s own time system, because that record is what the automaker audits and pays against. Payroll runs on UKG Pro WFM, where the firm’s pay rules, overtime treatment and labor cost structure live. Two systems hold the same hour, and each one is correct about something different.

Without a designed connection, the reconciliation between them is a person. Every day the automaker’s system produces a flat file of roughly 900 lines that someone checks line by line, and every week a billing analyst moves hours between overtime and regular time before invoicing. CloudApper’s approach is to turn that recurring judgment call into a designed pipeline that connects both systems and keeps both definitions of the hour intact.

Two Systems, Two Definitions of the Same Hour

An hour an engineer spends on a client program is a payroll event and a billing event at once, and the rules governing each are written by different parties. The automaker’s contract defines what is billable: which project codes qualify, how travel and equipment setup time are treated, what happens when an engineer moves between programs mid-shift. The firm’s own policy defines what is compensable: shift premiums, overtime thresholds, and internal non-billable time that never appears in the client’s system at all. Collapse those two rule sets into a single record and one of them gets quietly rewritten, usually the one nobody is auditing that week.

iPaas for UKG

UKG Technology Partner

Sync UKG across your entire tech stack.

See Integrations

According to the Manager of Billing at the engineering services firm, the client’s overtime rule shows how far apart the two can sit: “[The OEM client] will not pay overtime if it’s not eight hours on a [client] job for the day.”

The same logged hour carries two rule sets: what the employer pays and what the client contract allows to be billed.

What the Manual Routine Costs

A manual routine like this holds together because the people running it are careful, which is also why it is expensive. Analyst time goes to transcription and comparison work, and discrepancies get resolved from memory of past contract interpretations that are rarely written down anywhere a successor could find them.

iPaas for UKG

UKG Technology Partner

UKG + your ERP + your CRM, working as one.

Integrate Today

The consequences show up late. A misclassified hour surfaces as a payroll correction after close, or as an invoice query from the client weeks later. Labor is adjusted as far as 60 days back, and finance cannot see billing-ready labor until the manual step finishes, so program margin is always a retrospective number.

Designing the Pipeline to Preserve Both Rule Sets

CloudApper approaches this as an integration design problem rather than a data-entry problem. CloudApper iPaaS for UKG ingests the automaker’s daily export automatically, resolves identity between the client system’s worker identifiers and the corresponding UKG Pro WFM employee records, then applies the firm’s contract logic to split the file into two streams: hours destined for payroll, and hours destined for client billing. Validated pay codes are written into UKG Pro WFM timecards, and the billing stream is handed off to the firm’s own commercial process without ever passing through a timecard.

iPaas for UKG

UKG Technology Partner

Let UKG data flow automatically, everywhere it's needed.

Automate It

It is the same discipline behind producing a change-only file for a downstream payroll platform or consolidating dozens of country-level payroll reports into one export: transformation logic belongs in a layer that can be versioned and audited, not in a person’s morning routine.

“So our goal in an exercise like this would be nobody’s manually touching anything.”
Finance Lead, automotive engineering services firm

The Exception Queue Is the Point

Automated mapping carries its own risk: a pipeline can apply the wrong contract rule far faster than a person can. CloudApper handles this by treating exceptions as a first-class output rather than a failure state. When a record hits a project code, time category, or mid-shift transfer the two parties have not explicitly aligned on, the pipeline does not guess. It flags the record, holds it out of the sync, and routes it to a named reviewer. Nothing ambiguous reaches a UKG timecard without human sign-off, and over time the queue becomes a living record of contract interpretation.

The CloudApper iPaaS pipeline resolves identity, splits the payroll and billing streams, and holds exceptions for human review before anything reaches a UKG timecard.

Who Owns the Mapping When the Client Changes the Export

This is the question a CIO should ask before approving any feed sourced from a system their organization does not control, and it is the one most integration projects answer too late. The automaker will change its export at some point, on its own schedule, for its own reasons.

iPaas for UKG

UKG Technology Partner

Your systems, connected to UKG in one place.

Link Systems

Ownership has to be settled before anything goes live. In this design, CloudApper maintains the ingestion and transformation layer, including format changes on the client side; the firm’s HRIS team owns the pay code mapping and the exception review roster; UKG Pro WFM configuration stays untouched, which is what keeps the arrangement durable across platform updates. That separation is the same principle behind extending UKG Pro without disturbing the core configuration: the customization lives in a layer built to absorb change, so upgrades remain routine.

What This Means for Payroll, Finance and IT

The requirement is to retire the manual check-and-reclassify routine and the corrections it generates. With a designed pipeline, engineering staff embedded at client facilities can be paid from validated data rather than transcribed data, and finance can see project labor cost on the timecard’s cadence instead of the spreadsheet’s, the same way accurate job and cost center allocation turns labor data into a costing input rather than a payroll artifact.

For any firm whose people work inside a customer’s systems, the hours are already being captured accurately. What the organization needs is a connective layer that carries them into UKG under the right rules and stops when it is unsure. That is the work the CloudApper AI Platform for UKG does, and it is how a UKG investment can extend to a workforce whose time originates somewhere else entirely.

Questions HRIS Teams Ask About This Setup

How do you separate payroll hours from client billable hours when employees log time in a customer’s system but payroll runs in UKG Pro WFM?
Keep the two rule sets separate by design. An integration layer such as CloudApper iPaaS ingests the customer’s time export, resolves worker identity against UKG employee records, applies the contract’s billing logic and the employer’s pay policy as two distinct transformations, writes only the payroll result into UKG Pro WFM timecards, and routes the billing result to the commercial process. Records hitting an unaligned rule are flagged for review, not posted.

Who should own the data mapping when the time system belongs to the client?
Split it explicitly before go-live. The integration partner owns the ingestion and transformation layer, including changes the client makes to its export format. The HRIS team owns pay code mapping and exception review. UKG configuration stays unchanged so platform updates remain routine.

If your workforce logs time in a system you do not own, or your payroll and client billing rules keep meeting in a spreadsheet, talk to the CloudApper team about what a connected pipeline into UKG would look like for your contracts.