01
End-to-End Ownership
I own the full lifecycle — architecture, implementation, on-site deployment, and post-launch stabilization. Not just the code.
Istanbul, Türkiye — 4 Years in Production
ALI BOYACI
Full-Stack Product Engineer
Real-time systems that run in production — and stay up.
Four years building event-driven systems on Node.js, TypeScript, and React — across on-prem industrial automation, open-source dev tools, and B2B platforms. I own the full lifecycle, from architecture to 24/7 production.
6,000+Real-time operations processed in production, 6 months after deploy
40–50Incidents prevented by early-warning telemetry
70+Enterprise sites on platforms I contribute to
10–30Production Kubernetes clusters operated
How I work
Built for Production
Engineering decisions driven by operational reliability — not demos.
02
Real-Time System Architecture
Event-driven pipelines on MQTT, WebSocket, and REST that move thousands of records per minute under hard latency requirements.
03
Risk-Managed Delivery
Runbooks, rollback plans, telemetry, and 24/7 incident response. I don’t ship anything I can’t operate.
Experience
Where I’ve Done It
Four years shipping and stabilizing real-time software in live industrial environments.
- Built event-driven Node.js / TypeScript services (REST, WebSocket, MQTT) moving thousands of records per minute between data sources, dashboards, and ERP systems.
- Core contributor to two production platforms (Retmes & Retgate) running at 70+ enterprise customer sites; led or contributed to 10+ deployments from architecture to go-live.
- Operated Node.js services across 10–30 production Kubernetes clusters — release management, telemetry validation, and 24/7 incident response.
- Promoted from Junior to Mid-level Engineer (2024) within a 10–15 person R&D team.
Selected Work
Case Studies
Systems I’ve owned end-to-end — the problem, what I built, and the measured outcome.
Flagship Project
Tank & Filling Automation System
A real-time control and telemetry system that replaced a fully manual workflow across 60+ tanks and 20+ operational lines. Sole software engineer on a two-person team, end-to-end across an 8-month on-prem deployment.
- 6,000+ real-time operations processed in the first 4 months, with full digital traceability.
- Early-warning telemetry prevented an estimated 40–50 incidents and surfaced 3–4 equipment failures per month before disruption.
- Modbus + MQTT pipeline, Node.js backend, React control UI — deployed fully on-prem with no cloud dependency.
Measured Impact
60+ tanks
Scope
20+ operational lines
6,000+ ops
Throughput
first 4 months
40–50
Reliability
incidents prevented
Details
Context
A high-throughput loading facility ran entirely on manual, paper-based operations with no digital traceability. I designed and shipped a real-time control system covering 60+ tanks and 20+ filling lines — owning architecture, implementation, deployment, and on-site telemetry as the sole software engineer on a two-person team over an 8-month deployment.
Constraints
- Strict on-prem infrastructure — no external cloud access.
- Implementation during active 24/7 operations, with zero tolerance for downtime.
- High data density from field devices with hard real-time latency requirements.
What I Built
- Modbus + MQTT data pipeline ingesting live device telemetry into a Node.js backend.
- React control and operator UI for filling lines, built for rugged daily field use.
- Real-time early-warning telemetry that alerts field engineers before unsafe conditions.
- On-prem deployment automation, runbooks, and incident response for a restricted environment.
Outcomes
- Processed 6,000+ real-time operations in the first 4 months with full digital traceability and reporting.
- Prevented an estimated 40–50 incidents and detected 3–4 equipment failures per month before they caused disruption.
- Replaced a fully manual workflow with a stable, auditable digital control system.
What’s Next
- Add predictive maintenance using accumulated telemetry data.
- Expand failover drills and automated load testing.
DriftGuard — Open-Source Schema Drift CLI
An enterprise-grade Python CLI that detects schema and data contract drift across databases, APIs, and files before breaking changes reach production.
- 7 source collectors: PostgreSQL, MySQL, SQLite, OpenAPI, JSON Schema, CSV, YAML.
- Semantic diff engine with 12 event types and fuzzy field rename detection.
- 190 tests, 78% coverage, CI validated across Python 3.11 / 3.12 / 3.13.
Collectors→
Normalizer→
Snapshot Store→
Diff Engine→
Policy Engine→
Reporter→
CI Gate
Details
Context
Most schema validation tools focus on a single data layer — SQL linters check migration syntax, API linters check OpenAPI specs. Real drift happens across layers: a renamed Postgres column can break a downstream CSV export or a partner API consumer. DriftGuard was built to catch these cross-source breaking changes in one unified pipeline.
Constraints
- Must normalize schemas from 7+ heterogeneous sources (databases, APIs, files) into a single comparison model.
- Policy enforcement must be configurable per-team: 5 modes (strict, lenient, default, backward-compatible, forward-compatible).
- Must integrate as a CI gate with non-zero exit codes on policy violations.
What I Built
- Collector architecture with 7 adapters behind a common interface (SQLAlchemy 2.x for databases, pyarrow for files, HTTP clients for APIs).
- Semantic diff engine: type widening taxonomy, constraint-level diffing (PK, FK, unique, numeric ranges), and fuzzy field rename detection via SequenceMatcher.
- Policy engine with 5 enforcement modes and per-resource severity overrides.
- Multi-format reporters: Terminal (Rich), JSON, Markdown, HTML.
- Full test suite: 190 tests, 78% line coverage, ruff + mypy static analysis, GitHub Actions CI matrix.
Outcomes
- Published as open-source on GitHub with comprehensive documentation (architecture guide, CLI reference, adapter guide, policy rules).
- CI pipeline validated across Python 3.11, 3.12, and 3.13 via GitHub Actions.
- Extensible architecture: new collectors and policy modes plug in without changes to the core diff engine.
What’s Next
- Add collectors for Avro, Protobuf, and Kafka Schema Registry.
- Implement SARIF and JUnit XML reporters for CI/CD integration.
ORIA — LLM-Assisted Operations Hub
A solo-built, WhatsApp-centered CRM with LLM-assisted reply drafting and human-in-the-loop approval.
- WhatsApp-centered CRM with direct message-to-record mapping.
- LLM-assisted reply drafting (Anthropic Claude / OpenAI) with human approval before send.
- Node.js / Express + React (Vite) + MongoDB, shipped with a CI/CD pipeline.
WhatsApp Intake→
Data Processing→
AI Draft→
Human Approval→
CRM Sync
Details
Context
A side project exploring LLM-assisted operations: a CRM built around WhatsApp, where incoming messages map to records and the model drafts replies for a human to review and approve before they go out.
Constraints
- Tight turnaround for a usable MVP with real conversations.
- AI output must stay under human control — nothing sends without approval.
What I Built
- Node.js / Express backend with a MongoDB data model for contacts and threads.
- WhatsApp message intake mapped directly into CRM records.
- LLM-assisted reply drafting (Anthropic Claude / OpenAI) with a human-in-the-loop approval step.
- React + Vite admin dashboard, shipped through a CI/CD pipeline.
Outcomes
- Delivered a working MVP with end-to-end product ownership, from architecture to deploy.
- Practical patterns for LLM API integration and prompt design in a production workflow.
What’s Next
- Add activation and retention reporting.
- Harden permission levels for multi-user teams.
Wardrobe — AI-Powered Outfit Planner
A side project exploring AI-assisted recommendations: a React Native app that suggests outfits from weather forecasts and personal wardrobe data.
- Photo-based garment management with AI analysis and categorization.
- 7-day weather forecast integration for context-aware outfit planning.
- Cross-platform TypeScript app with a Supabase backend (Postgres + Auth + Storage).
Project Status
iOS & Android
Platform
Expo + React Native
Supabase
Backend
Postgres + Auth + Storage
Beta
Status
Private repo
Details
Context
A personal project exploring AI-driven personalization in a consumer mobile context. Users photograph their wardrobe items; the app analyzes garments and recommends outfits aligned with weather conditions and personal style.
Constraints
- Image processing and AI analysis must stay responsive on mobile hardware.
- Personalization engine must learn from user feedback without excessive data collection.
What I Built
- Expo + React Native + TypeScript with TanStack Query and Zustand for state management.
- Supabase integration: Postgres with Row-Level Security, Auth, and Storage for garment photos.
- Open-Meteo weather API integration for 7-day forecasts with location-based context.
- Sentry for error tracking, PostHog for product analytics, i18next for Turkish/English localization.
Outcomes
- Functional beta with batch garment upload and AI-powered garment categorization.
- Personalization engine that improves suggestions based on user selections over time.
What’s Next
- Refine the recommendation algorithm based on beta tester feedback.
- Add outfit history and social sharing features.
What you get
Value I Bring
Beyond features — reliable systems teams can trust in production.
01
On-Prem & Real-Time Delivery
Systems engineered for reliability in air-gapped, restricted, or latency-critical environments.
02
Dashboards Teams Rely On
Real-time, low-latency interfaces built for daily field use under pressure.
03
Versatile, Problem-Fit Engineering
From Python CLIs to React Native apps to on-prem automation — I adapt the architecture to the problem, not the other way around.
Contact
Let’s build something reliable.
Looking for a product-minded engineer who ships and stabilizes? I usually reply within 24–48 hours.
Available for product-minded full-stack & product engineering roles.
Email is the best first channel.
aaliboyaci@gmail.com