ENGINEERING & PRODUCT DELIVERY

From complex problems to working systems.

I combine engineering, analytical thinking, and product judgement to turn ambiguous requirements into systems with clear boundaries, measurable behaviour, and practical value.

Focus Areas:AI & AutomationProduct & Workflow SystemsFinance & Data

Finance & Quantitative SystemsCase Study 01

Deterministic DCF Valuation Engine with Dual-Format Reconciliation

01 The Problem

Spreadsheet-based discounted cash flow (DCF) models frequently bury assumptions and sensitivity drivers inside deeply nested cell formulas, causing silent calculation errors during financial analysis.

02 Why It Matters

Corporate valuation models must be verifiable and deterministic. When investment committees evaluate cash flows, formula drift between web dashboards and exported spreadsheets undermines trust.

03 My Role & Responsibilities

Sole System Architect & Full-Stack Engineer — modeled the financial mathematics, structured schema validation, built the FastAPI computation core, and engineered the dual-export pipeline.

04 System Architecture Flow

1. Driver InputsUnlevered Free Cash Flows, WACC, Terminal Growth, Exit Multiple

2. Schema GatePydantic & Zod validation enforcing numeric bounds & consistency

3. Valuation CoreDeterministic calculation of Enterprise & Equity Value (Gordon Growth + Exit Multiple)

4. Dual ExportSynchronized OpenPyXL Excel (.xlsx) workbook & immutable JSON audit snapshot

05 Implementation & Technical Decisions

Built with Python, FastAPI, React, and OpenPyXL. The valuation core is isolated into pure mathematical functions with zero side effects. Terminal values are evaluated under both Gordon Growth and EV/EBITDA multiple methods, producing a unified sensitivity matrix.

06 Validation & Evidence

Automated unit test suite verifies zero mathematical discrepancy between the web application state and exported Excel workbooks across varying tax rate and discount rate scenarios.

07 Limitations & Next Steps

Current implementation operates on manually entered or uploaded point-in-time financial statements; real-time equity market data streaming is scheduled for a future iteration.

Stack:

PythonFastAPIReactOpenPyXLFinancial ModelingSensitivity Analysis

Workflow Automation & ReliabilityCase Study 02

Durable Ingestion Pipeline with Transactional Outbox Pattern

01 The Problem

Direct synchronous HTTP calls from web forms to third-party CRM APIs and messaging gateways risk permanent lead loss during network blips and produce duplicate notifications on browser retries.

02 Why It Matters

In commercial customer acquisition, dropped enquiries directly reduce revenue. Workflows require atomic persistence and idempotent message dispatch that survive downstream provider downtimes.

03 My Role & Responsibilities

Backend Architect & Engineer — designed the database transaction boundaries, implemented HMAC token authentication, and built the advisory-locked background outbox worker.

04 System Architecture Flow

1. Form IngestionInbound customer submission verified via HMAC-signed session token

2. Atomic CommitPostgreSQL transaction writes lead record and outbox intents simultaneously

3. Outbox WorkerSession advisory-locked worker fetches pending items with exponential backoff

4. External DispatchIdempotent sync to Google Sheets adapter & WhatsApp notification channel

05 Implementation & Technical Decisions

Engineered with TypeScript, Next.js, Hono, and PostgreSQL. Client submissions require a cryptographically signed token to prevent automated spam. The outbox processor uses PostgreSQL session advisory locks (`pg_try_advisory_lock`) to serialize delivery without distributed locks, retrying transient errors with bounded backoff (max 8 attempts).

06 Validation & Evidence

Full integration test suite verifies zero lead loss when external adapters simulate 503 errors, confirmed deduplication of retry submissions, and verified OAuth 2.0 refresh persistence.

07 Limitations & Next Steps

Current dispatch targets Google Sheets and WhatsApp webhook channels; automated bi-directional CRM synchronisation and voice agents remain out of scope.

Stack:

TypeScriptNext.jsHonoPostgreSQLTransactional OutboxOAuth 2.0Advisory Locks

Geospatial Data ProductsCase Study 03

Geospatial EV Charging Station Locator with PostGIS Indexing

01 The Problem

EV owners searching for charging stations encounter sluggish radius queries and unstandardized connector compatibility data when navigating crowded metropolitan areas.

02 Why It Matters

Finding an operational, compatible charger is time-critical for EV drivers. Geospatial APIs must return verified station listings within sub-100ms response windows even under heavy concurrent search traffic.

03 My Role & Responsibilities

Geospatial Systems Engineer — designed the bounding-box ingestion workflow, configured PostGIS spatial indexing, and implemented rate-limited API endpoints.

04 System Architecture Flow

1. User LocationCoordinate pair (lat/lng) and vehicle connector compatibility criteria

2. Request ClampingHono middleware clamps search radius and bounds coordinate boxes

3. Spatial QueryPostgreSQL/PostGIS ST_DWithin query accelerated by GiST spatial index

4. Normalized FeedSub-50ms GeoJSON payload formatted with connector types and power tiers

05 Implementation & Technical Decisions

Constructed with Next.js, Hono, and PostgreSQL with PostGIS extension. Search radiuses and coordinate limits are strictly validated to prevent full-table spatial scans. GiST indexes on station geometric points enable rapid proximity lookups.

06 Validation & Evidence

Radial distance queries execute in under 50ms across station snapshot records; API body limiters protect database memory from malicious payload sizing.

07 Limitations & Next Steps

Indexes static and verified station directory records; dynamic real-time occupancy (charger busy/available) requires integration with proprietary CPO network protocols (OCPI).

Stack:

Next.jsHonoPostgreSQLPostGISGiST IndexingTypeScript

AI Systems & Natural LanguageCase Study 04

Sandboxed Natural-Language Query Engine & SQL Analytics

01 The Problem

Non-technical stakeholders and product managers wait days for centralized data analysts to author routine SQL queries, stalling product decisions and operational insights.

02 Why It Matters

Allowing non-technical users to query production databases with natural language poses severe security risks, including destructive queries (DROP/DELETE) and resource-exhausting unindexed scans.

03 My Role & Responsibilities

AI Product Designer & Full-Stack Engineer — architected the natural language to SQL translation pipeline, authored the AST security validator, and built the visualization UI.

04 System Architecture Flow

1. Natural PromptPlain-English business question (e.g. 'Monthly revenue by region in Q3')

2. Schema InjectionContext injector injects normalized DDL and column descriptions

3. AST Security GateParser AST visitor blocks DDL/DML, restricts to read-only replica, clamps LIMIT 500

4. Visual OutputExecutes against read-only database replica; returns data table & Plotly chart

05 Implementation & Technical Decisions

Built with Python, FastAPI, React, SQLAlchemy, and Plotly. The SQL query generated by the language model is parsed into an Abstract Syntax Tree (AST) prior to execution. The validator rejects any non-SELECT statements, enforces execution timeouts, and injects row limits.

06 Validation & Evidence

Zero DDL/mutation bypasses achieved across malicious prompt injection test batteries; automated tests confirm queries execute exclusively on read-only replicas.

07 Limitations & Next Steps

Optimized for normalized star schemas and clean relational tables; highly ambiguous analytical questions or complex window functions still require human analyst review.

Stack:

PythonFastAPIReactSQLAlchemyAST ValidationPlotlyText-to-SQL

ADDITIONAL VERIFIED WORK

Specialized Tooling & Research Systems

Targeted implementations solving graph signal synthesis and scientific literature extraction bottlenecks.

Technical SEO & Graph Signal Analysis

Autonomous Site Graph Analysis & On-Device MLX Inference

Modeled website architectures as directed NetworkX link graphs to compute PageRank and crawl depth, synthesizing issue clusters into structured developer tickets using local Apple Silicon MLX models.

PythonFastAPINetworkXApple Silicon MLXTechnical SEO

View Project Specs →

AI Research & Literature Extraction

Multi-LLM Consensus Scientific Literature Pipeline

Engineered an automated data extraction and validation pipeline using a 4-model ensemble (Gemini, DeepSeek, Anthropic, OpenAI) to extract structured JSON ecological edge lists from unstructured PDF monographs.

PythonMulti-LLM EnsemblePyTorch GeometricSchema Enforcement

Explore OIST Research →

ENGINEERING STANDARDS

How I Build Software

Core technical principles applied consistently across every codebase.

1. Verification Over Assumptions

Every feature must be grounded in verified automated tests, strict schema contracts, and empirical output evidence. Unverified claims have no place in engineering.

2. Determinism Before Generative Models

Financial math, authorization, and core business transactions should always be deterministic. Use AI models for reasoning and synthesis, never as an unconstrained substitute for business logic.

3. Outbox Durability Over Direct Chains

Never rely on fragile direct synchronous HTTP chains across external services. Commit state locally and use the transactional outbox pattern to guarantee idempotency and fault tolerance.

4. Clean Boundaries & Minimal Dependencies

Build modular systems with explicit boundaries, clean typing, and native platform capabilities before reaching for bloated third-party abstractions.

LET’S COLLABORATE

Interested in working together?

I am open to technical leadership, full-stack architecture, AI engineering, and quantitative financial product challenges.

Contact Details →