Hi, I’m Cam. I climb & build apps.

Senior Software Engineer / Fayetteville, WV

I turn complex business problems into software people can use and teams can maintain. From the first conversation to production, I design the systems and write the code.

Selected work

New systems.
Real-world constraints.

Recent work at Objective, through September 2026. Client names omitted; both broader migrations are still underway.

Enterprise ordering / 2026

Rebuilding around the business rules

An ordering platform connected customer purchases to fulfillment and accounting in SAP. Replacing it meant untangling regional pricing, purchasing constraints, and delivery schedules without losing the rules that kept it running.

I developed the architecture and phased delivery plans, built customer and admin APIs and interfaces, and created parallel AWS infrastructure for the migration.

  • Normalized pricing into the units customers buy, preserving historical order data.
  • Built an order-event log and processing locks while keeping legacy status fields compatible.
  • Aligned interfaces with OpenAPI contracts, generated types, and automated checks.
More about the migration

I traced existing workflows and turned them into reviewable features, revising the plan as implementation revealed hidden dependencies. Shared user records preserved relationships and employee roles, with separate customer and administrator access boundaries.

The infrastructure work moved toward a consolidated Phoenix application on ECS, with GitHub Actions for delivery. New interfaces, APIs, infrastructure, and parts of the processing workflow were implemented by September. Queue handover, processing ownership, rollback observation, and the wider cutover remained part of the ongoing migration.

Elixir / Phoenix / TypeScript / PostgreSQL / AWS

Insurance & payments / 2026

Modernizing one reliable step at a time

Quotes, payments, signatures, and policy creation had to stay coordinated while a Rails application was being replaced—even when events arrived out of order or processing stopped halfway through.

I extracted payment integrations into TypeScript services and built React checkout flows, using feature flags and Rails API clients to support incremental rollout.

  • Built durable webhook storage, duplicate-event protection, and recovery paths.
  • Bridged existing credentials into new authentication without password resets.
  • Preserved Rails audit history and added deployment checks that detect ECS rollbacks.
More about the migration

I separated payment collection from order finalization. Verified webhook signatures, PostgreSQL event storage, transactional worker claims, advisory locks, and completion checks protected processing. Retry and administrative recovery paths addressed interrupted work.

Tracing quote-to-policy behavior exposed separate checkout implementations and changed the delivery sequence. I consolidated shared work and documented the evolving design. By September, payment services, checkout flows, authentication and API foundations, audit compatibility, and deployment infrastructure were implemented; the broader Rails replacement remained underway.

TypeScript / React / Hono / Bun / Rails / PostgreSQL

The path so far

A little background.

13 years building software across finance, healthcare, insurance, logistics, ecommerce, and civic data.

2021–present / 2017–2020

Objective

Senior Developer / previously Developer

Architecture, technical delivery, and hands-on development for client applications. Work spanning web and mobile products, financial calculations, enterprise integrations, and production infrastructure.

2020–2021

A climbing interlude

Built climbing-wall maps and activity features at Pebble in early 2020. Then traveled around the country climbing, June 2020 through April 2021.

2017

Grow.com

Software Engineer

Built product features with React and PostgreSQL and developed a companion Chrome extension.

2014–2017

City of Asheville

Software Developer / Civic & GIS Programmer

Made civic data more accessible to residents and city employees. Built public and internal applications, replaced a critical web service, and laid the groundwork for a React and GraphQL migration.

2013–2014

Locus Technologies

Software Engineer

Rebuilt an environmental application for the web and developed a custom GIS API and interactive map.

Before software: geography research and teaching at Appalachian State, logistics, and service in the U.S. Army.

Download my full résumé

Approach & tools

Keep it simple.

I like the web, simple systems, and tools that earn their place.

How I build

Start with the business rules. Use domain-driven design to give them clear names and boundaries. Organize features with Vertical Slice Architecture so related behavior stays together.

Keep the Unix philosophy close: small pieces with clear responsibilities. Make changes incremental, test the important behavior, and plan for what happens when something fails.

Current toolkit

Frontend
TypeScript, React, TanStack, Next.js, Remix, Tailwind
Backend
Elixir, Phoenix, LiveView, Node.js, Hono, Bun, PostgreSQL
Infrastructure
AWS, CloudFormation, ECS, Docker, GitHub Actions
Also worked with

React Native, Ruby on Rails, Python, Swift, Objective-C, Java, Kotlin, Angular, Express, MongoDB, MySQL, GraphQL, and GIS.

Exploring

Go

Go’s simplicity, static typing, and performance make it a language I’m excited to work with. I spent substantial time exploring it and evaluating it for agency projects. Its small surface area and straightforward tooling fit the way I like to build software.

For our agency’s needs at the time, the team’s familiarity with TypeScript and the libraries and integrations we already relied on made our existing stack the more practical choice. I haven’t used Go in production yet, but I came away from that exploration wanting to. I’d love to work with it professionally.

Datastar & hypermedia

Years of maintaining legacy applications have made me acutely aware of the cost of dependency churn, especially in the React ecosystem. React is still my go-to for most projects because it gives me the capabilities to build the interfaces clients need. But I’m increasingly interested in how much I can do with fewer dependencies.

I keep coming back to the idea of a “100-year web app”: software built on durable web foundations, with less to replace just to keep it running. This site is a small expression of that idea. Just HTML, CSS, and a few good fonts.

Datastar and hypermedia appeal to me as a way to bring that same restraint to richer, interactive applications. I want to explore how far I can take an interface with HTML, server-driven updates, and one small frontend dependency. I haven’t used Datastar in production yet, but I’m excited to do more with less.