The Customer

The customer is a large U.S.-based healthcare payments and financial technology platform focused on improving payer–provider financial workflows. Its systems support mission-critical operations such as claim pricing, reimbursement validation, and payment execution, all of which rely on precise, client-specific decision logic.

Each enterprise customer introduces distinct contractual terms, reimbursement thresholds, and policy constraints. These variations must be applied accurately and consistently, often with strict effective-date requirements. Any error or delay directly impacts financial accuracy and regulatory trust.

As the platform scaled across healthcare clients, the volume and complexity of decision logic increased rapidly, pushing existing processes beyond sustainable limits.

What Triggered the Change

Historically, a significant portion of client-specific decision logic lived outside the core application stack. Thresholds and mappings were maintained in spreadsheets, while other rules were embedded in a legacy Microsoft-based rules engine.

Over time, this approach created compounding issues:

• Rule updates required engineering involvement for even minor changes
• Spreadsheet-based logic introduced operational risk and inconsistency
• Effective-date handling depended on manual coordination
• Version history reconstruction during audits became difficult

With growing client volume and frequent policy changes, leadership recognized that the existing model could not scale without adding significant operational and engineering overhead.

The Challenges

Spreadsheet-Driven Rule Management

Client-specific thresholds were calculated and validated in spreadsheets that required continuous manual updates and reviews. This increased error risk and slowed down claim processing workflows.

Hardcoded Logic in Legacy Systems

A portion of decision logic was embedded in a legacy rules engine. While functional, it remained inaccessible to business teams and discouraged frequent iteration due to development cycle costs.

Engineering Dependency for Routine Changes

Operations teams lacked direct control over rule updates. Every modification entered the engineering backlog, reducing responsiveness to client and regulatory changes.

Limited Governance and Auditability

Versioning, rollback, and effective-date execution were handled manually, creating audit and compliance risk in a highly regulated healthcare environment.

Scalability Constraints

As rule volume grew across clients, the combined spreadsheet-and-code approach became increasingly fragile, with no clear path to reliably support large-scale rule expansion.

Why the Previous Approach Fell Short

Decision logic existed across multiple systems with fragmented ownership. Business teams understood policy intent but could not change rules. Engineering teams controlled execution but lacked full context behind policy decisions.

Every change required cross-team coordination and deployment cycles. Client onboarding slowed. Small updates carried disproportionate risk. Each additional customer increased complexity rather than operational leverage.

Over time, decision logic shifted from being an enabler to a bottleneck, limiting the platform’s ability to scale, adapt, and operate with confidence.

What the Customer Needed

The organization sought a solution that could:

• Externalize decision logic from core applications
• Enable business teams to own and manage rules
• Execute logic using real-time internal data
• Apply policy-effective dates automatically
• Maintain complete version history and audit trails
• Deploy securely within a private Azure environment
• Scale to hundreds of thousands of rules

The Solution: How Nected Was Implemented

The customer implemented Nected as a centralized decision automation layer, deployed inside its private Azure infrastructure and integrated with existing pricing and claims workflows.

Business-Controlled Rule Authoring

Operations teams now define and update client-specific thresholds, mappings, and validations using Nected’s visual rule editor, removing routine dependencies on engineering.

Real-Time System Integration

Nected executes decisions using live data fetched from internal systems at runtime. No sensitive data is stored or duplicated.

Policy-Effective Execution and Versioning

Rules are versioned automatically and evaluated based on effective dates, ensuring every transaction uses the correct policy logic.

Staging and Controlled Rollouts

Separate staging and production environments allow teams to test and validate changes before promotion, reducing production risk.

Audit-Ready Governance

Every rule change and execution outcome is logged, enabling traceability down to the exact rule version and input data used.

Scalable Decision Architecture

The implementation was validated to support 250,000+ rule conditions, removing scalability constraints for future growth.

‍

Before vs After Transformation

Quantitative Outcomes

The shift from spreadsheet- and code-driven logic to a centralized decision layer produced measurable, operational results within weeks of adoption.

(All outcomes based on internal and customer-validated measurements.)

• ~90% faster rule deployment  
  Rule changes that once waited for engineering release cycles now move from request to production in days, allowing Zelis to respond quickly to client and policy changes.
• Removal of spreadsheet dependency  
  Threshold calculations and validations now execute directly inside production workflows, eliminating manual handoffs and reconciliation effort.
• Reduced engineering workload  
  Engineers no longer spend cycles maintaining client-specific logic, freeing capacity for core platform and product development.
• Scalability to 250,000+ rule conditions  
  Decision logic growth no longer creates operational or technical bottlenecks as the customer base expands.

Qualitative Outcomes

Beyond efficiency gains, the change fundamentally altered how teams across Zelis operate and collaborate.

• Business autonomy  
  Operations teams now own the full lifecycle of rule definition, testing, and updates, reducing dependency on engineering for everyday changes.
• Improved audit confidence  
  Every decision is traceable to a specific rule version and effective date, making audits faster and less disruptive.
• Faster client onboarding  
  New client logic can be configured directly in the decision layer without touching application code, shortening onboarding timelines.
• Lower operational risk  
  Versioned, testable rules reduce the chance of incorrect logic being applied during policy updates or regulatory changes.

Why the Customer Chose Nected

The evaluation was driven by structural gaps in the existing decisioning approach rather than a search for another rule engine. The customer needed a platform that could realign ownership, governance, and scalability of decision logic without increasing compliance or operational risk.

A key factor was business ownership of logic. Policy thresholds, reimbursement rules, and client-specific mappings are business-defined by nature. The organization required a system where operations teams could author, test, and evolve this logic directly, without translating intent into tickets, code changes, or release cycles.

Governance and auditability were equally critical. In a healthcare payments environment, every decision must be explainable after the fact. Nected provided built-in versioning, effective-date execution, and complete audit trails, allowing audit and compliance teams to trace any outcome back to the exact rule configuration and input data used at that point in time.

Deployment control and security also influenced the decision. The ability to deploy Nected inside a private Azure environment ensured alignment with internal security standards and healthcare regulatory expectations, while avoiding duplication or persistence of sensitive data outside core systems.

From a technical standpoint, real-time execution on internal data removed synchronization challenges common with replicated decision stores. Decisions run against live system data, preserving accuracy while simplifying integration.

Finally, proven scalability was non-negotiable. Validation at 250,000+ rule conditions demonstrated that decision logic growth would not become a future bottleneck as client volume, policy variation, and regulatory complexity increased.

Together, these factors positioned Nected not as a point solution, but as a foundational decision layer that supports governed, scalable, and business-controlled decisioning across the organization.