Case Study — Healthcare Infrastructure
Serverless API Platform for Healthcare Interoperability
How we designed and delivered a production-grade serverless API platform for a Bengaluru-based healthtech company — enabling ABDM-compliant health record exchange across 200+ hospitals, labs, and pharmacies on India's national digital health stack.
Client
Healthtech Company
Industry
Healthtech / ABDM
Timeline
14 months
Team Size
6 engineers
Results at a Glance
200+
Hospital integrations live
1.2M
Health records exchanged (Year 1)
99.99%
API uptime, measured over 12 months
180ms
Average API response time (p50)
0
PHI data breaches since launch
100%
ABDM sandbox certification pass rate
01 — Client Overview
A Bengaluru-Based Healthtech Company
The client is a Bengaluru-based healthtech company with a mission to accelerate India's transition to a unified, interoperable digital health ecosystem. Founded in 2021 by a team of former NHA (National Health Authority) policy advisors and enterprise software engineers, the company builds middleware and integration infrastructure that bridges the gap between legacy hospital management systems and modern digital health standards.
Their core product is a health information exchange (HIE) platform that acts as a certified Health Information Provider (HIP) and Health Information User (HIU) under the Ayushman Bharat Digital Mission (ABDM) framework. This means hospitals and diagnostic labs that integrate with the platform can automatically participate in the national health record exchange network — giving patients sovereignty over their own health data through their ABHA (Ayushman Bharat Health Account) IDs.
By the time the client engaged Xortrix AI, they had strong domain knowledge and regulatory relationships but were running a prototype-grade backend that could not support the load, security requirements, or operational complexity of a production deployment across hundreds of healthcare institutions. They needed a partner who could translate deep compliance requirements into a robust, scalable cloud architecture — and deliver it on the aggressive timelines the NHA certification process demanded.
02 — The Challenge
The Complexity of Health Interoperability at Scale
Building a health record exchange platform in India is not simply a technology problem. It sits at the intersection of regulatory compliance, clinical data standards, legacy system heterogeneity, and privacy law — each of which introduces its own constraints that compound one another.
ABDM Compliance Requirements
The Ayushman Bharat Digital Mission mandates specific API contracts for HIP and HIU gateway interactions, signed consent artifacts, ABHA ID verification flows, callback-based health record fetch patterns, and audit logging at the transaction level. Every API response, consent workflow, and data transfer must conform precisely to the NHA-defined specifications. Deviation from these contracts — even in non-functional attributes like response envelope structure — results in certification failure and the inability to operate on the national network.
FHIR R4 as the Canonical Data Format
ABDM mandates FHIR R4 (Fast Healthcare Interoperability Resources) as the wire format for health records. This is the correct long-term standard, but it created an immediate problem: of the 200+ hospital management systems the client needed to integrate with, the vast majority persisted clinical data in HL7 v2 messages, proprietary XML schemas, or bespoke relational database formats. The platform needed a transformation pipeline capable of ingesting data in dozens of formats and emitting validated FHIR R4 bundles — without data loss or clinical meaning distortion.
Consent Management as a First-Class Concern
Under the Digital Personal Data Protection Act and the ABDM Health Data Management Policy, every health record fetch must be preceded by a patient-granted, time-bound, purpose-specific consent. Consents are represented as cryptographically signed consent artifacts — JSON documents signed with the HIP and HIU gateway keys. The platform must track consent lifecycle states (REQUESTED, GRANTED, REVOKED, EXPIRED, DENIED), enforce data access windows, and immediately halt record delivery if a consent is revoked mid-transfer. Consent state must be consistent, auditable, and tamper-evident.
Protected Health Information Security
Health records contain the most sensitive category of personal data. The platform needed end-to-end encryption for data in transit and at rest, strict access control with least-privilege IAM, envelope encryption using customer-managed KMS keys, and comprehensive audit trails proving that PHI was accessed only under valid consent. The client's enterprise hospital customers were explicit: they would not integrate unless the client could demonstrate security practices equivalent to HIPAA-adjacent standards, even though India does not yet have a direct equivalent.
Heterogeneous Hospital Management System Integrations
The target market included public hospitals running open-source HMIS like Bahmni, private hospital chains on Oracle Health (formerly Cerner), mid-tier hospitals on custom .NET or Java monoliths, and small clinics using off-the-shelf billing software with minimal API exposure. Each integration required a different adapter: some via HL7 MLLP sockets, some via proprietary REST APIs, some via database polling with change data capture, and some via SFTP file drops. Building a generic, extensible adapter framework was as large a technical challenge as the core API platform itself.
Operational Scale and Availability Expectations
Hospitals operate 24/7. A patient arriving for emergency treatment at 3am needs their records available immediately. The platform needed to target four-nines uptime (99.99%), handle burst traffic during morning outpatient rushes, and scale to zero overnight to control costs — requirements that pointed strongly toward a serverless architecture. At the same time, cold start latency in Lambda is a real concern for patient-facing workflows, demanding careful use of provisioned concurrency for latency-sensitive endpoints.
03 — Solution Architecture
A Serverless-First Architecture for Healthcare-Grade Workloads
After evaluating ECS-based containerized deployments and managed Kubernetes options, we recommended and implemented a fully serverless architecture on AWS. The decision was driven by three factors: the spiky, unpredictable traffic profile of healthcare record requests; the operational burden reduction that serverless provides (no patching, no capacity planning); and the native integration between AWS Lambda and the broader AWS security ecosystem that makes compliance controls easier to implement and audit.
The architecture is decomposed into distinct planes — the gateway plane, the business logic plane, the data plane, and the async processing plane — each with independently scalable and auditable components.
Core Infrastructure Components
Amazon API Gateway (HTTP API)
Gateway PlaneAll inbound API traffic enters through Amazon API Gateway configured as HTTP APIs (not REST APIs) for lower latency and cost. We defined separate API stages for ABDM gateway callbacks, hospital HIP integration endpoints, patient-facing HIU query APIs, and internal operational endpoints — each with its own throttling configuration, WAF association, and access log destination. Custom domain names are mapped per API type, with mutual TLS (mTLS) enabled on the ABDM gateway-facing endpoints to satisfy NHA's certificate pinning requirements.
Lambda Custom Authorizers
Authentication PlaneEvery API endpoint is protected by a Lambda custom authorizer (REQUEST-type, not TOKEN-type, to enable access to full request context). The authorizer validates inbound JWTs issued by the ABDM gateway using JWKS endpoint verification with key rotation support, verifies hospital-specific API keys against DynamoDB, enforces ABHA token signatures for patient-initiated requests, and returns a fine-grained IAM policy document scoping the downstream Lambda's execution context. Authorizer responses are cached for 300 seconds per unique token to avoid redundant validation overhead, with cache invalidation triggered on token revocation events via SQS.
AWS Lambda (Business Logic)
Compute PlaneBusiness logic is distributed across purpose-specific Lambda functions written in TypeScript (Node.js 20.x runtime). Key functions include: ConsentOrchestrator (handles the full consent lifecycle state machine), HealthRecordFetcher (initiates async record collection from registered HIPs), FHIRTransformer (runs HL7-to-FHIR transformation), ABDMGatewayAdapter (implements the NHA gateway protocol including push notifications to ABDM callback URLs), and AuditEmitter (writes structured audit events to CloudWatch Logs). Provisioned concurrency is configured on ConsentOrchestrator and ABDMGatewayAdapter — the two functions in the critical path for patient-facing workflows — targeting 20 pre-warmed instances each to eliminate cold start latency from consent grant and record request flows.
Amazon DynamoDB
Consent and State StoreDynamoDB serves as the primary state store for consent artifacts, consent lifecycle events, hospital registration records, and ABHA linking tokens. Tables are encrypted at rest with AWS-managed KMS keys (SSE-KMS with aws:dynamodb service key), with DynamoDB Streams enabled on the ConsentTable to trigger downstream processing when consent state transitions occur. The data model uses a single-table design with entity-type prefixed partition keys (CONSENT#<consentId>, HOSPITAL#<hipId>, PATIENT#<abhaId>) and composite sort keys for efficient access patterns. Point-in-time recovery is enabled on all production tables with a 35-day retention window.
Amazon S3 (Health Record Store)
Data PlaneAssembled FHIR bundles are stored in a dedicated S3 bucket with server-side encryption using customer-managed KMS keys (SSE-KMS). Each health record object is keyed by a compound path that includes the consent artifact ID, the ABHA address hash, and a record timestamp — making access pattern auditing straightforward. Bucket policies enforce that objects are only accessible via the VPC endpoint (no public internet path exists to health record objects). S3 Object Lock is enabled in Governance mode with a 7-year retention policy for audit compliance. Pre-signed URLs with 15-minute expiry are generated for patient health record downloads, with URL generation events logged to CloudTrail.
AWS KMS (Key Management)
Encryption PlaneWe implemented an envelope encryption pattern for PHI. Each health record is encrypted with a unique data encryption key (DEK) generated per-record. The DEK is itself encrypted (wrapped) with a customer-managed KMS CMK. The encrypted DEK is stored alongside the record metadata in DynamoDB; the plaintext DEK exists only in Lambda function memory during record assembly and is never persisted. KMS CMKs are configured with key policies that restrict decrypt operations to specific Lambda execution roles and require multi-region replication for disaster recovery. Key usage is logged to CloudTrail with each decrypt event associated to a consent artifact ID.
Amazon SQS (Async Processing)
Async Processing PlaneHealth record fetch is inherently asynchronous in the ABDM protocol: the HIU requests records, the HIP queues a fetch job, retrieves records from its HMIS, packages them as FHIR bundles, and delivers them via a callback URL — all without a synchronous HTTP connection held open. We modelled this with SQS FIFO queues per hospital (to maintain ordered processing within a consent context), Lambda triggers consuming from those queues with a batch size of 1 for isolation, a dead-letter queue capturing failed fetch attempts with a redrive policy after 3 retries, and a separate RecordDeliveryQueue for outbound FHIR bundle dispatch to HIU callback URLs. Message bodies are encrypted using SQS SSE with the same CMK hierarchy as the record store.
Amazon CloudWatch (Audit and Observability)
Observability PlaneEvery significant operation — consent state transition, health record access, FHIR transformation, ABHA ID verification, gateway authentication — emits a structured JSON audit event to a dedicated CloudWatch Log Group with a 2-year retention policy and log data protection enabled to mask PHI in log streams. CloudWatch Logs Insights queries are pre-built for common audit scenarios: 'all record accesses under a given consent ID', 'all consents granted for a specific ABHA address in a time window', 'failed authentication attempts per hospital in last 24 hours'. CloudWatch Alarms monitor error rates, DLQ depth, consent processing latency, and API Gateway 5xx rates, with PagerDuty integration via SNS for on-call alerting.
04 — Implementation Details
Engineering the ABDM Protocol Layer
FHIR R4 Compliant API Endpoints
The platform exposes a set of FHIR R4 RESTful endpoints for clinical resource management, alongside the ABDM-specific gateway endpoints that implement the NHA protocol. FHIR resources supported in the initial release include Patient, Observation, DiagnosticReport, MedicationRequest, AllergyIntolerance, Condition, Procedure, Encounter, and DocumentReference — covering the health record categories defined in ABDM's Health Data Management Policy (HDMP).
Each FHIR resource endpoint validates incoming resources against the ABDM FHIR Implementation Guide profiles using the HAPI FHIR validator running as a Lambda layer. Invalid resources are rejected with OperationOutcome responses that include specific validation failure details, which we found dramatically reduced integration debugging time for hospital IT teams. Resources that pass validation are stored as immutable FHIR bundles in S3, indexed in DynamoDB with metadata for efficient retrieval.
Bulk export endpoints implement the FHIR Bulk Data Access ($export) specification for large record set transfers, with export jobs managed asynchronously via SQS and status polling via a job status endpoint. This was critical for initial data migration scenarios where hospitals needed to export years of historical records into the ABDM ecosystem.
HIP and HIU Gateway Implementation
The ABDM protocol defines separate API contracts for Health Information Providers (HIPs — hospitals and labs that hold patient records) and Health Information Users (HIUs — entities requesting records, such as insurers, other hospitals, or patients themselves). The client operates in both roles: as a HIP on behalf of integrated hospitals, and as a HIU on behalf of downstream applications querying the health record network.
The HIP gateway implementation handles: ABHA number verification callbacks from the ABDM central registry, consent request notifications, health information request notifications, and record packaging with digital signatures. The HIU gateway implementation handles: initiating consent requests, receiving consent grant notifications, initiating health information requests, and receiving delivered health records via callback.
HIP Endpoints Implemented
- ›/v0.5/patients/care-contexts/discover
- ›/v0.5/links/link/init
- ›/v0.5/links/link/confirm
- ›/v0.5/consents/hip/notify
- ›/v0.5/health-information/hip/request
- ›/v0.5/health-information/notify
HIU Endpoints Implemented
- ›/v0.5/consents/request/init
- ›/v0.5/consents/hiu/notify
- ›/v0.5/consents/fetch
- ›/v0.5/health-information/hiu/request
- ›/v0.5/health-information/hiu/on-request
- ›/v0.5/health-information/transfer
Consent Artifact Management
Consent artifacts are the cryptographic backbone of ABDM record exchange. Each consent is a JSON document containing the patient's ABHA address, the requesting HIU's identifier, the HIP's identifier, the permitted health information types, the time range of records permitted, the consent expiry date, and the purpose of access — all signed with the ABDM gateway's private key and countersigned by the ConsentManager.
We implemented consent state management as a DynamoDB-backed state machine. State transitions are atomic (using DynamoDB conditional writes with the current state as the condition expression) to prevent race conditions when concurrent revocation and fetch events arrive simultaneously. DynamoDB Streams trigger a ConsentStateProcessor Lambda on every state change, which propagates notifications to relevant parties, invalidates API Gateway authorizer cache entries for affected tokens, and writes an audit event.
Consent expiry is enforced proactively via EventBridge Scheduler rules created at consent grant time, targeting the exact expiry timestamp and triggering automatic consent state transitions to EXPIRED. This prevents any edge case where an expired consent remains technically valid due to a missed revocation check.
HL7 to FHIR Data Transformation Pipeline
The single most technically complex component of the platform is the HL7-to-FHIR transformation pipeline. Legacy hospital management systems emit HL7 v2.x messages — a pipe-delimited wire format from the 1980s that encodes clinical events like admissions (ADT), lab results (ORU), and orders (ORM). These must be translated into structured FHIR R4 resource bundles without loss of clinical meaning.
We built the transformation pipeline as a Lambda function using the open-source HL7 FHIR Converter library as a base, extended with custom mapping templates for India-specific coding systems (ICD-10-CM localizations, LOINC code mappings for common Indian lab panels, SNOMED CT mappings for diagnosis codes). The pipeline runs as a multi-step process: message parsing and segment extraction, segment-to-resource mapping using Liquid templates, SNOMED/LOINC code normalization via a DynamoDB-backed terminology service, FHIR bundle assembly, and FHIR profile validation against the ABDM IG.
For hospitals emitting proprietary XML or JSON, we built hospital-specific adapter Lambda functions invoked upstream of the FHIR transformer. These adapters normalize inbound data into a canonical intermediate representation that the main transformer can process uniformly — isolating hospital-specific quirks from the core transformation logic and making it straightforward to onboard new hospital integrations by writing only the adapter layer.
Per-Hospital Rate Limiting and Quota Management
With 200+ hospital integrations, uncontrolled traffic from any single integration partner would have downstream effects on the entire platform. We implemented per-hospital rate limiting at two layers: API Gateway usage plans with per-API-key throttling (burst limit of 500 requests/second per hospital, sustained rate of 100 requests/second), and application-level quota enforcement in the Lambda authorizer that checks a DynamoDB rate limit table using atomic increment operations with TTL-based reset.
Hospitals that consistently exceed their quota receive graduated response codes: 429 with a Retry-After header for burst violations, and a 429 with a quota-exceeded reason code for sustained overuse. The operations dashboard surfaces per-hospital quota consumption in real time via CloudWatch metrics published by the authorizer Lambda, enabling the operations team to proactively reach out to integrating hospitals showing unusual traffic patterns before they become incidents.
05 — Security & Compliance
Security Architecture for PHI at Scale
Healthcare data security is not a feature — it's the architectural foundation. Every design decision in this platform was made with the assumption that PHI data will be targeted by adversaries and that the blast radius of any breach must be minimized through defense-in-depth controls. We implemented a security model aligned to HIPAA Security Rule principles (which formed the client's enterprise customer requirements) even though Indian law does not yet mandate this framework.
Network Isolation
- All Lambda functions execute inside a dedicated VPC with no internet gateway attachment
- VPC endpoints deployed for all consumed AWS services: S3, DynamoDB, SQS, KMS, CloudWatch Logs, Secrets Manager — eliminating any PHI data path over the public internet
- Security groups on Lambda ENIs permit outbound traffic only to specific service VPC endpoint prefix lists
- AWS PrivateLink used for ABDM gateway connectivity where NHA infrastructure supports it
- Network ACLs provide subnet-level stateless filtering as a secondary control layer
Identity and Access
- Separate IAM execution roles per Lambda function, each with least-privilege policies scoped to specific resource ARNs
- No wildcard resource ARNs or wildcard action policies exist anywhere in the account
- AWS IAM Access Analyzer runs continuously with findings reviewed weekly
- AWS Organizations SCPs prevent IAM privilege escalation paths and block creation of public S3 buckets
- All human access to AWS console requires MFA; production access requires a break-glass procedure with CloudTrail alerting
Encryption Architecture
- Envelope encryption: per-record DEKs wrapped with customer-managed CMKs
- S3 SSE-KMS with CMKs; DynamoDB SSE-KMS; SQS SSE with CMK
- TLS 1.2 minimum enforced on all API Gateway endpoints; TLS 1.3 preferred
- mTLS on ABDM gateway endpoints with certificate rotation automation via ACM
- KMS key rotation enabled with annual automatic rotation; key usage logged to CloudTrail per decrypt call
Audit and Monitoring
- CloudTrail enabled across all regions with S3 log delivery to an immutable audit account
- CloudWatch Logs Insights pre-built query library for PHI access audit scenarios
- AWS Config rules continuously evaluate resource configuration drift
- GuardDuty enabled for threat intelligence-based anomaly detection
- Security Hub aggregates findings from GuardDuty, Config, IAM Access Analyzer, and Inspector
Penetration Testing and Third-Party Audit
Before the ABDM sandbox certification submission, we engaged an independent security firm to conduct a black-box penetration test of all externally accessible API endpoints and a white-box review of the IAM configuration and encryption key hierarchy. The engagement identified three medium-severity findings — all related to overly permissive CORS configuration on non-PHI operational endpoints — which were remediated before the certification window. No high or critical findings were identified.
The pen test report and remediation evidence were included in the ABDM sandbox certification submission package, which NHA cited as a contributing factor in the accelerated certification review timeline.
06 — Tech Stack
Technology Choices
Compute
- ›AWS Lambda (Node.js 20.x)
- ›Lambda Layers (HAPI FHIR Validator)
- ›Lambda Provisioned Concurrency
API Layer
- ›Amazon API Gateway (HTTP API)
- ›Lambda Custom Authorizers
- ›AWS WAF with managed rule groups
Data Stores
- ›Amazon DynamoDB (single-table design)
- ›Amazon S3 (FHIR record store)
- ›Amazon ElastiCache Redis (session tokens)
Messaging
- ›Amazon SQS FIFO (per-hospital queues)
- ›Amazon EventBridge Scheduler
- ›Amazon SNS (operational alerts)
Security
- ›AWS KMS (CMK envelope encryption)
- ›AWS Secrets Manager
- ›AWS IAM / Organizations SCPs
- ›AWS Certificate Manager (mTLS)
Observability
- ›Amazon CloudWatch Logs + Insights
- ›AWS CloudTrail
- ›AWS X-Ray (distributed tracing)
- ›Amazon GuardDuty + Security Hub
Networking
- ›Amazon VPC with private subnets
- ›VPC Endpoints (PrivateLink) for all services
- ›AWS PrivateLink for ABDM connectivity
Infrastructure as Code
- ›AWS CDK (TypeScript)
- ›GitHub Actions for CI/CD
- ›AWS CodePipeline for production gates
Clinical Standards
- ›FHIR R4 (HL7)
- ›ABDM FHIR Implementation Guide
- ›HL7 v2.x (inbound integration)
- ›SNOMED CT, LOINC, ICD-10-CM
07 — Outcomes
What We Delivered
Fourteen months after the engagement began, the client is operating as a certified ABDM Health Information Provider and Health Information User — one of a small number of platforms to achieve dual certification in the first cohort. The platform processes consent and record exchange transactions in production daily, with a track record that has become a proof point in the client's enterprise sales conversations.
200+ Hospitals, Labs, and Pharmacies Integrated
The adapter framework enabled the client's integration team to onboard a new hospital in an average of 3 days once the HL7/API interface was understood — down from the estimated 3–4 week timeline in the original prototype architecture. The mix includes public hospital networks, private hospital chains, standalone diagnostic labs, and retail pharmacy chains.
1.2 Million Health Records Exchanged in Year One
The platform handled 1.2 million FHIR bundle exchanges in its first 12 months of production operation — a volume that grew month-over-month as new hospitals went live. The SQS-based async processing architecture absorbed traffic spikes without performance degradation, with the FIFO queue design ensuring ordered delivery even during peak load.
99.99% Measured API Uptime
Over the first 12 months, the platform recorded 52 minutes of total unplanned downtime — a 99.99% uptime figure. Two incidents contributed to this: a 34-minute DynamoDB regional degradation that impacted consent state reads (mitigated by DynamoDB global tables in a subsequent architecture update), and an 18-minute API Gateway cold start cascade during a provisioned concurrency misconfiguration after a deployment.
180ms Average API Response Time (p50)
Provisioned concurrency on the two critical-path Lambda functions eliminated cold start latency from the patient-facing consent and record fetch flows. The p50 API response time of 180ms meets the NHA guideline of sub-300ms for gateway interactions. The p99 response time is 420ms, occurring on endpoints that require KMS decrypt operations and DynamoDB reads in the hot path.
ABDM Sandbox Certification: First Attempt Pass
The client passed the NHA ABDM sandbox certification on the first submission attempt — uncommon for dual HIP/HIU certification. The NHA review team noted the completeness of the audit log implementation and the robustness of the consent revocation flow as particularly well-implemented. The certification unlocked the platform's ability to operate on the production ABDM network.
Zero PHI Data Breaches
In 14 months of production operation and the preceding 3-month sandbox period, zero PHI data breaches or unauthorized data access events have been recorded. GuardDuty has flagged and auto-remediated two anomalous IAM credential usage events during this period — both traced to developer configuration errors in non-production environments, neither involving PHI.
08 — Reflections
What We Learned
The deepest lesson from this engagement was that healthcare interoperability is fundamentally a data governance problem, not a technology problem. The technology to exchange health records securely has existed for years. The hard work is establishing the trust model: which entity vouches for a patient's identity? Who controls access revocation? What happens to data already fetched when a consent is revoked? These questions have policy answers (the ABDM framework provides most of them) but translating those policy answers into code that handles every edge case takes significantly longer than the happy-path implementation.
Provisioned concurrency is often presented as a simple Lambda configuration option, but managing it correctly in a CI/CD context requires discipline. Provisioned concurrency is attached to a specific Lambda function version — meaning deployments that create new versions do not automatically carry the provisioned concurrency configuration forward. We experienced one production incident from this exact issue and subsequently built a CDK construct that manages provisioned concurrency as part of the deployment pipeline, with blue/green traffic shifting that does not cut over until provisioned concurrency is active on the new version.
The FHIR transformation pipeline is harder to test than almost any other software component we've built. Clinical correctness is not a property you can unit test with a simple assertion — it requires clinical domain experts to review transformation outputs for a representative sample of real HL7 messages. We built a testing harness that feeds real (de-identified) HL7 messages from partner hospitals through the transformation pipeline and presents the FHIR output for clinical review. This review process took longer than the transformation code itself, and that time was well spent.
Finally, the ABDM sandbox environment itself is not always stable — a common challenge when working against national government API infrastructure that is itself under active development. We built a mock ABDM gateway into the test infrastructure early in the project, which paid dividends when the sandbox environment had a two-week outage during our final certification preparation sprint. The team continued integration testing uninterrupted using the mock.
Related Case Studies
Real-Time Logistics Platform
Event-driven shipment tracking with IoT GPS ingestion, geofencing, and automated dispatch on AWS.
Serverless E-Commerce Backend
Hyperlocal grocery delivery with Step Functions order orchestration and Razorpay UPI integration.
Document Processing Pipeline
Automated insurance claims verification using Textract OCR and Step Functions workflows.
Work with Xortrix AI
Building healthcare infrastructure or a compliance-sensitive API platform?
We have deep experience with serverless architectures, PHI data security, FHIR and healthcare interoperability standards, and the specific requirements of operating on India's ABDM digital health stack. If you are building in this space, we would like to talk.
Get in touch