Building Real Software, Start to Finish

Complete applications across platforms. Not just code—full products with thoughtful architecture, comprehensive testing, and polished user experiences.

What I Do

Web Applications at Scale

Production systems that handle real business complexity. Multi-tenant platforms with sophisticated access control. Admin dashboards that make operations manageable. APIs that external systems can depend on.

The hard parts: Legacy codebases that need modernization without breaking what works. Authentication systems with multiple user types and permission levels. Search interfaces that stay fast as data grows. Audit trails for compliance-sensitive industries.

Tech stack: Laravel, FastAPI, Vue, Inertia.js, OpenSearch, PostgreSQL, Redis

Data That Drives Decisions

Turning raw information into insights people actually use. ETL pipelines that run reliably. Dashboards that answer questions before they’re asked. Automated reports that save hours of manual work.

The hard parts: Aggregating data from messy sources. Building visualizations that surface patterns. Natural language processing for unstructured text. Making AI-generated analysis actually useful.

Tech stack: Python, DuckDB, dbt, Dagster, Metabase, OpenAI, LangChain

Native Mobile Apps

iOS and Android applications that feel native because they are. Offline-capable with intelligent sync. Background processing that respects battery life. Real-time features that work reliably.

The hard parts: Managing state across network conditions. Platform-specific integrations done right. Authentication flows that don’t frustrate users. Testing across device configurations.

Tech stack: Swift/SwiftUI, Kotlin/Jetpack Compose, SwiftData, Hilt, Retrofit

Device & Hardware Integration

Software that connects to the physical world. Custom extensions for cycling computers and wearables. Headless device authentication. Real-time tracking and location services.

The hard parts: Working within hardware constraints. Building for devices without keyboards. Synchronizing data between multiple form factors. Handling intermittent connectivity.

Tech stack: Kotlin, Swift, MonkeyC, CoreLocation, device-specific SDKs

Lightweight Web Tools

Progressive web apps that work offline. Browser extensions that enhance existing workflows. Simple tools that do one thing well.

The hard parts: Service worker caching strategies. Cross-browser compatibility. Building installable experiences without app store friction.

Tech stack: Lit.js, Svelte, vanilla JS, IndexedDB, Service Workers

Developer Tools & Automation

CLI tools that solve recurring problems. Build automation that saves time. Integration scripts that connect disparate systems.

The hard parts: Making tools that are actually pleasant to use. Handling edge cases gracefully. Supporting multiple platforms without complexity explosion.

Tech stack: Go, Python, Cobra, typer, httpx

How I Work

Architecture first. Understanding the problem before writing code. Choosing patterns that fit the scale. Avoiding over-engineering, but also avoiding shortcuts that create debt.

Testing as standard. Unit tests, integration tests, and end-to-end coverage where it matters. Not 100% for vanity metrics—focused coverage on the paths that can break.

Delivery mindset. Working software over perfect plans. Incremental progress with frequent check-ins. Clear communication when scope or timeline concerns arise.

Tech Stack Overview

Languages: Swift, Kotlin, Go, Python, PHP, JavaScript/TypeScript

Web: Laravel, FastAPI, Django, Vue, Svelte, Lit.js, HTMX

Mobile: SwiftUI, Jetpack Compose, SwiftData, Hilt

Data: PostgreSQL, MySQL, SQLite, DuckDB, OpenSearch, Redis

AI/ML: OpenAI, LangChain, Google Cloud NLP, Langfuse

Infrastructure: GitLab CI/CD, Docker, Sentry, various cloud providers

Let’s Build Something

From initial architecture through production deployment—native apps, web platforms, device integrations, data pipelines, and everything in between.

If you have a project that needs to get built right, let’s talk.