Open to healthcare IT, Epic & imaging analyst roles

Healthcare IT professional.
Software that supports care.

Master’s in Computer Science. I build with Epic FHIR, HL7, and healthcare data, focused on Epic, EHR, and imaging (PACS) systems.

Currently
Latest
Aperture, Browser DICOM Viewer
Also live
Phanera · HealthHub · Caelis
Based in
Richmond, VA
Open to relocation
Epic FHIR
HL7 FHIR R4
SMART on FHIR
DICOM
PACS
Epic Radiant
HIPAA
EHR Analytics
Revenue Cycle
SQL
Java 17
Spring Boot
Python
Docker
Healthcare IT

Four healthcare apps, shipped live
from price transparency to medical imaging.

01

Phanera

Hospital Price Transparency Platform

Streaming JSON PostgreSQL CMS MRF Data Pipeline

Since 2021, U.S. hospitals must publish their full price lists — but they bury them in unreadable 600 MB files. Phanera parses those federal price-transparency files from 11 Richmond hospitals and turns them into a simple tool: pick a procedure, see what every hospital charges, ranked cheapest to most expensive. Same procedure, same city, prices that differ by thousands.

Data Pipeline
11 hospital MRFsCSV + JSON
Parsersfilter to 22 CPT codes
PostgreSQL~14k price points
Ranked comparecash vs negotiated
Java 17 · Spring Boot · Jackson streaming parser (handles a 648 MB file without loading it into memory) · Apache Commons CSV · PostgreSQL · deployed on Docker + Coolify + Traefik.
Why these choices
Streaming JSON over loading the whole file

VCU's price file is 648 MB; reading it whole would exhaust the heap. A token-by-token Jackson streaming parser walks to the charge array and reads one item at a time, filtering to the ~22 shoppable procedures — bounded memory regardless of file size.

Two parsers cover ~19 hospitals

HCA and VCU publish the identical CMS v3.0.0 JSON shape, so one JSON parser plus one CSV parser (Bon Secours) cover every system. The tedious per-hospital normalization is the moat — funded players stay shallow nationally; Phanera goes deep on one metro.

Filter at parse time

Raw files hold tens of thousands of rows (every screw, drug, supply). Keeping only rows whose CPT/HCPCS code is a shoppable procedure means the database holds a few thousand useful rows, not millions.

Healthcare revenue-cycle domain: charge masters, CPT/HCPCS codes, payer-negotiated rates, gross vs cash vs negotiated pricing
CMS Hospital Price Transparency Rule (45 CFR 180) — the data, the formats, the compliance
Streaming large-file ingestion + multi-format normalization into one schema
02

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
03

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
04

Aperture

Browser-Based DICOM Viewer

DICOM Canvas Client-Side Window / Level

Radiology runs on DICOM, the file every CT, MRI, and X-ray produces. Aperture opens a real .dcm study entirely in the browser: it parses the DICOM header, rescales the stored pixels to Hounsfield units, and renders the 16-bit image to a canvas with interactive window/level, zoom, pan, and CT presets, the same controls a radiologist uses at a PACS workstation. A synthetic head-phantom study is generated in-page, so it works with one click and no upload.

Render Pipeline
.dcm filedrag-drop or in-page
DICOM parserVR + transfer syntax
Modality LUTraw·slope + intercept
Window / LevelVOI → Canvas
Vanilla JavaScript · custom DICOM Part 10 parser (Explicit & Implicit VR Little Endian, sequence skipping) · modality LUT + VOI LINEAR windowing · HTML5 Canvas · zero dependencies, fully client-side so no image ever leaves the browser.
Why these choices
Fully client-side, nothing uploaded

Medical images are protected health information. Parsing, windowing, and rendering every pixel locally means there is no server to store or leak data, the safe default for anything imaging-related.

A hand-written DICOM parser, not a black-box library

Reading the header directly (group/element tags, value representations, the transfer-syntax switch, sequence skipping) is the clearest way to show I understand the DICOM data model that PACS, VNAs, and Epic Radiant are built on.

Window/level applied on the modality LUT

Stored pixels are first rescaled to Hounsfield units (slope and intercept), then windowed with the DICOM VOI LINEAR formula. That is the exact order a diagnostic viewer uses, which is why the Brain, Bone, and Lung presets land on the right tissues.

DICOM data model: tags, VRs, transfer syntaxes, photometric interpretation, rescale slope/intercept, VOI window center/width
Why imaging is stored as 12/16-bit and displayed through a window, not as an ordinary 8-bit image
The imaging IT chain end to end: modality → DICOM → PACS/VNA → viewer, and where an analyst sits in it
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. Phanera parses 11 hospitals’ federal price-transparency files into a live price-comparison tool. Caelis Health is a multi-page clinical analytics dashboard across 500 patients and 2,000 visits. HealthHub authenticates against Epic’s FHIR R4 sandbox using SMART on FHIR with OAuth2 PKCE. All three are live, each deployed on a Linux VPS with Docker, Traefik, and auto-issued SSL, shipped from GitHub. Currently a teaching assistant at Project STEM, supporting 30+ students in Java and Python.

Healthcare IT

Epic FHIRHL7 FHIR R4SMART on FHIRImaging InteroperabilityEpic RadiantHAPI FHIREHR AnalyticsRevenue CycleHIPAAClinical Workflows

Languages & Frameworks

Java 17Spring BootSpring SecuritySpring Data JPAThymeleafPythonSQLFastAPIPostgreSQL

Data & Tools

SQLPostgreSQLData AnalysisReportingChart.jsGitDockerLinux
Contact

Let's build something.

Open to Healthcare IT roles: Epic and EHR analyst, systems and application analyst, PACS and imaging IT, data and quality analyst, and clinical informatics. If you think I’d be a good fit, reach out.