ENZO ROMANO
Full-stack systems engineer
I design and build software systems end-to-end, from frontend interfaces to backend platforms and infrastructure.
Focused on system behavior as complexity grows.
What I work on
Systems I build
Frontend / Backend / Infrastructure / AI / IoT / Distributed Systems
Where I operate
Complex systems, distributed workflows, automation, scalable architectures
What I care about
Clarity, maintainability, evolvability, reducing complexity over time
Systems approach
Work
Systems I've designed and built across domains. Each entry covers context, constraints, approach, trade-offs, and outcome.
End-to-end event-driven platform processing millions of events per day across a distributed system.
Context
A growing product required near-real-time analytics over streaming data from multiple sources. The existing batch pipeline could not meet latency requirements and required a redesign.
Constraints
- —Sub-second end-to-end latency
- —Exactly-once processing semantics
- —Zero-downtime deployments
- —Multi-region failover
Approach
Designed an event-driven architecture using partitioned event logs and stream processors. Events are ingested through regional gateways, deduplicated at edge, and processed through a DAG of stream operators before landing in query-optimized storage.
Trade-offs
- —Accepted operational complexity of Kafka for throughput guarantees
- —Chose at-least-once with idempotent processors over two-phase commit
- —Favored eventual consistency in analytics over strong consistency
Outcome
Platform handles 5M+ events/day with p99 latency under 200ms. Multi-region deployment with active-active failover. Engineering team grew the system incrementally without fundamental redesign.
Component library tooling and CI/CD pipeline serving multiple frontend applications across three frameworks.
Context
Multiple product teams maintained divergent UI implementations. Need for a shared design system with framework-agnostic tokens and automated distribution.
Constraints
- —Support React, Vue, and Web Components
- —Tree-shakeable per-component imports
- —Visual regression testing on every PR
- —Semantic versioning with automated changelogs
Approach
Built a token-based architecture where design decisions flow from Figma tokens through Style Dictionary into framework-specific outputs. Components are authored as single sources of truth and compiled to framework targets via custom build tooling.
Trade-offs
- —Custom build pipeline over off-the-shelf tools for multi-framework output
- —Runtime CSS injection avoided in favor of build-time extraction
- —Opted for CSS custom properties over JS-based theming for zero-cost runtime
Outcome
Unified design language across 6 applications. Component adoption reached 90% within 3 months. Visual regression suite catches regressions before merge. Design-to-code workflow reduced handoff time by 60%.
Zero-downtime migration from a monolithic API to a federated GraphQL gateway serving 40+ downstream services.
Context
A monolithic REST API serving 200+ endpoints had become a bottleneck for team autonomy. The migration needed to happen incrementally without disrupting existing clients.
Constraints
- —Zero breaking changes to existing clients
- —Gradual migration path per domain
- —Unified authentication and rate limiting
Approach
Introduced a federation layer that initially proxied all requests to the monolith. Domains were extracted one at a time into standalone GraphQL services, with the gateway composing the unified schema. Traffic was shifted via canary routing.
Trade-offs
- —GraphQL federation adds latency overhead vs direct service calls
- —Schema composition required careful coordination across teams
- —Chose Apollo Federation over schema stitching for operational simplicity
Outcome
Migrated 40+ domains over 12 months with zero client-facing incidents. Team deploy velocity increased 3x. Gateway handles 10K requests/sec with p99 latency under 100ms.
Distributed edge compute platform processing sensor data on-device with selective cloud offload.
Context
Industrial sensors generated high-volume data that was too expensive to stream entirely to cloud. Needed local preprocessing with intelligent sampling.
Constraints
- —Operate on constrained ARM devices
- —Survive intermittent connectivity
- —Over-the-air updates without downtime
Approach
Built a Rust-based edge runtime that processes sensor streams locally using a lightweight rule engine. Anomalies and aggregated windows are selectively uploaded. Device shadow maintained in cloud for command-and-control.
Trade-offs
- —Rust chosen over Python for memory safety and performance on constrained hardware
- —Eventual consistency for device state over strong consistency
- —Binary patching over container-based updates to minimize resource usage
Outcome
Reduced cloud bandwidth by 94% via local preprocessing. Devices operate for weeks offline with local decision-making. OTA updates complete in under 30 seconds with rollback capability.
Unified build and deploy platform across 80+ repositories with standardized pipelines and environment management.
Context
Teams maintained divergent CI configs with inconsistent practices. Flaky builds and slow feedback loops were blocking delivery velocity.
Constraints
- —Migrate 80+ repos without blocking teams
- —Reduce average pipeline time under 10 minutes
- —Self-service ephemeral environments per PR
Approach
Created a pipeline-as-code framework with shared templates and team-specific overrides. Builds are cached across branches via content-addressable storage. Ephemeral environments are provisioned per PR using infrastructure-as-code.
Trade-offs
- —Opinionated pipeline templates vs full flexibility for teams
- —Monorepo-style caching across repos adds infrastructure complexity
- —Chose build re-execution over remote caching for security isolation
Outcome
Average pipeline time dropped from 22min to 7min. Build success rate improved from 85% to 98%. Ephemeral environments enabled pre-merge integration testing that caught 60% of regressions.
Experiments
Side projects and prototypes exploring ideas at the intersection of systems, infrastructure, and automation.
Why
Privacy-sensitive codebases cannot send code to cloud AI services. Exploring local inference with quantized models.
Explores
Quantized transformers, ONNX runtime, edge inference constraints
Why
Low-cost distributed sensing in agricultural settings without existing network infrastructure.
Explores
ESP-NOW protocol, duty cycling, mesh routing under power constraints
Why
Code review tools add friction. Exploring whether git itself (notes, refs, commits) can encode structured review data.
Explores
Git internals, review protocols, developer workflow optimization
Why
Distributed systems are hard to test reliably. Deterministic simulation enables reproducible fault injection.
Explores
Virtual time, fault injection, property-based testing for distributed systems
Why
Multi-tenant platforms need safe, sandboxed extensibility without trusting user code.
Explores
WASI runtime, capability-based security, plugin isolation
Why
Home lab infrastructure grows organically and becomes fragile. Infrastructure-as-code brings reproducibility to personal setups.
Explores
Declarative configuration, secrets management, self-hosted services
About
I started building software as a full-stack developer, working across frontend and backend. Over time, my focus shifted from individual components to how systems behave end-to-end — under load, at scale, and during failure.
I work on systems that span multiple domains: from user interfaces that handle complex state, to backend services processing millions of events, to infrastructure that supports continuous delivery across teams.
My approach is guided by first principles: understanding the problem space, mapping constraints, and designing solutions that remain coherent as complexity grows. I value clarity, simplicity, and systems that fail predictably.