Engineers at an automotive engineering services firm log project hours in their client's own time system while payroll runs in UKG Pro WFM. This case study covers how CloudApper iPaaS ingests the client's daily export, keeps payroll rules and contract billing rules separate, holds exceptions for human review, and settles who owns the mapping when the client changes its format.
Table of Contents
The engineers do not clock in on their employer’s system. They clock in on the customer’s.
That is the operating reality at a large automotive engineering, prototyping and testing services firm whose staff work inside a major automaker’s facilities. 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.
For years the reconciliation between them was a person. Every morning someone downloaded a CSV export from the automaker’s system, cross-referenced it against payroll records, decided what belonged on a timecard and what belonged on an invoice, and typed the result into UKG. CloudApper was brought in to turn that daily 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.
According to the Payroll Manager at the engineering services firm, the daily question was never how many hours an engineer worked. It was “whose hours, under whose rules, and which number is allowed to move.”
The same logged hour carries two rule sets: what the employer pays and what the client contract allows to be billed.
What the Daily Routine Actually Cost
The manual routine held together because the people running it were careful, which is also why it was expensive. Two staff spent the first part of every day on transcription and comparison work, and discrepancies were resolved from memory of past contract interpretations that were never written down anywhere a successor could find them.
“We were not short on controls. We were short on a place to put them. Every rule about what the client pays for and what we pay for lived in two people’s heads and a spreadsheet tab nobody else opened.”
HRIS Director, automotive engineering services firm
The consequences showed up late. A misclassified hour surfaced as a payroll correction after close, or as an invoice query from the client’s program office weeks later. Finance could not see project labor cost until the spreadsheet step finished, so program margin was always a retrospective number.
Building the Pipeline to Preserve Both Rule Sets
CloudApper approached 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.
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.
“The design decision that mattered was refusing to build one authoritative number. Two rule sets, permanently side by side, reconciled on purpose.”
Controller, 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. The firm and CloudApper handled 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 became the firm’s living record of contract interpretation.
“I care less about the hours that flow through cleanly. I care about the ones that stop. That queue is the only honest picture of where our contract and our pay policy disagree.”
IT Director, automotive engineering services firm
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.
The firm settled ownership before go-live. 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 Changed for Payroll, Finance and IT
The daily download-and-retype routine is gone, and with it the payroll corrections it generated. Engineering staff embedded at client facilities are paid from validated data rather than transcribed data. Finance sees 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 why this firm’s UKG investment now covers 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.
