Integravision Solutionsintegravisionsolutions.com  ·  LLC Book an audit

29 Years Software Engineering · 10 Years at UKG · 10 Years Big 4 Consulting · .NET · Boomi · Full-Stack

Software & integrations that run clean, fast, and auditable.

Integravision Solutions is a software engineering and integration company built on 29 years of experience, with .NET and C# at the core — from .NET applications, APIs and services, to enterprise UKG Pro WFM (Dimensions) and Boomi integrations between Workday, UKG, payroll and downstream systems, plus databases, cloud, automation and reporting. 10 years of that experience was at UKG itself, where we built their first Paragon version — so we know this platform from the inside, not just as users of it. Another 10 years was spent in consulting at a Big 4 firm — one of the world's largest consulting firms. We run multiple client engagements in parallel: we audit, debug, build and tune — and document exactly what was wrong and how it was fixed.

29 yearsSoftware engineering — .NET at the core; design, build, debug, support
10 years at UKGBuilt UKG’s first Paragon version — platform knowledge from the inside
10 yearsConsulting experience at a Big 4 firm — one of the world’s largest consulting firms
6,701Employee records traced in a single production run review
47 of 73 minFound in UKG upsert waits — not Boomi — in a performance review
15 findingsPrioritized fixes (C1–C15) delivered with a full requirements document
INTEGRATION DIAGNOSTIC — SAMPLE FINDINGSREAD-ONLY REVIEW
CheckResult
Records in / upsert success6,701 / 6,522
Business-rule disqualifications62  REVIEW
Errors — incl. HTTP 400 batches of 10061  FIX
Unaccounted in run log56  TRACE
Cache index — cached key vs. arriving valueFIX
CRT / cross-reference tables reconciled26 tables · 23,157 rows
Upsert call wait (avg)~30 sec / call
PGP cipher — 3DES vs AES checkVALIDATED

From a real Employee Data Import review: two HTTP 400 failure points isolated (hires-existence check & reports-to), empty effective dates traced to a cache index problem in the cached pay-rule lookup, and 46,000 excess log lines per run identified. Client and employee identifiers are never published.

Sound familiar?

The failures that hide inside a “working” interface

Most UKG/Boomi interfaces don’t crash — they quietly lose records, run long, and leave no trail. An audit finds them before payroll or audit season does. The single most common culprit we find is the first one below: cache index problems.

⌗ Cache index problems — the silent lookup failure Very common

Boomi document caches are read through an index — often a single key, like a Pay Rule name feeding a cached lookup of pay-period (CPP) start dates. If the value arriving at runtime doesn’t match the cached key exactly — different case, trailing spaces, a renamed pay rule, or the row filtered out before the cache was built — the index finds nothing, the lookup returns blank, and the field goes to UKG empty. No error is raised and the run still reports success, so it can hide for months. We see this in interface after interface: it is one of the most common Boomi/UKG defects there is, and one of the easiest to miss without a deliberate cache-index check. Our audits verify every cached lookup — what the index is keyed on, which values actually arrive, and where the two diverge.

400 Batch HTTP 400s with no culprit record

When a hires check sends person numbers in batches of 100, one bad value fails the whole batch. We isolate which field — and which record — is responsible, instead of re-running and hoping.

◷ 70+ minute runs nobody can explain

Is it Boomi or UKG? We time every step. In one review, upserts alone were 47 minutes of a 73-minute run at ~30 seconds per call — pointing the fix at parallelism and batch size, not new hardware.

∅ Empty dates & silent rule filters

The symptom of the cache index problem above: effective / pay-period dates arrive blank because filter switches sit in front of the cached lookup — a pay rule dropped by a filter never reaches the cache at all, so its dates come out empty downstream with no error anywhere in the log.

⚿ Encryption & 3DES deprecation risk

UKG is removing TripleDES for SFTP/PGP after November 30, 2026. An RSA 4096 key alone doesn’t prove AES. We check the key’s preferred symmetric algorithms and validate with a dummy test file only — never real employee data.

⇄ Stale or wrong CRT mappings

Cross-reference tables quietly drift: a new pay rule, location or job code appears in the source but never gets a CRT row, so values pass through unmapped — or map to the wrong target — run after run. We modify CRTs (add, correct and retire mappings) and validate every table against the values the source actually sends and the values UKG expects, before anything reaches production.

⌫ Years of unused processes, profiles & connections

Boomi accounts accumulate dead weight: test and copy-of processes nobody dares delete, orphaned profiles, maps and shapes, old connections pointing at retired systems, and duplicate components with almost-identical names. Nobody knows what is safe to remove, so nothing is — and every audit, search and deployment gets slower and riskier. We inventory every component, trace what is actually referenced and deployed, and remove only what is provably unused.

✎ An interface built by someone else — and nobody can vouch for it

A vendor, systems integrator, contractor or a departed employee built it, the project closed, and go-live was declared — but there is no independent evidence it actually works correctly: counts were never reconciled, error handling was never tested, edge cases were never tried, and the handover was a folder of screenshots. You inherit the risk at payroll time. Our Code Inspection validates third-party work independently — against the requirements, the source and target data, and real run history — and gives you an acceptance verdict you can sign off on, or a defect list the builder has to fix first.

⇪ No clean way to test the UKG API

Your team needs answers straight from UKG — a person record, a schedule, an accrual balance — but there is no organized way to call the API: Postman is a tangle of one-off requests saved by different people, environments and tokens are set up differently on every laptop, example payloads are missing or out of date, and nobody is sure which endpoint, header or auth flow is the right one. Testing slows to trial-and-error and knowledge walks out the door with whoever figured it out last. We help you use the UKG API correctly and build — or clean up and organize — a Postman workspace your whole team can actually rely on.

◎ Mobile punches from anywhere — and no map to prove where

Employees punch in from the UKG mobile app, but without geofencing there is nothing stopping — or even flagging — a punch from home, the parking lot, another site, or another city. Managers suspect buddy punching and early clock-ins away from the work location, but the evidence is buried: UKG holds the punch GPS coordinates, yet nobody has a report that plots them. There is no map showing where punches actually occurred, no in-fence vs. out-of-fence count, and no exception list a manager can act on before payroll. We add geofencing to your UKG environment and build the Power BI (or other) reporting that puts every punch on a map.

Services — Full Catalog

Everything we do

29 years in software engineering means you’re not getting a single-tool contractor — you’re getting a company with the depth to run several engagements at once. .NET / C# is a core skill and UKG / Boomi is the specialty — the rest of the stack is the foundation underneath it. We take on multiple clients and projects in parallel, so your work never waits in a one-person queue. Contract engagements (C2C / 1099), remote across the U.S. Every engagement is documented with findings separated from recommendations. Each service below shows its starting price — based on our $150/hr expert rate — with the final fixed price quoted in writing after scoping, before work begins.

01

UKG / Boomi Integration Audit

  • Fixed price
  • Read-only first
  • Written report
From $2,950Starting price · Quick Check — see audit packages

Full trace of a live interface: record counts in vs. out, error and disqualification breakdown, HTTP failure isolation, performance timing by step, logging waste, security checks (PGP cipher, SFTP auth) — and a dedicated cache index review of every cached lookup, since key mismatches are among the most common and least visible defects in Boomi/UKG interfaces. Delivered as a requirements-grade document with prioritized corrections.

02

Interface Build & Debug

  • Boomi
  • Workday → UKG
  • SSIS
From $4,950Starting price · scoped per interface

New interfaces and rescue work on broken ones: person imports, assignments, accruals, pay rules, reports-to, schedule groups, and CRT / reference-data handling. Changes are made one at a time in UAT first, with your go-ahead at each step — nothing moves to production without explicit approval.

03

Performance Tuning

  • Parallel upserts
  • Batch sizing
  • Cache index fixes
  • Log reduction
From $2,950Starting price

Step-by-step timing to prove where the wait actually is, then the levers that matter: parallel upsert execution, batch-size testing, cache and lookup fixes — including cache index problems, where a cached lookup keyed on the wrong index (or matched against values that don’t arrive in the same form) silently returns blanks and forces rework — timeout handling for long runs, and cutting tens of thousands of noise log lines so real errors are visible.

04

Environment & Release Help

  • PROD / UAT / TST
  • Extensions
  • CRT data
From $1,950Starting price

Boomi environment-extension copying between environments, deployed-version and atom confirmation, and CRT export analysis, modification and validation — for example, reconciling 26 tables and 23,157 rows against live counts and flagging empty or missing tables that are still referenced by process config.

05

Documentation & Runbooks

  • Requirements docs
  • Smoke-test runbooks
  • Handover
From $1,950Starting price

Requirements documents, linkage reports (for example Workday ↔ UKG access-sync), preview / smoke-test runbooks, failure-alert design, and upstream source-validation checklists — written so another engineer can run, test, and support the interface.

06

Custom Software Development — .NET & C#

  • .NET / C#
  • Web apps
  • Backend services
  • Utilities & tools
From $7,500Starting price · per project

.NET is a core specialty. Design and build of internal tools, web applications, backend services, APIs, Windows services, data utilities, file processors, and automation tools — in C# / .NET and .NET Core, ASP.NET / Web API and Entity Framework, plus Java, Python, JavaScript / TypeScript and SQL where they fit better. Clean architecture, readable code, and handover documentation included.

07

API Development & System Integration

  • REST / SOAP
  • Webhooks
  • Any system to any system
From $4,950Starting price

Beyond HR: APIs built, consumed and debugged between ERPs, CRMs, payroll, finance, identity, scheduling and custom systems. REST, SOAP, GraphQL concepts, webhooks, OAuth / token auth, pagination, retries, idempotency, and full error handling — not happy-path only. For UKG specifically — direct API help and a built, organized Postman workspace — see service 16 below.

08

Database Design, Development & Tuning

  • SQL Server
  • PostgreSQL · MySQL · Oracle
  • Snowflake
From $2,950Starting price

Schema design, stored procedures, views, functions, triggers, indexing, query tuning, data migration, ETL / ELT, data cleansing, reconciliation and fixing bad joins, duplicates and missing data across SQL Server, PostgreSQL, MySQL, Oracle and Snowflake.

09

Reporting, BI & Dashboards

  • Power BI
  • SSRS · SSIS
  • Excel · Crystal
From $2,450Starting price

Operational and executive reporting: Power BI dashboards, SSRS reports, SSIS packages, Excel workbooks and automations, data models, KPIs, run / error / reconciliation dashboards — so managers see the truth without reading raw logs. For UKG punch-location maps in Power BI — where every mobile punch occurred, plotted against its geofence — see service 17 below.

10

Cloud, DevOps & Automation

  • Azure · AWS
  • CI / CD
  • Scripting
From $3,950Starting price

Azure and AWS services, deployment pipelines, environment management, scheduled jobs, PowerShell / Python automation, SFTP / PGP workflows, logging, monitoring and alerting — the work that keeps production running without manual babysitting.

11

Debugging, QA & Production Support

  • Root-cause analysis
  • Testing
  • Rescue work
$175/hrOr $1,500/month retainer · starting rate

Deep debugging across code, data, config and infrastructure: log analysis, defect isolation, unit / integration / UAT testing, regression and smoke-test plans, performance profiling, incident triage and fixing inherited or undocumented systems.

12

Architecture, Review & Consulting

  • Code review
  • Design review
  • Roadmaps
From $2,950Starting price

Solution architecture, integration strategy, code and design reviews, technology selection, security review (access, encryption, secrets handling), upgrade / migration planning, and honest second opinions before you commit budget.

13

CRT Modification & Validation

  • Cross-reference tables
  • Add · correct · retire mappings
  • Validated before deploy
From $1,950Starting price

Boomi cross-reference tables (CRTs) decide how source values become UKG values — pay rules, locations, job codes, org units and more. When they drift, records land wrong or fail silently. We modify CRTs safely: add missing mappings, correct wrong ones, retire dead entries and reconcile duplicates — then validate the result table-by-table against the live values your source system actually sends and the lookups UKG expects, checking for unmapped values, orphan rows, and mismatches between PROD, UAT and TST. Changes are tested in UAT first and documented row-by-row, so you can see exactly what changed and why.

14

Boomi Code Cleanup — Unused Processes, Profiles & Connections

  • Unused components only
  • Processes · profiles · connections
  • Nothing live or in use is touched
From $2,450Starting price

This cleanup is for unused components only — never the ones in use. Every process, subprocess, profile (XML, JSON, flat file, database, EDI), map, connection and connector operation, cache, CRT, folder and environment extension is inventoried and traced — what references it, what is deployed where (PROD / UAT / TST), and when it last ran — for one purpose: to prove which components are not referenced by anything live. Only those provably unused, orphaned, duplicated or test / copy-of components are flagged with the evidence, reviewed with you, and then removed or archived — never deleted on suspicion alone. Anything used — referenced by, shared with, or deployed alongside a live process — is left exactly as it is, and is documented as in-use so nobody removes it by mistake later. You get a before / after inventory, a list of everything removed and why it was safe, and a leaner account where search, deployment, auditing and handover are faster because only real, working code remains.

15

Code Inspection — Interfaces Built by Others

  • Code Inspection
  • Third-party QA
  • Acceptance testing
  • Handover sign-off
  • We didn’t build it — no bias
From $2,950Starting price

Code Inspection is our independent audit and validation service for interfaces built by others. When another vendor, systems integrator, contractor or internal team built the interface, you need someone who didn’t build it to say whether it is actually good. We inspect and validate third-party work independently: design and code review against the requirements and the agreed scope, configuration and mapping checks (including CRTs and cache indexes), record-count reconciliation from source to target, error-handling and retry behaviour, negative and edge-case testing, performance under real run volumes, and security — encryption, SFTP / API authentication and access. We also assess handover readiness: is the documentation complete enough for your team to support it, are runbooks and failure alerts in place, and what knowledge still lives only with the builder? You receive an acceptance report with a pass / fail result per criterion, defects graded by severity, a remediation list the builder can work from, and a clear verdict — ready for sign-off, sign-off with conditions, or not ready for handover. Because we are independent of the original build, the findings are evidence, not opinion — usable in vendor acceptance, milestone payment and warranty discussions.

16

UKG API Help & Postman Workspace — Build & Organize

  • UKG Pro WFM API
  • Postman workspace
  • Collections & environments
  • Auth & testing
From $1,450Starting price

We help clients work directly with the UKG API — and leave them a Postman workspace that makes it easy. If you are not sure which UKG Pro WFM endpoint to call, how authentication works, what headers and payloads UKG expects, or why a call returns an error, we work it through with you against your own tenant: correct endpoint and method, OAuth / token setup, request and response structure, filtering, pagination, and reading UKG error messages back to the field that caused them. Then we build — or clean up and organize — your Postman API workspace so that knowledge doesn’t stay on one person’s laptop: collections organized by domain (people / person import, time, scheduling, accruals, assignments and more), separate environments for UAT and production with base URLs and variables set once, authentication configured at the collection level, named and documented example requests with saved example responses — including common error examples — consistent naming, and lightweight tests that check status and key fields. Secrets and tokens are kept in environment variables, never hard-coded into shared requests. The result is a shared, documented workspace where any engineer on your team can find the right UKG call, run it safely in UAT, and see what a good response looks like — without starting from trial-and-error every time.

17

UKG Geofencing & Punch Location Reporting — Power BI Map

  • UKG geofencing setup
  • Mobile punch location
  • Power BI map dashboard
  • Out-of-fence exceptions
From $3,950Starting price · geofencing + Power BI punch map

Two connected pieces of work: control where punches can happen, and prove where they actually did. Geofencing in UKG: we add geofencing to your UKG Pro WFM environment — defining a geofence around each work location (site address, centre point and radius sized to the building, yard or campus, not a default that is too tight or too loose), assigning the fences to the right locations, jobs and employee groups, and configuring what happens on a mobile punch outside the fence in the UKG Pro mobile app — blocked, allowed with an exception, or flagged for manager review — together with the related punch rules, manager notifications and exception handling. It is tested in UAT first with test punches inside and outside each fence, so legitimate punches at the door, dock or satellite site are not rejected, before it is moved to production with your approval. Punch location reporting: we build a reporting tool — Power BI by default, or another reporting tool you already use — that takes the punch data UKG captures (employee, date and time, punch type, device / mobile source, and the GPS latitude and longitude recorded with the punch) via UKG Data Hub, the UKG API, scheduled extracts or a database feed, and plots every punch on an interactive map (ArcGIS Maps / Azure Maps visuals in Power BI). Punches are colour-coded — inside the geofence, outside the geofence, and no location captured — with the geofence boundary shown for each site, so a manager can see at a glance where punches are occurring, spot clusters away from the workplace, and drill from the map into the detail. The report is fully filterable — slicers and search for department, employee name, employee ID / person number, manager, site / location, job, date range, punch type (in / out), device and in-fence vs. out-of-fence status, and similar fields from your UKG data — so a manager can filter to one department, one person, or a set of employee IDs and see only their punches on the map, with the counts, exception list and detail table updating to match. It also includes distance-from-fence and out-of-fence exception lists, repeat-offender and buddy-punching patterns, and counts and trends over time. The report is set up with scheduled refresh, row-level access so managers see only their own teams, and an exportable exception table payroll and HR can work from — turning location data UKG already records into evidence you can act on, instead of suspicion nobody can prove.

.NET / C#IntegrationCRT Modification & ValidationBoomi Cleanup — Unused OnlyCode InspectionUKG API HelpPostman WorkspaceUKG GeofencingPunch Location MapPower BI Punch ReportingQA & Handover Sign-OffCache Index ReviewCustom DevelopmentWeb AppsAPIsDatabasesETL / Data MigrationReporting & BICloudDevOpsAutomationDebuggingPerformance TuningTesting / QAProduction SupportDocumentationArchitectureSecurity & EncryptionCode Review

UKG Integration Hub · Design Integration Templates

UKG Integration Templates We Work With

Employee Data Import is only one of them. UKG Pro WFM (Dimensions) ships with a large catalogue of standard integration templates in Integration Hub / Design Integration Templates — the starting points for most Boomi-based UKG interfaces. We deploy, configure, audit, debug and extend templates across all of the areas below: person and payroll data, timekeeping and punches, scheduling, accruals, attendance, leave, business structure and Healthcare Productivity. If your interface started life as one of these templates — or should have — we can work with it.

Honest note — this list is not complete, and no complete public list exists. UKG says Integration Hub includes over 80 standard templates, but only about 54 are named in public UKG sources — the ones listed on this page. The full, tenant-specific list lives inside your own UKG environment, at Administration > Application Setup > Integrations Setup > Design Integration Templates > Deploy > Integration Packs, and opening it needs a UKG login. Which templates you actually have also depends on your licensed modules and release. On an engagement, we read the list from your tenant and work from that — not from a public summary.

Quick Setup — The 14 Predefined Templates

The predefined integration templates UKG names for the Quick Setup (Turnkey Integration Platform) process. These are the templates UKG itself publishes as a named list:

  • Accrual Balance Reset Import
  • Attendance Balance Reset Import
  • Attendance Balance to Accrual Code Reset
  • Attendance Event Import
  • Bulk Enable Edits
  • Cost Center Import
  • Employee Group Import
  • Labor Category Entry Import
  • Labor Category List Assignment Import
  • Labor Category Profile Import
  • Leave Case Import
  • Organizational Set Import
  • Pay Code Edit Import
  • Punch Data Import

People / Employee Data

Person records into UKG Pro WFM — the family our Employee Data Import work belongs to, plus the other named people-data packs:

  • HCM People Import · HCMPeopleImport-v2 · UKG Pro HCM → WFM
  • PeopleImport-v1 · Universal · flat file via SFTP
  • SAP SuccessFactors Delta Employee Data Import · changed records only
  • Employee Group Import · Quick Setup
  • Organizational Set Import · Quick Setup

Payroll

Worked hours and pay data out to payroll, and payroll-side data in:

  • HCM Payroll Export-v2 · WFM → UKG Pro HCM payroll
  • PayrollExport-v1 · Universal · flat file via SFTP
  • Payroll Import · Healthcare Productivity
  • Payroll Department Mapping Import / Export · Healthcare Productivity
  • Payroll Employment Status Mapping Import / Export · Healthcare Productivity
  • Payroll Job Mapping Import / Export · Healthcare Productivity

Timekeeping & Punches

Punch data, pay code edits and timecard-related imports:

  • Punch Data Import · Quick Setup
  • Pay Code Edit Import · Quick Setup
  • Bulk Enable Edits · Quick Setup
  • Agency Export / Agency Import · Healthcare Productivity · agency timecard transactions

Scheduling

Schedules synchronised between UKG TeleStaff and UKG Pro WFM:

  • TeleStaff Schedule Import · WFTSScheduleImport-v1 · near real-time, one employee at a time
  • TeleStaff Schedule Batch Import · WFTSScheduleImport-Batch-v1 · multiple employees / dates, run daily or weekly

Accruals

Accrual balances out to HCM, and balance resets in:

  • HCM Accruals Export · HCMAccrualsExport · WFM → UKG Pro HCM
  • Accrual Balance Reset Import · Quick Setup
  • Attendance Balance to Accrual Code Reset · Quick Setup

Attendance & Leave

Attendance events and balances, and leave cases:

  • Attendance Event Import · Quick Setup
  • Attendance Balance Reset Import · Quick Setup
  • Leave Case Import · Quick Setup

Business Structure & Labour Categories

The structure every other interface maps against — cost centres and labour categories:

  • Cost Center Import · Quick Setup
  • Labor Category Entry Import · Quick Setup
  • Labor Category List Assignment Import · Quick Setup
  • Labor Category Profile Import · Quick Setup

Healthcare Productivity — Imports & Exports

The Healthcare Productivity set (CSV file-based, run from Maintenance > Integrations). Each export is the counterpart of the same-named import, used to verify an import by comparing output to input:

  • Work Unit Import / Export
  • Work Unit Hyperfinds Import / Export
  • Work Group Import / Export
  • Job Code Work Group Import / Export
  • Billing Department Mapping Import / Export
  • Charge Master Import / Export
  • Volume Department Copy Import / Export
  • Volume Department Copy Override Import / Export
  • Targets Import / Export
  • Fiscal Calendar Import
  • Volume Import
  • Agency Import / Export
  • Payroll Import
  • Payroll Department Mapping Import / Export
  • Payroll Employment Status Mapping Import / Export
  • Payroll Job Mapping Import / Export

However yours was built — from a UKG template, by another vendor, or from scratch — we can audit it, validate it with a Code Inspection, fix it, or take it over. Tell us the template or interface name from your tenant and we will start there.

Audit packages · Fixed price

Pick the depth you need

You’re buying a result — a verified picture of your interface and a prioritized fix list — not hours. No changes are made during an audit; implementation is a separate, approved step.

Quick Check

For one interface that “mostly works” but loses records or runs long.

$2,950
⏱ 1 WEEK · 1 INTERFACE
  • Run-log review with full record reconciliation
  • Error counts & HTTP 400 isolation
  • Performance bottlenecks by step
  • PGP / 3DES cipher check
  • Short findings report
  • Full C-style prioritized fix list
  • Walkthrough call
Start with Quick Check

Audit + Fix

We implement the top fixes for you — in UAT first, one change at a time.

$9,500 +
⏱ SCOPED AFTER AUDIT
  • Everything in Full Audit
  • Top fixes built & tested in UAT
  • CRT modifications — mappings added, corrected & validated
  • Boomi code cleanup — unused processes, profiles & connections removed
  • Code Inspection re-check after a third-party builder remediates audit findings
  • Postman workspace built or reorganized — UKG API collections, environments, auth & documented examples
  • UKG geofencing configured & tested — fences per site, out-of-fence punch rules & manager exceptions
  • Power BI punch-location map built — every punch plotted against its geofence, filterable by department, employee, employee ID, manager, site & date
  • Parallelism & batch-size changes
  • Failure alerts & logging cleanup
  • Preview / smoke-test runbook
  • Production deploy support*
  • *Data decisions & prod deploy need your explicit approval
Discuss Audit + Fix
Intro offer: First 2 audit clients — Full Audit at $3,500 in exchange for a testimonial once the work is delivered.Claim intro pricing

Not sure which one fits?

Tick what’s true for your interface — we’ll point you at the right package. No email required.

Our recommendation

Quick Check · $2,950

Start with a 1-week Quick Check. If it surfaces deeper issues, the fee logic is simple: upgrade to the Full Audit and we’ll credit the work already done toward the deeper review.

Ask about this package

Full capability — 29 Years

All the languages, platforms, databases & tools we work in

Boomi and UKG are the specialty, not the limit. With 29 years in software engineering behind the company, we debug and build across the full stack — languages, frameworks, databases, cloud, integration, reporting, testing and DevOps. If it’s listed here, we can read it, debug it, and build with it.

Boomi AtomSphereProcesses, maps, connectors, document caches and cache index design, CRT / cross-reference tables, environment extensions, deployed-version control, AtomSphere API, Molecule / Atom management — plus account-wide cleanup of unused components only: inventorying every component to prove what is in use, and removing only the unused processes, profiles, connections and orphaned components.CORE SPECIALTY
UKG Pro WFM (Dimensions) & UKG Pro HCMPerson import, pay rules, accruals, assignments, reports-to, hyperfind, Data Hub, time & attendance, scheduling, UAT vs. production behavior. Backed by 10 years at UKG, where we built their first Paragon version.CORE SPECIALTY · 10 YEARS AT UKG
Workday HCMHR source data, workers, job profiles, organizations, access-sync linkage, EIB / API concepts, upstream validation before data reaches Boomi.HCM SOURCE
Microsoft Stack — .NET, SSIS, SSRS, IIS.NET apps and services, SSIS + COZYROC ETL, SSRS reporting, IIS hosting, Windows Services and scheduled tasks.MICROSOFT
HR, Payroll & Identity SystemsPayroll, benefits, time, badge / access, Active Directory / Azure AD (Entra ID), SSO, RSA / IAM access-review concepts.ENTERPRISE
CRM, ERP & Business Systems (via API / DB)Salesforce, SAP, Oracle, Dynamics and other ERP / CRM systems reached via REST, SOAP, JDBC and file interfaces.VIA INTEGRATION
File Transfer — SFTP, WinSCP, FTPSKey-based SFTP auth, scheduled transfers, PGP encryption, decrypt-in-UI validation, and safe dummy-file testing.TRANSFER
PGP Tools & Encryption UtilitiesPGPTool, OpenPGP, COZYROC PGP tasks, key inspection — preferred symmetric algorithms, AES vs. 3DES verification.SECURITY
Web & API PlatformsWeb servers, API gateways concepts, Postman, Swagger / OpenAPI, JSON / XML tooling, browser-based UAT systems.WEB / API
UKG APIs & Postman WorkspacesDirect help with the UKG Pro WFM API — endpoints, OAuth / token auth, headers, payloads, filtering, pagination and error diagnosis — plus building and organizing Postman workspaces for clients: collections by domain, UAT / production environments and variables, collection-level auth, documented examples with saved responses, and lightweight tests, with secrets kept in variables, not in shared requests.UKG API · POSTMAN
UKG Geofencing & Mobile Punch LocationGeofences in UKG Pro WFM around each work location — centre point and radius per site, assigned to locations and employee groups — with punch rules for the UKG Pro mobile app: block, allow with exception, or flag for manager review when a punch falls outside the fence. Tested in UAT with inside- and outside-fence punches before production.GEOFENCING · MOBILE PUNCH
.NET & C# — .NET Core, ASP.NETCore specialty: web apps, Web APIs, Windows services, console tools, SSIS script tasks — full application development, debugging, refactoring and modernization of older .NET code.CORE SPECIALTY · BUILD + DEBUG
JavaEnterprise apps, integration utilities, Java-based tooling (including PGP tooling), log analysis, services and APIs.BUILD + DEBUG
PythonAutomation, data processing, ETL scripts, API clients, file handling, reporting scripts and quick tools that replace manual work.BUILD + DEBUG
JavaScript & TypeScriptFrontend and Node-style code, Boomi scripting, API logic, data shaping, validation and interactive web behavior.BUILD + DEBUG
SQL — T-SQL, PL/SQL, ANSI SQLStored procedures, functions, views, triggers, reconciliation queries, performance tuning on SQL Server, Oracle, PostgreSQL & MySQL.PRIMARY · BUILD + DEBUG
Groovy (in Boomi)Custom scripting inside Boomi maps and processes — data shaping, dynamic lookups, error routing, batch handling.BOOMI SCRIPTING
HTML5, CSS3 & Web UIResponsive web pages and app UI, forms, accessibility, and working with modern frontend frameworks / libraries.FRONTEND
VB.NET, VBA & Legacy .NETMaintaining and modernizing legacy Windows / Office automation, macros and older .NET codebases still running production.LEGACY SUPPORT
PowerShell & Batch / ShellScheduled jobs, file watchers, deployment and transfer automation, admin scripting and glue around SFTP / PGP jobs.AUTOMATION
XML, XSLT, JSON, CSV & Flat FileThe payloads interfaces actually move: UKG / Workday XML, JSON APIs, XSLT transforms, fixed-width and delimited files.DATA FORMATS
Regular Expressions & Data ParsingLog parsing, validation rules, file-format debugging and extracting signal from messy production data.EVERYDAY TOOL
Frameworks & LibrariesASP.NET / MVC / Web API, Entity Framework, ADO.NET, REST clients, common Java / JS / Python libraries as the project requires.FRAMEWORKS

In practice: if it feeds, transforms, stores or receives data, we can read its logs, trace its records, and fix it at the layer where it actually broke — not just inside one tool.

Microsoft SQL Server & Azure SQLPrimary database background: schema, stored procedures, SSIS / SSRS, staging, reconciliation, indexing and tuning.PRIMARY
PostgreSQLQueries, schema, data fixes and application backends — via direct SQL and Boomi / JDBC connectors.BUILD + DEBUG
MySQL / MariaDBWeb and app databases, queries, migration, validation and performance fixes.BUILD + DEBUG
Oracle DatabasePL/SQL, source / target systems via connectors, enterprise HR and finance data, validation and tuning.ENTERPRISE
SnowflakeCloud data warehousing concepts, SQL, loading, reporting and analytics queries.CLOUD DW
Boomi CRT / Reference DataCross-reference and lookup tables — modified (mappings added, corrected and retired) and validated table-by-table against live source and target values; exports reconciled (26 tables, 23,157 rows in one UAT review).REFERENCE DATA
SQLite, Access & Embedded DBsSmall tools, local apps and legacy Access databases still embedded in business processes.TOOLS / LEGACY
Flat Files, Excel & SFTP Drops as DataCSV, fixed-width, Excel, PGP-encrypted files — parsing, validation, error files and data cleansing.FILE DATA
ETL / ELT & Data MigrationSSIS, Boomi, SQL and Python pipelines; source-to-target mapping, CRT mapping, history loads and cutover validation.DATA MOVEMENT
Data Modeling & DesignNormalized and reporting models, keys, constraints, audit columns, slowly changing data concepts.DESIGN
Data Validation, Quality & ReconciliationIn vs. out counts, unaccounted-record tracing, duplicates, referential integrity and disqualification analysis.QUALITY
Encryption & Secure Data HandlingPGP (RSA 4096, AES vs. 3DES), SFTP key auth, masked / sample test data only for employee and sensitive records.SECURITY
Power BIDashboards, data models, measures, KPI views for operations, HR, finance and integration health.BI DASHBOARDS
Punch Location & Geofencing Reporting — MapPower BI (or SSRS / Excel / other reporting tool) map reports from UKG punch data: every punch plotted by its GPS latitude / longitude against its site geofence, colour-coded in-fence, out-of-fence and no-location. Fully filterable by department, employee, employee ID / person number, manager, site, job, date, punch type and fence status — filter to one department, one person or a set of IDs and the map, counts and exception table show only their punches. Scheduled refresh, manager-level row security and exportable exception lists included.POWER BI MAP · UKG PUNCHES
SSRS — SQL Server Reporting ServicesOperational, exception, reconciliation and audit-evidence reports on SQL Server data, scheduled and on-demand.SQL REPORTING
Excel Reporting & AutomationWorkbooks, pivot analysis, Power Query concepts, VBA / formulas, CRT and log analysis turned into stakeholder-ready summaries.ANALYSIS
Crystal Reports & Legacy ReportingMaintaining and migrating older report estates that still run the business.LEGACY
UKG & Workday ReportingUKG Pro WFM and Workday reports / data checks used to verify imports landed correctly — people, assignments, accruals, access.HR SYSTEMS
Interface Run & Operations ReportingRun summaries that survive the run: counts, errors, timing and authoritative totals — not 46,000 lines of noise.OPERATIONS
Custom Web DashboardsLightweight dashboards and status pages built in HTML / JS / APIs when off-the-shelf BI is too heavy.CUSTOM
Requirements, Audit & Linkage ReportsFormal documents: requirements, Workday ↔ UKG linkage reports, findings with a separate corrections section (PDF / Word).DOCUMENTS
Alerting & Monitoring DesignFailure alerts, threshold checks, email / dashboard alerts and “did the run actually succeed?” reporting for support teams.MONITORING
Microsoft AzureAzure SQL, App Services concepts, storage, functions / automation concepts, Azure AD (Entra ID) and cloud-hosted integrations.CLOUD
AWSS3, EC2 / hosted services concepts, file and API integrations with cloud storage and compute.CLOUD
Git, GitHub & Version ControlBranching, code review, release tagging, and keeping 29 years of lessons: never lose a working version.SOURCE CONTROL
CI / CD & Release ManagementBuild / deploy pipelines concepts, PROD / UAT / TST promotion, environment extensions, deployed-version confirmation.DEVOPS
Docker & Virtualization ConceptsContainerized tools and services, VM-hosted Atoms / servers, environment parity for testing.INFRASTRUCTURE
IDEs & Developer ToolsVisual Studio, VS Code, SQL Server Management Studio (SSMS), IntelliJ / Eclipse concepts, Postman, WinSCP, PGPTool.TOOLING
Scheduling & Job AutomationWindows Task Scheduler, SQL Agent, Boomi scheduling, cron-style jobs, file watchers and retry logic.AUTOMATION
Logging, Monitoring & Alerting ToolsApplication logs, run logs, performance counters, alert design — cutting noise so real errors stand out.OBSERVABILITY
Office & CollaborationMicrosoft 365, Excel, Word, SharePoint concepts — where requirements, CRTs and reports actually live in most companies.PRODUCTIVITY
Full SDLCRequirements, design, build, test, deploy, support — the whole life of a system, not just the coding phase.29 YEARS
Agile / Scrum & WaterfallWorking in sprints, backlogs and releases — and in formal change-controlled environments when the client requires it.DELIVERY
Debugging & Root-Cause AnalysisSystematic isolation: reproduce, bisect by layer (code / data / config / infra), prove the cause, fix once.CORE STRENGTH
Testing — Unit, Integration, UAT, RegressionTest plans, smoke tests, preview runs, dummy-file validation, and sign-off evidence your auditors accept.QA
Code Review & MentoringReviewing others’ code for correctness, security and maintainability; documenting patterns for the next engineer.QUALITY
Performance Tuning (End to End)Profiling code, SQL, APIs and integration steps separately — fixing the actual bottleneck, not guessing.PERFORMANCE
Security by DesignLeast-privilege access, encrypted transfer / storage, secrets never in code or chat, masked test data only.SECURITY
Change & Release ControlUAT-first changes, one at a time, explicit approval for production, rollback thinking before deploy.GOVERNANCE
Code InspectionIndependent audit and validation of interfaces built by other vendors, integrators or teams — inspecting code, maps and configuration against acceptance criteria, defect grading, remediation tracking and a sign-off verdict independent of the builder.THIRD-PARTY QA
Documentation-First HandoverRequirements, runbooks, linkage reports and support notes written to be picked up cold by any engineer a year later.HANDOVER
Protocols, APIs & formats we work in daily:RESTSOAPGraphQLWebhooksOAuth 2.0SFTP / FTPSPGP / OpenPGPXML / XSLTJSONCSV / Fixed-WidthJDBC / ODBCAtomSphere APIUKG Pro WFM APIPostmanUKG GeofencingPower BI MapsHTML / CSS

How an audit works

Read-only first. No surprises.

STEP 0 — YOURS

Intro call & access

30 minutes. You show us the interface, the run history, and the pain. We agree scope and the fixed price in writing before anything starts.

STEP 1

Read-only trace

We follow real runs end to end — counts, errors, timing, logs, CRT data — without changing anything. Sample / masked data only for tests.

STEP 2

Findings document

You get the full written report: what’s wrong, evidence for each finding, impact, and a prioritized correction list you own outright.

STEP 3

Walkthrough & next step

We review it together. Fix it yourselves, or we implement in UAT — one change at a time, each with your explicit go-ahead.

About — 29 Years in Software Engineering

Integravision Solutions LLC

We bring 29 years in software engineering — designing, building, debugging and supporting enterprise software across languages, databases, platforms and industries. That breadth is why clients trust us with the hard middle: the interfaces and data flows other firms are afraid to touch.

10 of those years were spent at UKG itself, where we built their first Paragon version. That insider history is why our UKG work goes deeper than configuration checklists — we know how this platform was built, not only how it is configured today.

Another 10 of those years were spent in consulting at a Big 4 firm — one of the world's largest consulting firms. That decade of enterprise consulting is behind how we run every engagement: scoped in writing, evidence first, and documented so the client can act on it.

Today we specialize in the high-stakes workforce stack — Workday, Boomi and UKG Pro WFM interfaces that decide whether 6,000+ employees are set up correctly for time, pay and access — but we also build custom software, APIs, database systems, ETL, reporting and automation across the full stack listed above. As a company, we handle multiple clients and projects concurrently, so engagements move in parallel rather than waiting in a one-person queue.

Recent work includes a full read-only analysis of a production Employee Data Import (Boomi → UKG), performance and cipher validation for the UKG 3DES deprecation, and CRT / environment work across PROD, UAT and TST. We document as we go — requirements, findings and corrections kept separate and auditable.

  • Experience29 years — software engineering
  • At UKG10 years — built first Paragon version
  • Big 4 consulting10 years — at a Big 4 firm
  • CompanyIntegravision Solutions LLC (S corp)
  • Domainintegravisionsolutions.com
  • BasedRemote — United States
  • EngagementsContract — C2C / 1099
  • CapacityTeam of senior consultants — multiple clients & projects in parallel
  • Core stack.NET & C# development
  • SpecialtyUKG / Boomi / Workday integrations
  • AlsoCustom software · APIs · UKG API & Postman · UKG Geofencing & Punch Maps · DB · BI · Cloud
  • Focus industriesHealthcare & large-workforce employers
  • Data practiceSample / masked test data only

Questions

Before you book

Will you change anything during the audit?

No. The audit is read-only. Implementation is a separate engagement, done in UAT first, one change at a time, and production moves only with your explicit approval.

What do you need from us to start?

Access to the Boomi process and run logs, a recent UKG run summary, and CRT / reference-data exports if you have them. Sample or masked data is enough for any test file — we never need real employee SSNs or private keys.

Can you help with the UKG 3DES deadline?

Yes — that check is included in both audit packages. We verify the PGP key’s preferred symmetric algorithms (AES-256 / 192 / 128 vs. 3DES), and validate end-to-end with a dummy encrypted test file only.

Can you modify and validate our CRTs?

Yes — that’s a service in its own right. We add, correct and retire cross-reference table mappings, then validate every table against the values your source system actually sends and the values UKG expects — catching unmapped values, duplicate or orphan rows, and differences between PROD, UAT and TST. Changes are made in UAT first, documented row-by-row, and moved to production only with your explicit approval.

Can you do a Code Inspection of an interface built by another vendor or team?

Yes — that is our Code Inspection service. We independently inspect and audit work built by other vendors, systems integrators, contractors or internal teams: design and code review against the requirements, mapping, CRT and cache-index checks, source-to-target count reconciliation, error-handling and edge-case testing, performance and security checks, and a handover-readiness assessment of the documentation and runbooks. You get an acceptance report with pass / fail per criterion, defects graded by severity, a remediation list for the builder, and a clear verdict — ready for sign-off, sign-off with conditions, or not ready. Because we did not build it, the report is independent evidence you can use for vendor acceptance, milestone payments and warranty discussions.

Can you help us with the UKG API and set up our Postman workspace?

Yes — both halves. For the UKG API itself, we help you find the right UKG Pro WFM endpoint for what you need, set up authentication correctly, shape the request and payload, handle filtering and pagination, and diagnose errors back to the field or value that caused them — working against your own UAT tenant first. For Postman, we build your workspace from scratch or clean up and organize the one you have: collections grouped by domain (people, time, scheduling, accruals, assignments), separate UAT and production environments with base URLs and variables, authentication set once at collection level, documented example requests with saved good and error responses, consistent naming, and simple tests on key calls. Tokens and secrets live in environment variables only — never hard-coded into shared requests — so the workspace is safe to share with your whole team.

Can you add geofencing to our UKG environment and show us on a map where punches are occurring?

Yes — both parts, as service 17. For geofencing, we define a fence for each work location in UKG Pro WFM — the site’s centre point and a radius sized to the actual building, yard or campus — assign the fences to the right locations and employee groups, and configure what happens when someone punches from the UKG Pro mobile app outside the fence: the punch is blocked, allowed with an exception, or flagged for manager review, with the related notifications and exception handling set up to match. We test it in UAT first with punches inside and outside each fence, so people at the door, dock or a satellite site are not wrongly rejected, and move it to production only with your approval. For reporting, we build a Power BI dashboard — or a report in another tool you already use — fed from the punch data UKG captures (via Data Hub, the UKG API, scheduled extracts or a database feed), plotting every punch by its recorded GPS coordinates on an interactive map with the geofence for each site drawn in. Punches are colour-coded inside the fence, outside the fence, and no location captured. The report is filterable by department, employee, employee ID / person number, manager, site / location, job, date range, punch type and in-fence vs. out-of-fence status — filter to one department, one employee, or a set of employee IDs and the map, totals and exception table show only their punches. Managers get row-level access to their own teams only, refresh is scheduled, and the out-of-fence exception list can be exported for payroll and HR follow-up.

Can you clean up our Boomi account — unused processes, profiles and connections?

Yes — and only the unused ones. We do not clean up, modify or remove components that are in use. We inventory every component in the account — processes and subprocesses, profiles, maps, connections and connector operations, caches, CRTs, folders and extensions — and trace what each one is referenced by, where it is deployed, and when it last ran, specifically to separate what is live from what is provably not referenced by anything. Only the unused, orphaned, duplicated or leftover test components are flagged with evidence and reviewed with you before removal; anything a live, deployed process uses or depends on is left exactly as it is. You receive a before / after inventory and a removal log, so the cleanup itself is auditable.

Do you only work in Boomi and UKG?

No — those are the specialty, built on 29 years of general software engineering. We also design, debug and build in C# / .NET, Java, Python, JavaScript / TypeScript, Groovy, SQL (T-SQL / PL/SQL), PowerShell, HTML / CSS and VBA / VB.NET; across SQL Server, PostgreSQL, MySQL, Oracle and Snowflake; with SSIS / SSRS, Power BI, Excel and Crystal reporting; on Azure and AWS; and via REST, SOAP, GraphQL, webhooks, SFTP and PGP. See the full stack tabs above — if your system touches data, we can work in it.

What kinds of projects do you take besides audits?

Custom software and tools, new API / system integrations, database development and tuning, ETL and data migrations, BI dashboards and reports, cloud / DevOps automation, production rescue and debugging, code and architecture reviews, and documentation / runbooks. Fixed-price where scope is clear; contract (C2C / 1099) for larger builds.

Can you maintain or fix a legacy system?

Yes. A large part of 29 years is inheriting undocumented systems — legacy .NET, VB / VBA, Access, Crystal Reports, old SSIS packages and scheduled file jobs. We trace first, document what we find, then fix or modernize without breaking production.

How is pricing handled?

Audit packages are fixed price, agreed in writing before work starts: Quick Check $2,950, Full Audit $4,950, Audit + Fix from $9,500. Every other service shows a clear “From” starting price on its service card above — based on our standard $150/hr expert rate — and the final fixed price for your scope is quoted in writing after a short scoping call, before any work begins. Debugging, QA & Production Support is the exception: it is billed at $175/hr, or on a $1,500/month retainer. Audit + Fix is scoped after the audit, once we both know exactly which fixes matter most.

Get a verified picture of your interface — or build the thing you need.

Tell us what’s hurting or what you need built — system, language / platform, and what goes wrong — and we’ll reply with scope and the fixed price where possible. We’re set up to take on new clients alongside the projects already in flight. Audits, builds, database work, reporting, cloud and rescue work all start here. No pitch deck, no obligation.

Request an audit by email Compare packages again integravisionsolutions.com · Remote, U.S.