Building backend systems where failure isn't an option?I can help with that.

Specializing in resilient APIs, event-driven architectures, and high-throughput data pipelines engineered for high concurrency and zero silent failures.

Resilient backend architecture, from endpoint to database.

High-Concurrency Architecture

Designing non-blocking services with asynchronous event loops, worker thread offloading, and decoupled microservices built for horizontal scale.

Data Modeling & Storage

Structuring persistent data layers across relational, time-series, and vector stores, with a focus on indexing efficiency and schema integrity.

API Design & Protocols

Architecting high-performance REST APIs, event-driven message brokers (MQTT), and real-time streaming interfaces via WebSockets and SSE.

Validation & System Security

Enforcing strict request schemas (Pydantic/FHIR), secure zero-trust networking boundaries, and defensive payload serialization.

DevOps & Production Reliability

Automating CI/CD pipelines via GitHub Actions, containerizing multi-service stacks in Docker, and instrumenting metrics to eliminate silent failures.

Here's some of my work.

01 — Event-Driven IoT Systems

An event-driven IoT integration server bridging web protocols with embedded hardware over binary MQTT streams.

Architected a non-blocking integration server using FastAPI and an asynchronous aiomqtt event loop running persistently in the background. It handles bidirectional device traffic, automated backoffs, and hardware state synchronization without stalling the main API thread.

To eliminate JSON parsing overhead on memory-constrained microcontrollers, I built a custom serialization layer translating HTTP payloads into deterministic byte size binary structs. Blocking I/O operations like InfluxDB time-series writes and binary packing are explicitly offloaded to worker threads via asyncio.to_thread.

Edge DevicesTime-Series I/Oasyncio // aiomqtt010203

The Protocol · aiomqtt & Sockets

1360 BExact binary structs packed for low-overhead microcontroller client deserialization
Single-endpointUnified WebSocket stream that replays system state on connect, then pushes live broker events
0 msEvent-loop block time, offloading serialization and database I/O to separate threads

The Architecture · Dynamic Registry

RegistryHardware abstraction pattern dynamically mounting device routers and health checks at startup
Time-seriesInfluxDB persistence for high-throughput current draw and dosing execution telemetry
Multi-stageDocker Compose environment containerizing API, broker, database, and Nginx frontend

02 — Distributed Systems & APIs

A clinical safety layer streaming verified LLM claims and FHIR R4 resources via Server-Sent Events.

Engineered a high-performance FastAPI service that orchestrates a LangGraph agentic pipeline to detect hallucinations in clinical LLM responses. The system ingests FHIR R4 resources from HAPI servers, queries PubMed via NCBI E-utilities, and dynamically routes medication queries to OpenFDA APIs.

Instead of keeping client connections idle, the server streams live node execution and claim validations over Server-Sent Events (SSE). Queries are embedded with BioBERT into query-isolated Pinecone namespaces to prevent session cross-contamination, followed by DeBERTa-v3 NLI cross-encoder verification.

PubMed/FDAIngestParseAPIsPineconeResultServer-Sent Events (SSE) Stream

The API & Ingestion · FastAPI & FHIR

SSE Streamreal-time execution updates and per-claim validation streamed directly over HTTP
FHIR R4native ingestion for Condition, MedicationRequest, and DiagnosticReport resources
Namespacedisolated Pinecone vector indexes per query session, eliminating semantic cross-contamination

The Verification · DeBERTa-v3 & RAGAS

0.774faithfulness score measured via RAGAS across clinical evaluation benchmarks
10 claimsextracted and verified as structured JSON per response against primary literature
MLflowproduction monitoring logging confidence distributions and retrieved abstracts per run

03 — Compute & Inference Infrastructure

A containerized inference service executing sliding-window 3D brain tumor segmentation on multimodal MRI volumes.

Built a containerized FastAPI backend to operationalize a 3D U-Net trained on 1,200 BraTS multimodal MRI scans. The service handles compute-heavy sliding window inference over 128³ regions of interest across 4-channel volumes (T1, T1ce, T2, FLAIR).

The inference pipeline executes intensity normalization and skull-stripping transforms on the fly before generating 3-class voxel-wise masks. The entire system is packaged in a reproducible Docker runtime with full MLflow experiment tracking and automated GitHub Actions CI/CD.

BraTS 2023 // 128³ ROI
Drag to Rotate
NCR
ED
ET
Mounting WebGL...

The Inference Service · FastAPI & Docker

128³ ROIsliding window inference patches over full 4-channel multimodal NIfTI volumes
Dockerreproducible inference container with strict dependency pinning and automated CI/CD
MLflowexperiment tracking logging hyperparameters, loss curves, and artifact visualizers

The Accuracy · BraTS 2023 GLI (188 Cases)

0.930Dice score on Whole Tumor (WT) with 5.94 mm 95th-percentile Hausdorff distance
0.910Dice score on Tumor Core (TC) with 3.76 mm HD95 across held-out test cases
0.848Dice score on Enhancing Tumor (ET) with 3.23 mm HD95
And there's more where that came from...
Andrew Franco

About Me

My approach to system architecture comes from eight years managing high-acuity cardiac telemetry networks in the ICU and ER. Operating in an environment where a dropped packet has immediate patient consequences permanently changed how I view edge cases.

I apply the exact same clinical standard to backend engineering. I write defensive code, enforce strict schema validation, and integrate complete observability into every pipeline to ensure the infrastructure I ship is highly resilient and fails predictably.

[B.S. Computer Science, ABET-accredited.]

Get in touch