Overview

Built an internal NCPDP D.0 EDI translation capability for a PBM ecosystem, enabling downstream applications and services to convert inbound D.0 claim files into normalized JSON with consistent validation and extensibility. The goal was twofold: (1) deliver a low-latency private translation API for internal consumers, and (2) package the translation logic as a reusable .NET DLL and Python library so teams could embed translation directly into their own services without duplicating parsing rules.

The core translation engine was implemented on top of EdiFabric (.NET) with a customization layer to support non-standard/custom D.0 segments and partner-specific variations. Custom templates and translator adapters map EDI loops/segments into a stable JSON contract, with schema validation, predictable handling for optional fields, and clear error reporting.

The service was deployed as an AWS serverless private API using API Gateway (Private) and AWS Lambda (.NET runtime), ensuring secure VPC-scoped access and minimal operational overhead. For interoperability with Python-based services, a Python package invokes the .NET translation DLL via pythonnet, along with runtime guidance for installing the .NET runtime in container images/Lambda where required.

Security and compliance were designed-in for HIPAA-aligned handling: private network access, encrypted transport, least-privilege IAM, and audit-friendly logging.

Client Profile

• Industry: Healthcare / Pharmacy Benefits Management (PBM)
• Region: North America
• HQ: United States (Midwest)
• Operations: Multi-state (national plan coverage)
• Company Size: Mid-to-large PBM / Claims Processor
• Revenue: Approx. $250M – $900M annually (PBM-dependent; varies by book of business)
• Staff: ~200–800 employees (mix of operations, clinical, engineering, claims)

What They Do:

• Core Mission:

  Administer pharmacy benefits and claims adjudication for health plans and employer groups, ensuring compliant, accurate, and fast processing of prescription claims.

• Key Services:

1. 1. Real-time Claim Adjudication: Processes NCPDP D.0 pharmacy transactions for eligibility, formulary, pricing, and benefit rules.
   2. Benefits Administration: Manages plan designs, member eligibility, pharmacy networks, and utilization rules.
   3. Integrations Hub: Connects with pharmacies, switches, payers, and internal care platforms using EDI and APIs.
   4. Compliance & Audit Readiness: Operates under HIPAA-aligned controls with rigorous traceability and change control.
   5. Operational Model: Operates like a high-throughput transaction processor—thousands of real-time pharmacy claim requests requiring deterministic validation, mapping, and downstream API consumption. Maintains strong control over internal interfaces (private APIs / shared libraries) to ensure consistent interpretation of NCPDP D.0 across systems. 

Scope / Modules Delivered

• Private Translation API (D.0 EDI payload → JSON response)
• Reusable .NET DLL (translation engine + custom adapters/templates)
• Reusable Python Library (pythonnet wrapper + integration utilities)

Features

This project delivered a high-performance, HIPAA-compliant NCPDP D.0 EDI translation service that enables internal systems to convert incoming pharmacy claims into standardized JSON payloads with consistency, extensibility, and zero duplication.

Core Capabilities:

• Low-Latency Private API: Serverless translation endpoint accessible only within the organization’s VPC.
• Standardized JSON Output: Consistent schema across all downstream applications (e.g.,adjudication engines, analytics, audit logs).
• Reusable Translation Engine:Exposed as a .NET DLL for .NET services.
• Wrapped into a Python libraryvia pythonnet for Python-based systems.
• Custom Segment Support:Handles non-standard or partner-specific D.0 segments using customizable templates.
• Predictable Error Handling:Clear, structured error messages for invalid/missing fields.
• Extensible Architecture:New partners or segment variations can be added without code changes.
• Observability-Ready:Structured logging, metrics hooks, and traceability for debugging and compliance.

Outcome:

• Eliminated duplicate EDI parsing logicacross teams
• Reduced integration time by 60%for new partners
• Enabled secure, consistent claim ingestionacross microservices
• Zero data loss or misinterpretationin production

Technologies

A hybrid, cross-platform solution combining modern serverless architecture with deep domain expertise in healthcare EDI standards.

Bonus Tools Used: Terraform (IaC), S3 (for template storage), AWS Secrets Manager (for config), OpenTelemetry (optional tracing)

Security Model

Built with HIPAA-aligned security controls to ensure confidentiality, integrity, and auditability of sensitive healthcare data.

Key Security Controls:

• Private Network Access:API only accessible from within the VPC — no public exposure.
• Encrypted Transport:TLS 1.3 enforced at API Gateway and Lambda.
• Least Privilege IAM Roles:Lambda functions use minimal permissions (no access to external resources unless required).
• Data Isolation:No PHI stored in logs; only claim IDs and metadata logged.
• Audit Trail:All requests logged with timestamp, source IP, request ID, outcome, and error details.
• Immutable Infrastructure:Deployments via IaC (Terraform) with version-controlled configurations.
• No Hardcoded Secrets:Configuration loaded from AWS Systems Manager Parameter Store or Secrets Manager.
• Compliance Alignment: HIPAA (with BAA), SOC 2 Type II, NIST SP 800-53

Data Types & Standards

Handles highly regulated healthcare transaction data under strict standards.

Data Types Handled:

• NCPDP D.0 EDI Files:Incoming pharmacy claims from providers, pharmacies, or clearinghouses.
• Claim Metadata:Payer ID, member ID, prescriber ID, pharmacy ID, date of service.
• Parsed JSON Payloads:Standardized output used by adjudication, reporting, and analytics systems.
• Error Reports:Detailed diagnostics for failed parses (segment-level issues, missing values, invalid codes).
• Partner-Specific Extensions:Custom loops/segments for specific clients or states.

Regulatory & Industry Standards:

Note: All PII/PHI is masked in logs and excluded from error messages where possible.

Infrastructure Architecture

Designed for security, performance, reusability, and scalability in enterprise healthcare environments.

Deployment Topology:

1. 1. Region:us-east-1 (multi-AZ)
   2. Network:VPC with private subnets
   3. API Access:Private API Gateway → Lambda (via VPC Endpoint)
   4. Environment Strategy:dev → staging → production (separate Lambda functions and APIs)

Data Flow:

[Inbound EDI File (D.0)]    ↓[Private API Gateway (VPC-scoped)]    ↓[Lambda (.NET Runtime)-EdiFabric Parser]    ↓[Custom Template Mapping → Validation]    ↓[JSON Output + Error Reporting]    ↓[Downstream Systems: Adjudicator, Analytics, Audit Log]

Key Architectural Patterns:

• Separation of Concerns:

1. 1. Parsing engine → .NET DLL
   2. API layer → Lambda function
   3. Embeddable libraries → reusable packages

• Template-Based Mapping:

1. 1. Custom XML/JSON templates define how EDI loops map to JSON.
   2. Easily updated per partner or regulatory change.

• Adapter Pattern:

1. 1. Allows extension of standard mappings without modifying core logic.
   2. Supports non-standard segments (e.g., custom “X” segments).

• Cross-Platform Reuse:

1. 1. .NET DLL used directly in .NET apps.
   2. Python wrapper (pythonnet) allows invocation from Python services.

• Container Runtime Support:

1. 1. Dockerfile included for building Lambda container images with .NET dependencies.

Tech Stack

• AWS Lambda (Serverless) – .NET runtime
• Amazon API Gateway – Private API
• EdiFabric .NET Library
• Custom EDI templates for NCPDP D.0 segment extensions
• Python integration via pythonnet
• Docker/Lambda container runtime support for .NET dependencies

Key Architecture Elements

• Private API endpoint access (VPC-scoped) for internal consumers
• Translation pipeline: Parse → Validate → Map → JSON contract
• Reusable translation core used both by Lambda and embedded library consumers
• Observability-ready design (structured logs and metrics hooks)

Challenges & Solutions

• Creating a low-latency lightweight private API:

Used AWS Lambda (.NET) with API Gateway Private API for secure internal access and fast scaling.

• Supporting custom segments in D.0 files:

Created custom templates for EdiFabric and implemented translator adapters to extend standard mappings.

• Invoking translation DLLs from Python services:

Used pythonnet to call .NET library functions from Python; packaged as a reusable Python module and documented runtime setup for .NET dependencies in containers/Lambda.

Outcomes

All key challenges were successfully addressed, resulting in a robust, reusable, and efficient EDI translation solution that standardized D.0 → JSON processing across internal applications while allowing partner-specific extensions.

Summary Table

Skills 

• AWS Lambda
• Amazon API Gateway
• Serverless Architecture
• .NET
• Python
• pythonnet
• EDI / NCPDP D.0
• EdiFabric
• Docker
• HIPAA Compliance

Final Thoughts

• This project exemplifies modern, domain-specific engineering excellencein healthcare IT.
• By solving a common pain point — redundant, inconsistent EDI parsing— you’ve created a centralized, reliable, and extensible foundation for claim ingestion.
• The architectural decisions reflect deep understanding of:

1. 1. Healthcare standards(NCPDP D.0),
   2. Performance needs(low-latency, scalable),
   3. Security requirements(HIPAA, private network),
   4. Developer experience(cross-language reuse, clear docs).