Location: Remote. 30-40% travel to HQ, engineering sites, or customer locations.
ABOUT THIS ROLE
We are looking for a Sr Software Solutions Architect to own the target-state architecture of the platforms that run central fill pharmacy operations, and to stay in the code while doing it. Central fill is high-volume prescription fulfillment: orders route from retail, health-system, and mail-order pharmacies into a centralized facility where medication is filled, packaged, verified, labeled, and shipped back at a scale no individual pharmacy could sustain, and our Axona platform runs that operation end to end. Axona is the .NET and C# microservice platform, the Kafka event streams and MassTransit workflows behind those operations, and the React.js and React Native interfaces operators use while equipment is running, while Axona Middleware is the software that commands conveyors, diverters, programmable logic controllers (PLCs), vision systems, and label printers over MQTT and gRPC; this role covers both. It is an architecture role with hands on the keyboard, roughly a third of your time, spent on reference implementations, prototypes and spikes that settle open questions with evidence rather than opinion, and the design and code reviews that matter, and you will not own a feature backlog or manage people. Our Principal Engineers own the deepest engineering within their tier and our Lead Engineers own delivery of individual domains; you own the architecture they build against, including service and domain boundaries, API and event contracts, the tenancy model, deployment topology, front-end and back-end contract discipline, integration standards, non-functional requirements, and the sequencing of the modernization roadmap, and you are accountable for whether those pieces add up to one coherent platform.
You need to be credible on both tiers, and the user interface tier is not optional: a central fill site runs continuous shifts against fixed courier cutoffs, and a screen that quietly stops updating is not a cosmetic defect, it is a technician standing at a station without instruction and a shipment that misses its truck. Real environments make it harder, because networks drop, controllers reboot, and responses arrive late, out of order, or twice, and here a repeated message can mean a second diverter command or a duplicate label rather than a minor inconvenience. The platform also runs three ways, installed at a customer site, in a customer-managed cloud, and as a multi-tenant service Client hosts, and every service, event stream, and screen sits on a path that can carry protected health information (PHI). If you want to set architectural direction for pharmacy automation platforms where software decisions have physical and clinical consequences, and you want to keep building while you do it, this is a good fit.
Key Responsibilities
Target-State Architecture Across Axona and Axona Middleware
- Own the target-state architecture for both platforms and the reference architecture that describes it: service and domain boundaries, data ownership, layering rules, anti-corruption layers to legacy components, and the seams along which tightly coupled components get decomposed where the operational payoff is real rather than theoretical.
- Define how the application tier and the middleware tier meet: which system of record owns which state, how equipment and station state reaches the application platform, how operator intent reaches a device, and what the failure semantics are on each side of that boundary when a device, a dependency, or a database does not answer.
- Sequence the modernization roadmap into releasable increments that keep existing customer operations running, and make explicit the consistency model, latency budget, and availability target for every significant workflow instead of leaving those to whichever library happened to be used.
- Design for one codebase that runs in Client-hosted cloud, in customer-managed cloud, on customer premises, and at the edge, so deployment differences stay in configuration rather than in forked logic or customer-specific engineering.
Application and Front-End Architecture: React.js, React Native, and Real-Time Operator Interfaces
- Own front-end architecture across React.js web and React Native, including React Native Web: application structure, feature boundaries, routing, code splitting, module and package strategy, and the shared foundation that keeps desktop, tablet, handheld, and cart-mounted experiences consistent rather than three separately drifting applications.
- Set the standards that hold the front end together: TypeScript and modern JavaScript (ES6 and later) conventions, React internals discipline covering component lifecycle, reconciliation and rendering behavior, hooks semantics and dependency correctness, memoization and context boundaries, and the design and governance of a shared, configurable, themeable component library with accessibility semantics and responsive layouts grounded in strong HTML5 and CSS3 fundamentals.
- Own state architecture across the client tier: Redux Toolkit slice design, normalized state shape, selector and memoization strategy, entity adapters, and clear rules for global versus local versus server-cached state, with Redux-Saga standards for API orchestration, sequencing and parallelism, cancellation, debouncing, retry and backoff, race handling, and predictable error propagation.
- Architect the real-time experience over WebSocket and streaming transports for live order, station, and equipment status: subscription lifecycle, reconnection with backoff, client-side ordering and deduplication, state reconciliation after a gap, and update coalescing so a high-frequency device stream does not overwhelm rendering, plus the behavior operators see when connectivity to the cloud is lost and the line keeps running.
- Establish client-side integration and quality standards: typed API clients and data transfer objects, token lifecycle and refresh, a consistent error taxonomy, loading and error states, optimistic updates with rollback, front-end performance budgets covering bundle size, re-render behavior, network waterfalls, and memory growth across long operator shifts, and test strategy using Jest with React Testing Library or React Native Testing Library.
API, Integration, and Contract Architecture
- Define the contract discipline that lets the tiers evolve independently: versioned REST and gRPC APIs, shared TypeScript types, backward-compatible event schemas, schema registry and deprecation policy, and consumer-driven contract testing enforced in the pipeline rather than agreed in a meeting.
- Own the integration architecture to pharmacy, order management, ERP, and analytics systems, including HL7 v2, FHIR, and EDI ingestion from systems such as Epic and Cerner, and modernize those integrations toward API-first and event-driven patterns while maintaining interoperability with legacy interfaces customers still depend on.
- Establish the API-first standards, gateway and edge strategy, backend-for-frontend patterns where they earn their place, and the extension points that let integrations, partners, and future products build on the platform without customer-specific forks.
Event-Driven, Messaging, and Device Communication Architecture
- Own the messaging architecture across both tiers: Kafka for durable event streaming, MassTransit for workflow orchestration including sagas and state machines for long-running order, packaging, labeling, and fulfillment workflows, gRPC for low-latency service calls, and MQTT for device and controls communication, with direction on topic and partition design, key selection, consumer semantics, ordering guarantees, quality of service levels, retention, and backpressure.
- Set the IoT communication architecture for a distributed fleet of machines, controllers, and workstations across many customer sites: protocol trade-offs (MQTT, AMQP, gRPC streaming, OPC UA, and existing industrial interfaces), device identity, provisioning and lifecycle management, twin or shadow state with desired and reported reconciliation, store and forward buffering, local autonomy so a packaging line keeps running when the cloud is unreachable, and controlled catch-up on reconnect.
- Establish platform-wide standards for guaranteed delivery and idempotency: delivery semantics chosen per flow (at-most-once, at-least-once, effectively-once), idempotency keys and deduplication windows, transactional outbox and inbox, saga and compensating action patterns, retry with poison message detection and dead letter handling, ordering only where the workflow requires it, and reconciliation and drift detection between platform state and physical device state, so a duplicate message never produces a duplicate order, label, or diverter command.
- Govern schema and contract versioning across mixed firmware and mixed platform versions with staged rollout and rollback, and define the command and control semantics over asynchronous transport: correlation identifiers, acknowledgement, timeouts, cancellation, stale command expiry, and clock skew handling.
Multi-Tenancy, Deployment Topology, and Platform Delivery
- Own the tenancy model across data, messaging, compute, configuration, and secrets, with boundary rules that make cross-tenant access structurally impossible rather than policy-dependent, plus tenant-aware routing, rate limiting, noisy-neighbor protection, and per-tenant capacity and cost visibility.
- Define the deployment topologies the platform supports and what differs between them, so config-driven tenant, site, and device onboarding makes adding a customer an operation rather than an engineering project, and design the migration paths that move existing single-tenant installations onto the multi-tenant platform without disrupting live pharmacy operations.
- Set container and Kubernetes strategy for cloud and constrained on-premise or edge environments: hardened images, resource limits, graceful shutdown for in-flight device commands, Helm packaging, GitOps delivery, infrastructure as code, canary deployment and rollback, disaster recovery posture, and pipelines covering automated testing, security scanning, and software bill of materials generation.
Data Architecture and the Analytics Foundation
- Own the data architecture across operational stores, event streams, telemetry, and analytics: system-of-record boundaries, persistence and zero-downtime migration strategy, retention and archival, lot-level and audit traceability, and the tenant-scoped path from operational events to reporting and analytics without coupling analytics workloads to operational latency.
- Define the telemetry and event model well enough that operational data is usable downstream: stable semantics, cardinality discipline, and consistent identifiers for device, site, tenant, order, and workflow across both tiers.
Security, PHI Protection, and Regulatory Architecture
- Own the platform security architecture on a Zero Trust posture that treats the plant network as untrusted: per-device identity with certificate-based authentication and mutual Transport Layer Security, MQTT broker and topic-level access control scoped by tenant and site, protection against replay and command injection on downlink paths, service-to-service security through mutual TLS or a service mesh with short-lived workload identity and no shared long-lived credentials, and centralized secrets and key management with automated rotation.
- Define the identity and access architecture across the platform, including workforce and operator identity, AWS Amplify and Amazon Cognito user and identity pools, token lifecycle and refresh, multi-factor authentication, OAuth 2.0 and OpenID Connect federation with customer identity providers, role-based access control, and authorization enforced server-side rather than in the client.
- Design PHI handling to HIPAA Security Rule expectations: encryption in transit and at rest, unique user and service identification, integrity controls, tamper-evident audit logging of PHI access, and data minimization through de-identification, tokenization, or field-level encryption so PHI reaches only the services and screens that require it.
- Keep PHI out of logs, traces, metrics, error payloads, client-side storage, dumps, and non-production environments through automated checks; define retention, secure deletion, backup encryption, and disaster recovery consistent with business associate agreement obligations; and embed HIPAA, HITRUST, NIST Cybersecurity Framework, and medical device cybersecurity expectations into design from the start with threat modeling, software bill of materials, vulnerability management, and audit-ready traceability.
Observability and Operational Resilience by Design
- Define the observability architecture so a single order or operator action can be followed with OpenTelemetry from a screen or a device event through every service and event hop and back to a device command, extended into the client tier through error tracking and real user monitoring, with structured logging, metrics, and per-device, per-site, and per-tenant health scoring.
- Set the resilience patterns the platform is built on: health checks, circuit breakers, retry and dead letter handling, graceful degradation, and fault isolation so a single failing device, integration, screen, or tenant does not degrade the platform, together with the service level objectives, dashboards, and alerting that let support teams see a degraded line or tenant before the customer calls.
- Lead architecture-level incident review and the corrective engineering that prevents recurrence, and feed what production actually does back into the target-state architecture.
AI-Ready Foundation and AI-Assisted Engineering
- Architect the foundation for AI-enabled operational capabilities and future agent-based services by exposing clean APIs, event streams, and telemetry that monitoring, predictive maintenance, anomaly detection, intelligent alerting, and workflow optimization agents can consume, with the tenancy, PHI, auditability, and human-in-the-loop controls a regulated setting requires.
- Use Claude Code as a working part of the daily engineering toolchain for prototyping, reference implementations, refactoring, test generation, code review, and documentation, and demonstrate the practice credibly to other engineers.
- Own the internal scaffolding and guardrails that make AI-assisted development effective and safe across the engineering organization: repository and project context files, custom commands, subagents, skills, hooks, and Model Context Protocol integrations, with policy covering human accountability, traceability, licensing hygiene, secret handling, and validation expectations for regulated software, and measure where the assistance genuinely improves cycle time.
Architecture Governance and Technical Leadership
- Run the architecture practice: design reviews, architecture decision records, reference implementations, threat modeling, non-functional requirements, fitness functions and automated quality gates, and a technology selection process with explicit trade-offs, exit criteria, and a standard for when a deviation is justified.
- Set the test strategy the platform is held to across unit, integration, contract, front-end component, hardware-in-the-loop, load, soak, and chaos testing, with static and dynamic analysis, dependency and container scanning, and secret detection in the pipeline.
- Partner with Principal and Lead Engineers so the architecture is shaped by production experience rather than imposed on it, mentor senior and staff engineers across distributed systems, front-end architecture, security, and production ownership, and make technical risk, effort, and operational impact legible to product, engineering, and executive stakeholders.
To Be Successful in This Role, You Will Need:
- 14 or more years of professional software engineering experience, with 6 or more years in an architect or equivalent platform-wide technical role, and demonstrated architecture ownership of a production platform spanning both a service tier and a user interface tier rather than one of them.
- Deep, current, hands-on expertise in .NET and C# including modern async programming, with proven experience designing and operating microservices or modular architectures at production scale and demonstrated results in low-latency, high-throughput concurrent processing.
- Strong hands-on React.js and React Native experience with genuine understanding of React architecture, component lifecycle, and rendering behavior, plus expert TypeScript and modern JavaScript (ES6 and later), and the ability to set front-end architecture and standards rather than review them from a distance.
- Production experience with Redux Toolkit for shared state management and Redux-Saga for API orchestration and side effects, demonstrated design of reusable, configurable, accessible component libraries and responsive layouts grounded in strong HTML5 and CSS3 fundamentals including through React Native Web, and testing practice with Jest and React Testing Library or equivalent.
- Experience architecting WebSocket or equivalent real-time interfaces for live operational status, including subscription lifecycle, reconnection, client-side ordering and deduplication, and state reconciliation.
- Production experience with Kafka or equivalent event streaming, with MassTransit or an equivalent workflow orchestration framework including sagas or state machines, and with gRPC and MQTT, with a working understanding of delivery guarantees, ordering, and backpressure in each.
- Substantial IoT or connected device platform experience: device identity and provisioning, twin or shadow state, fleet-scale connection management, offline and intermittent connectivity, telemetry pipelines, and over-the-air configuration or firmware rollout.
- Deep practical knowledge of guaranteed delivery and idempotency: at-least-once and effectively-once processing, deduplication, transactional outbox, partitioning and ordering, retry and dead letter handling, and reconciliation of divergent state.
- Experience architecting multi-tenant SaaS platforms that also ship as customer-deployed software, with strong containerization and Kubernetes practice, infrastructure as code, continuous delivery, and command of OpenTelemetry and service level objectives.
- Demonstrated depth in application and platform security as a practitioner rather than a reviewer: device and machine identity, certificate-based authentication and mutual Transport Layer Security, OAuth 2.0 and OpenID Connect, AWS Amplify and Amazon Cognito or equivalent identity platforms, service-to-service authorization, MQTT broker and topic-level access control, secrets management, and threat modeling, with working knowledge of HIPAA Security Rule requirements as they apply to software design and PHI.
- Working experience using Claude Code or comparable AI coding tools as part of a professional engineering workflow, with a clear view of where they add value and where they need supervision.
- The ability to move between writing a reference implementation, arbitrating a design disagreement between teams, and framing an architectural trade-off and its cost for executives, with the judgment to choose the simple design when it is sufficient and the discipline to leave working systems alone.
Preferred Qualifications
- Experience in healthcare, medical device, pharmacy, or industrial automation, or another regulated domain.
- Direct experience with software that integrates with PLCs, conveyors, vision systems, or label printers, and with operator-facing interfaces where real-time status and error recovery matter more than visual novelty.
- Experience leading the modernization of an installed base of customer-deployed software toward a SaaS and multi-tenant model without disrupting live operations.
- Familiarity with hybrid and edge constraints: limited connectivity, customer-controlled infrastructure, and customer security review processes.
- Experience with HL7 v2, FHIR, or EDI pharmacy integrations, and with AMQP, AWS IoT Core, Azure IoT Hub, or operating an MQTT broker fleet.
Never miss an opportunity! Create an alert based on the job you applied for.