Cloud-Native Healthcare Software Architecture

Explain the responsibility boundaries among an application process, a container image and runtime, and Kubernetes orchestration in the local lab.

Define the actors, patient-data flow, and functional acceptance criteria for the evolving Nordic healthcare scenario.

Build a multi-stage Dockerfile for an ASP.NET Core API.

Evaluate a container image for unnecessary layers, excessive privileges, and known vulnerabilities.

Create a local Kubernetes cluster on Windows using Docker Desktop with kind or k3d.

Deploy an ASP.NET Core API to the local cluster using Kubernetes manifests.

Diagnose a deliberately broken deployment using kubectl, events, logs, and container state.

Map local Kubernetes components to their closest AKS equivalents.

Translate a healthcare workflow into measurable quality-attribute scenarios.

Create C4 context and container diagrams for a patient-data system.

Record a consequential architecture choice in an Architecture Decision Record.

Identify bounded contexts from a healthcare workflow using domain-driven design.

Choose between a modular monolith and microservices for a stated set of constraints.

Choose between synchronous and asynchronous communication for a specific interaction.

Identify temporal, runtime, and organizational coupling in a proposed design.

Define an architecture fitness check for one critical quality attribute.

Configure a Kubernetes Deployment to perform a controlled rolling update.

Expose an internal workload using Services and route local traffic through an Ingress.

Separate runtime configuration from an image using ConfigMaps and Secrets.

Configure startup, readiness, and liveness probes for an ASP.NET Core service.

Set CPU and memory requests and limits from observed workload behavior.

Configure horizontal pod autoscaling for a measurable workload signal.

Provision persistent storage for a stateful local workload.

Apply and verify service-to-service NetworkPolicies in a local cluster with a compatible networking implementation.

Explain how Helm combines chart templates, values, and release state to produce Kubernetes resources.

Package the patient-data API as a reusable Helm chart.

Create environment-specific Helm values without duplicating chart templates.

Validate rendered Helm manifests with linting, schema checks, and policy checks.

Trace build, test, packaging, and deployment flow through an Azure Pipelines YAML definition.

Write a CI pipeline that builds, tests, scans, and packages a .NET container.

Design a deployment pipeline with approvals, health verification, rollback, and immutable artifact promotion.

Analyze a small modular Bicep deployment to predict dependencies, idempotent updates, parameters, outputs, and drift limitations.

Select appropriate FHIR resources and references for a patient-care workflow.

Perform version-aware FHIR REST interactions using ETags and conditional requests.

Construct a FHIR transaction Bundle for an atomic multi-resource update.

Formulate FHIR searches using parameters, chaining, includes, and pagination.

Create a FHIR profile that constrains a resource for a local requirement.

Apply coded terminology bindings to a clinical data element.

Validate a FHIR resource against profiles and implementation-guide rules.

Consume and produce FHIR R4 resources from .NET using a FHIR SDK.

Interpret HL7 v2 message structure, delimiters, segments, fields, repetitions, and components.

Extract patient, encounter, and observation data from common ADT and ORU messages.

Generate appropriate HL7 acknowledgment responses for successful and failed processing.

Handle HL7 v2 null values, escaping, timestamps, and repeating fields without losing meaning.

Build a local adapter that parses and validates an HL7 v2 message.

Map an HL7 v2 ADT message to FHIR resources while preserving source provenance.

Test an HL7-to-FHIR transformation using representative and malformed message fixtures.

Diagnose a failed interface message from its payload, acknowledgment, and processing logs.

Explain how the openEHR reference model and archetype model separate stable structures from clinical knowledge.

Interpret constraints in an openEHR archetype and operational template.

Construct a Composition that conforms to a supplied openEHR template.

Submit and retrieve versioned Compositions through an openEHR REST API.

Write an AQL query for selected clinical elements in a patient record.

Relate Better platform services and APIs to standard openEHR concepts.

Define a semantic mapping between a FHIR resource and an openEHR Composition.

Assess the governance impact of changing an archetype or template.

Assign a system of record for each data category in a multi-standard healthcare platform.

Design anti-corruption layers at boundaries between FHIR, HL7 v2, openEHR, and internal domains.

Design patient-identity matching with explicit handling of uncertain matches.

Model and propagate provenance metadata as clinical data moves between FHIR, HL7 v2, openEHR, and internal representations.

Design an idempotent ingestion flow for duplicated or reordered healthcare messages.

Apply the transactional outbox pattern to publish changes without a distributed transaction.

Define a compatibility strategy for evolving messages, events, and APIs.

Design a data-minimizing read model for presenting a longitudinal patient view to an Angular application.

Create a GDPR data-flow inventory that identifies personal and special-category data, processing purposes, recipients, and controller, processor, or sub-processor roles.

Perform a lightweight data protection impact assessment for a high-risk patient-data flow.

Apply data minimization, purpose limitation, and retention rules to a proposed design.

Design user authentication for an Angular application and its APIs using OpenID Connect Authorization Code flow with PKCE.

Evaluate a patient-record authorization decision using role, care relationship, consent, purpose of use, and break-glass conditions.

Threat-model a patient-data flow using STRIDE and prioritize mitigations for trust-boundary, encryption, and key-management risks.

Design a tamper-evident audit trail for access to clinical data.

Map applicable GDPR, EHDS, and NIS2 obligations to concrete architecture controls and evidence.

Instrument a cross-service request with OpenTelemetry traces and correlation context.

Design structured logs that support diagnosis without exposing patient data.

Define service-level indicators and objectives for a patient-data workflow.

Create an actionable alert from an SLO and an observed failure mode.

Implement bounded timeouts and cancellation propagation for a dependency call.

Configure jittered retries and circuit breaking while preventing retry storms and duplicate side effects.

Use load-test evidence to identify a capacity bottleneck.

Define backup, restore, RPO, and RTO requirements for a clinical data store.

Distinguish customer and Azure responsibilities for the AKS control plane, nodes, workloads, patching, and upgrades.

Choose an AKS network topology for private healthcare workloads and controlled ingress and egress.

Design boundaries among Entra ID, Kubernetes RBAC, AKS Workload Identity, users, pipelines, and services.

Select an Azure data service from consistency, query, availability, compliance, and operational requirements.

Design secret and configuration delivery using Key Vault, App Configuration, and workload identity.

Design a zone- and region-aware deployment topology from stated availability and recovery targets.

Author and statically validate a modular Bicep blueprint for an AKS-based platform.

Evaluate an AKS design for capacity, cost drivers, operability, security, and production-readiness gaps.

Revise the initial C4 diagrams to reflect implemented boundaries, trust zones, data stores, and healthcare-standard interfaces.

Consolidate at least three consequential decisions into a coherent ADR set linked to quality-attribute scenarios.

Connect the previously built components into a local HL7-to-FHIR patient-data vertical slice.

Introduce a controlled failure and diagnose it from logs, metrics, traces, and Kubernetes evidence.

Audit the capstone architecture against STRIDE findings and European healthcare privacy requirements.

Execute a failure-recovery exercise to validate restore procedures, recovery point objectives, and recovery time objectives.

Create an AKS target-state blueprint and phased migration roadmap from the local design.

Defend the architecture against alternative designs using evidence, risks, and explicit trade-offs.