Open to healthcare IT & Epic analyst roles

Healthcare IT professional.
Software that supports care.

Master’s in Computer Science. Spring Boot, Epic FHIR, EHR analytics, and the production cloud infrastructure to deploy it safely.

Currently
Latest
HealthHub, Epic FHIR Portal
Also live
Caelis Health, Clinical Analytics
Based in
Richmond, VA
Open to relocation
Epic FHIR
HL7 FHIR R4
SMART on FHIR
HIPAA
Spring Boot
Java 17
EC2
S3
Lambda
RDS
CloudFront
SNS
IAM
VPC
CloudWatch
ECS
ECR
Route 53
Nginx
Let's Encrypt
ALB
Healthcare IT

Clinical software, built to learn
the Epic ecosystem from the inside.

01

Caelis Health

Clinical Analytics Platform

Spring Boot JPA Chart.js Docker

A multi-page clinical analytics dashboard simulating EHR operational metrics: 500 patients, 12 providers, 2,000 visits across 6 departments. Tracks wait times, no-show rates, top diagnoses, top medications, and department-level visit volume — the kind of data hospital operations leaders actually look at every day.

Pages
Overview5 KPIs · 7 charts
·
Patients500 records · search
·
Visits2,000 records · wait time
·
Clinicaldiagnoses · meds
Java 17 · Spring Boot · Spring Data JPA with JOIN FETCH for eager loading · Thymeleaf fragment-based layouts · Chart.js for interactive visualizations · H2 in PostgreSQL mode · deployed via Docker + Coolify on a Contabo VPS with Traefik + Let's Encrypt.
Why these choices
Multi-page Spring MVC over single-page React

Real EHR analyst tools are server-rendered for performance and accessibility. Thymeleaf + Spring keeps the codebase tight and renders the dashboard in under 100ms even with thousands of rows — no client-side hydration cost.

Native SQL aggregations over in-memory filtering

Wait time, no-show rate, and visits-per-day are calculated with native GROUP BY queries against H2 (in PostgreSQL mode). The same SQL would run unchanged against a real Postgres or Oracle EHR data warehouse — which is what hospitals actually use.

JOIN FETCH over lazy loading

With open-in-view: false, lazy associations would throw exceptions during Thymeleaf rendering. Custom findAllWithRefs queries eagerly fetch Patient + Provider in one round-trip, eliminating N+1 queries on the visit log.

Operational EHR metrics: wait time (arrival → seen), no-show rates by department, visit volume distribution
Spring Data JPA lifecycle — open-in-view: false, JOIN FETCH for eager loading, transaction boundaries
Production deploy without AWS: Docker multi-stage build, Coolify orchestration, Traefik reverse proxy, automatic SSL
02

HealthHub

Epic FHIR Patient Portal

Epic FHIR SMART on FHIR OAuth2 / PKCE HAPI FHIR

A patient-facing portal that authenticates against Epic's FHIR R4 sandbox using SMART-on-FHIR with OAuth2 + PKCE, then retrieves the patient's demographics and clinical data via Epic's developer APIs. Built to learn the Epic developer ecosystem and healthcare interoperability standards firsthand before applying for analyst roles.

Auth Flow
User/login
HealthHubSpring Security
Epic AuthorizeSMART on FHIR
Epic FHIR R4Patient / Observation
Spring Boot · Spring Security OAuth2 Client with PKCE (public client) · HAPI FHIR for resource parsing · Epic's developer sandbox at fhir.epic.com.
Why these choices
SMART on FHIR over a custom OAuth flow

SMART on FHIR is the standard Epic and every major EHR vendor use for patient-app authorization. Using the standard means the same code would work against Cerner, Allscripts, or Athenahealth sandboxes with only a configuration change.

PKCE with a public client over a confidential client secret

For browser-launched patient apps Epic requires PKCE. A static client secret can't be stored in a browser app without exposure, so PKCE provides one-time proof of possession during the code exchange.

HAPI FHIR library over raw JSON parsing

HAPI gives strongly-typed FHIR resources (Patient, Observation, MedicationRequest) with validation built in. Faster to develop against and forward-compatible with FHIR R4 → R5.

Epic developer ecosystem: app registration at fhir.epic.com, sandbox propagation, scope strings
FHIR R4 resources: Patient, Observation, MedicationRequest, AllergyIntolerance — the building blocks of clinical interop
OAuth2 + PKCE flow end to end: authorize → code exchange → access token → resource fetch
Cloud Engineering

Production AWS, end to end
and all defined in code.

01

Containerized CI/CD Pipeline

Docker + ECS Fargate + GitHub Actions

ECS ECR CI/CD

Took the Job Tracker from manual EC2 deployment to a fully automated container pipeline. Docker image builds on every push, gets stored in ECR, and deploys to ECS Fargate — zero SSH, zero downtime, zero servers to manage.

Architecture
git push Developer
webhook
CI/CD Pipeline
GitHub Actions Build + test + push
image
AWS
ECR
ECS Fargate
Each commit SHA is used as the image tag for full traceability. Rollback = redeploy a previous tag.
Why these technologies
ECS Fargate over EC2 for containers

EC2 means patching the OS, monitoring disk space, managing Docker daemon, and scaling manually. Fargate removes all of that — you define CPU/memory and AWS handles the rest. The tradeoff is less control over the host, but for a web app that's a good trade.

ECR over Docker Hub

ECR is private by default and in the same AWS network as ECS, so image pulls are fast and free. Docker Hub has rate limits on free accounts (100 pulls/6 hours) which can break CI/CD pipelines.

GitHub Actions over Jenkins or CodePipeline

GitHub Actions lives where the code lives — no separate CI server to manage. AWS CodePipeline would add another AWS service to maintain. Jenkins would need its own EC2 instance. GitHub Actions is free for public repos and has official AWS actions.

Docker multi-layer caching — dependencies installed before code for fast rebuilds
GitHub Actions CI/CD — auto deploys on every push to main, zero manual steps
Evolution from manual EC2 + systemd to serverless Fargate containers
02

Terraform Infrastructure

Infrastructure as Code

Terraform ECS ECR

Took everything I built by hand in the AWS Console and defined it as code. One command creates the entire infrastructure — ECR, ECS Fargate, IAM roles, security groups, CloudWatch logging. One command tears it all down. Version-controlled, reviewable, reproducible.

Architecture
.tf files 8 files, 7 resources
plan → apply
Terraform creates on AWS
ECS Cluster
ECS Service
Task Definition
ECR Repository
IAM Role + Policy
Security Group
CloudWatch Logs
State file tracks every resource. terraform destroy removes all 7 in the correct dependency order.
Why these technologies
Terraform over CloudFormation

CloudFormation is AWS-only. Terraform works with AWS, GCP, Azure, and 3,000+ providers. If I ever work with multi-cloud or non-AWS services, the same tool and language apply. The tradeoff is that CloudFormation has tighter AWS integration and catches some errors earlier.

IaC over console clicking

The console is fine for learning, but infrastructure built by hand is undocumented, unreproducible, and unauditable. With Terraform, the code IS the documentation. Changes go through pull requests. If a region goes down, terraform apply rebuilds everything elsewhere in minutes.

Separate repo over embedding in the app repo

Infrastructure and application code have different lifecycles. App code changes daily; infrastructure changes rarely. Separate repos mean separate CI/CD pipelines, separate permissions, and clearer ownership. The tradeoff is managing two repos instead of one.

Declarative IaC — define what you want, Terraform figures out how to build it
Plan before apply — always preview changes before they hit production
State management — Terraform tracks resources and detects drift
03

Snip — URL Shortener

Full-Stack Production App on AWS

ECS RDS Terraform ALB

A production URL shortener with click analytics. Paste a long URL, get a short trackable link. Every click is logged — timestamp, IP, referrer — and displayed on an analytics dashboard. Built with Java Spring Boot, deployed on ECS Fargate behind an Application Load Balancer with HTTPS. Entire infrastructure — 34 AWS resources — defined in Terraform.

Architecture
User HTTPS
AWS VPC (us-east-2)
Public Subnet
ALB HTTPS:443
ECS Fargate Spring Boot
port 5432
Private Subnet
RDS PostgreSQL No public access
34 AWS resources defined in Terraform. GitHub Actions builds + deploys on every push to main. Route 53 → ALB → ECS → RDS chain with security group isolation at every layer.
Why these technologies
Application Load Balancer over exposing ECS directly

ECS Fargate tasks get public IPs but no SSL support. The ALB terminates HTTPS, runs health checks, and allows scaling to multiple containers without changing DNS. Without it, there's no HTTPS, no health monitoring, and no zero-downtime deployments.

Java Spring Boot over Python FastAPI

Most enterprise cloud and backend roles use Java. Spring Boot has built-in dependency injection, JPA for database access, and Thymeleaf for server-side rendering — a complete production framework. The tradeoff is a heavier JAR and longer build times vs FastAPI's simplicity.

RDS in a private subnet over a public database

The database has no public IP. Only the ECS security group can reach port 5432. Even with valid credentials, external connections are blocked at the network level. Defense in depth — security groups + private subnet + VPC isolation.

VPC design with public/private subnets — ALB in public, RDS in private, security group chaining
ALB health checks and HTTPS termination — SSL at the load balancer, plain HTTP internally
Spring Data JPA entity lifecycle — managed vs detached entities and transaction boundaries
Enoch Kumanyenu
About

I learn by shipping.

Healthcare IT professional with a Master’s in Computer Science from Virginia Commonwealth University (3.8 GPA) and a B.S. from Valley View University. Before clinical software, I spent a year at EFT Corporation on backend systems for live financial transactions: authentication, audit logging, and SQL optimization across thousands of daily operations.

That production discipline now applies to healthcare. Caelis Health is a multi-page clinical analytics dashboard with 500 patients, 12 providers, and 2,000 visits across six departments. HealthHub authenticates against Epic’s FHIR R4 sandbox using SMART on FHIR with OAuth2 PKCE. Every project here is live. This portfolio itself runs on a Linux VPS with Nginx, Let’s Encrypt SSL, and Route 53 DNS, auto-deployed from GitHub. Currently a teaching assistant at Project STEM, supporting 30+ students in Java and Python.

Healthcare IT

Epic FHIR SandboxHL7 FHIR R4SMART on FHIROAuth2 PKCEHAPI FHIREHR AnalyticsHIPAA FundamentalsClinical Workflows

Languages & Frameworks

Java 17Spring BootSpring SecuritySpring Data JPAThymeleafPythonSQLFastAPIPostgreSQL

Cloud & DevOps

AWS ECS FargateRDSALBRoute 53VPCIAMCloudWatchTerraformDockerGitHub ActionsLinuxNginx
Contact

Let's build something.

Open to Healthcare IT roles like Epic Project Manager, Technical Solutions Engineer, and EHR Analyst, as well as cloud engineering positions where both skills apply. If you think I'd be a good fit, reach out.