Turning ambiguous problems into
real products. Experiment, learn,
ship, repeat.
Building reliable systems, high
performing teams, and technology
that scales.
I am a software engineer and technical leader with over two decades of experience building products from initial concept to high-scale production. My work spans founder-led SaaS platforms processing over C$1 million in volume, enterprise-scale customer-embedded SDKs, and event-driven microservices processing hundreds of thousands of weekly operational messages. I bridge the gap between 0→1 product discovery, maintainable systems architecture, and pragmatically aligned technical teams.
I have personally run every step of the product lifecycle—shaping requirements, writing code, managing infrastructure, and supporting real-world operations under live conditions.
I build systems that solve today’s customer problems without creating unnecessary layers or premature abstractions that impede future momentum.
I leverage spec-driven, AI-assisted workflows across implementation, testing, and refactoring to accelerate execution while maintaining strict architectural standards.
Over the past 20+ years, my career in software engineering has evolved across three distinct operational environments: early-stage startup founding, high-growth platform expansion, and large-scale enterprise reliability.
I began with direct engineering and web development, eventually founding and operating MotoRegistry—a complete SaaS platform for motorsport organizers where I served as sole engineer, product manager, and operator. This experience provided a firsthand understanding of product-market fit, production stakes, and the realities of running live software.
As my career progressed through organizations like Unata, Instacart, and PagerDuty, I translated that founder mindset into larger technical ecosystems. I managed frontend development teams, led embedded JavaScript SDK integrations for enterprise grocery partners, and designed distributed Kafka and Elixir microservices powering high-throughput notification and fraud-prevention pipelines.
My technical leadership combines direct architectural oversight, code review, and mentorship with team unblocking and cross-functional alignment. Today, I combine this deep operational context with modern spec-driven, AI-assisted engineering workflows. This approach allows me to move fluidly between high-level system strategy, product decision-making, and hands-on execution.
The same mindset that takes an idea from zero to one also scales it to serve millions.
I believe great engineering is not about using the most sophisticated tools or architectures — it's about making deliberate, context-aware decisions that create long-term value. The goal is to solve real problems, move quickly, and build systems that can evolve without unnecessary friction.
Architecture should match the specific problem, the cost of system failure, and current domain uncertainty. Early-stage products require flexible architectures that allow for fast iteration and low overhead; mature enterprise systems require strict separation of concerns, isolation, and explicit contracts. Building enterprise-scale abstractions for an unproven product creates rigid codebases and drains momentum.
Every additional architectural layer, framework wrapper, or microservice boundary introduces maintenance overhead, debugging friction, and cognitive load. I prioritize clear, direct implementations that make system behavior obvious. Complexity must earn its place by solving explicit business or operational requirements.
Engineering time is best spent on core differentiators. When evaluating third-party platforms, managed services, or internal builds, I assess the long-term maintenance burden alongside initial delivery speed. Leveraging established external tools for standard requirements (e.g., identity, payments, messaging) preserves focus for unique product value.
Code quality and system aesthetics are not isolated goals; they are tools to deliver reliable customer value. Architectural choices must directly support user experience, operational stability, and product flexibility. Technical decisions should be treated as deliberate financial instruments: useful for testing hypotheses under tight deadlines, provided it is managed and retired intentionally.
MotoRegistry was born out of direct domain experience in motorsport event management. Recognizing the friction of manual, paper-based race day workflows, I designed, built, and deployed a complete end-to-end SaaS platform for motorsport clubs and event organizers.
As the sole engineer, designer, product manager, and system operator, I took full ownership of the entire product lifecycle.
Evolved the system from simple online registration into a full event operations engine—handling race entries, digital waivers, on-site check-in, live scoring, and official results.
Integrated payment processing workflows that reliably handled over C$1 million in volume.
Worked directly on-site as track staff during motocross events to test software under real-world conditions, observing operational bottlenecks firsthand and adjusting product mechanics accordingly.
Operating MotoRegistry taught me that production failures carry real operational consequences. It established my commitment to pragmatic, zero-fluff engineering where reliability directly dictates user trust.
Multiplayer Experiences with Generative AI
As Co-Founder and Technical Lead at Electric Sheep Studios, I led engineering for a multiplayer product leveraging generative AI.
Built a real-time multiplayer architecture utilizing WebSockets for state synchronization, host-managed state models, Supabase for persistence, and direct integrations with external AI image-generation APIs.
Navigated tight accelerator and pitch deadlines to move from concept to a playable, responsive MVP.
Validated fast feedback loops in novel product spaces while establishing steady state synchronization and API error-handling patterns.
Building reliable, event-driven systems that turn complex data into real customer value.
HIGH-SCALE RELIABILITY & MESSAGING
At PagerDuty, I designed and built event-driven systems that processed large volumes of data, delivered high-impact customer communications, and improved platform security. This work combined distributed systems design, operational reliability, and growth-focused experimentation.
Designed and implemented an automated data enrichment and messaging pipeline built on Kafka. The system processed complex usage insights and delivered personalized reports to roughly 750,000 weekly recipients. The architectural separation between data enrichment, payload generation, and delivery mechanisms ensured stability without degrading core messaging flows.
Engineered Elixir-based microservices connected to Kafka event streams to evaluate fraud risk in real time. By strictly decoupling account evaluation logic from account creation pathways, the design delivered full operational auditability, simple reversibility, and higher confidence across risk and compliance stakeholders.
Worked within cross-functional growth initiatives to optimize trial onboarding, self-serve checkout flows, event instrumentation (using Segment), and A/B testing frameworks. This work linked core platform reliability with customer acquisition and expansion loops.
FLEXIBLE PLATFORMS. STRONGER PARTNERSHIPS.
At Unata and later Instacart, I led frontend engineering and delivered enterprise SDKs that enabled major grocery partners to integrate and customize e-commerce experiences at scale.
Led a team of 10+ frontend engineers, establishing code quality standards, component architectures, and delivery schedules.
Managed the architecture and delivery of customer-embedded SDKs integrated into major enterprise grocery platforms.
Maintained platform stability while supporting partner-specific branding, styling, and custom workflows. Enforced strict backward compatibility and explicit interface boundaries to allow partner configurations to evolve without breaking releases.
I view technical leadership as the practice of establishing architectural clarity, removing friction, and framing business context so engineering teams can make sound, autonomous decisions.
Engineers do best when they understand the underlying customer problems, operational constraints, and business goals—not just a list of Jira tickets. Providing full context enables engineers to identify simpler solutions that product specifications might miss.
Leadership requires staying close enough to the code to understand team bottlenecks. Whether through architectural design reviews, technical mentorship, or jump-starting complex integrations, I focus on unblocking teams and establishing clear technical standards.
I foster team cultures where technical decisions are evaluated based on evidence, trade-offs, and operational risks. Open discussion about system constraints leads to stronger architecture and collective accountability.
Technical debt is a tool to trade temporary velocity for immediate feedback. I help teams distinguish between useful, deliberate debt and sloppy implementation, ensuring that shortcut decisions are documented and scheduled for refactoring before causing structural drag.
Rather than treating AI as a replacement for software engineering, I utilize AI tools as high-speed execution multipliers guided by human architectural judgment.
FROM SPEC TO IMPLEMENTATION
Writing clear, structured specs detailing system constraints, interfaces, and edge cases before generating code.
Utilizing AI tools to rapidly generate boilerplate, write unit and integration test suites, and draft refactoring options.
Inspecting generated code against strict architectural boundaries, security considerations, and maintainability standards.
EXPLORE. VALIDATE. APPLY.
Creating functional interactive prototypes (e.g., 3D web environments, AI-backed tools) to evaluate user interaction patterns before committing full resources.
Embedding LLM APIs into background processing tasks to handle unstructured data transformation.
A selection of projects that highlight my experience building, scaling, and operating real-world software products.
Founder, Sole Engineer, Product Manager, and Operator
Built an end-to-end race management SaaS platform handling online entry registrations, digital waiver sign-offs, payment processing, on-site check-in workflows, and live race scoring. Processed over C$1 million in transaction volume.
Lead Systems Architect & Software Engineer
Designed a Kafka-based data enrichment and messaging pipeline that processes platform usage patterns and formats personalized operational reports for roughly 750,000 weekly recipients.
Senior Software Engineer
Built Elixir microservices consuming Kafka event streams to evaluate account risk factors asynchronously. Decoupled evaluation logic from account creation pathways for auditability and risk assessment.
Engineering Manager / Technical Lead
Managed the customer-embedded JavaScript SDK and led a frontend engineering team of 10+ developers across major enterprise grocery retailers.
Co-Founder & Technical Lead
Architected a real-time multiplayer product featuring generative AI image generation, state synchronization via WebSockets, host-managed state models, and Supabase integration.
Creator & Engineer
Designed and released independent applications—including a mobile audio-visual training app and AI-assisted analysis tools—exploring cross-platform mobile engines and LLM API integrations.
A path defined by building, scaling, and solving real-world problems.
I am seeking senior technical roles—such as Principal Engineer, Founding Engineer, or VP of Engineering / CTO at early-to-growth stage companies—where I can combine product vision, architectural oversight, hands-on execution, and technical leadership.
I'm always open to meaningful conversations about new opportunities, interesting problems, or potential collaborations.