TECHNICAL SKILLS & ENGINEERING APPROACH
I work across architecture, application code, data, and infrastructure. My focus is connecting the product people need with systems that can be understood, operated, and changed.
Here’s a closer look at the decisions, patterns, and tools behind my work.
Explore my approachThe outcome the person is trying to achieve.
Inputs, authority, ownership, and expected results.
Persistence, background work, retries, and recovery.
State, evidence, and a clear path back to the user.
Design the boundaries.
Stay close to the details.
I start by deciding who owns the data, who can authorize a change, and how work moves between applications. Those decisions shape the code, the interfaces, and the recovery path.
I separate the customer experience, API edge, business orchestration, financial state, and execution workers. Read models carry the information a product needs while the owning service remains responsible for changes.
Domain boundaries · command/query separation · projections · multi-database Rails
Retries and duplicate messages are part of asynchronous work. I use scoped idempotency keys, request fingerprints, database constraints, transactional outboxes, and explicit acknowledgements to make replay and recovery deliberate.
Durable messaging · idempotency · outbox/inbox patterns · bounded retry policies
An endpoint or AI tool needs a clear execution boundary. My integration work includes tenant and workspace context, scoped credentials, OIDC verification, schema validation, and authorization checks before side effects.
REST · MCP · JSON Schema · OpenAPI · OAuth client credentials · OIDC
I work with relational transactions, uniqueness, row locks, and explicit state transitions. Financial workflows separate reservation, consumption, and release. Geographic workflows need their own geometry and coordinate-system rules.
PostgreSQL · transactional consistency · account ledgers · PostGIS
A database commit and a remote message are separate events. I stage delivery intent alongside the business change, then let an outbox dispatcher deliver it. Consumers persist receipts and distinguish a valid replay from the same identity arriving with different content.
That supports recovery after interruption without treating a transport acknowledgement as the final business result. Correlation, versioned projections, and explicit failure states keep the original request connected to its eventual outcome.
I model reservation, consumption, release, and settlement as explicit transitions with stable identity. Account-level locking and transaction boundaries protect competing changes; a repeated request must match the original operation before its result can be reused.
The tests that matter include duplicate consumption, revoked permission on replay, and real contention between database connections. A useful failure is bounded and understandable, with enough state retained to recover.
Relational records, geographic relationships, graph projections, and search indexes serve different queries. In spatial work I distinguish administrative hierarchy from actual geometric overlap, normalize invalid polygons, prefilter candidate geometry, and use explicit area and containment semantics.
For relationship exploration I work with parameterized Cypher upserts and bounded graph traversals. For retrieval I combine filtered full-text queries with provenance-bearing context. I keep the source record and the derived representation conceptually separate.
I represent acceptance, execution, and completion as distinct states, and carry stable references through the workflow so the result can be traced back to the original intent.
My collaboration work connects Rails authorization, AnyCable-powered application events, and LiveKit’s WebRTC media layer. The challenge is keeping people, permissions, and product state aligned while connections and devices change.
Membership, resource access, capabilities, durable messages, call records, and recording state.
Authenticated subscriptions, presence, cursors, call updates, and presenter/follow coordination.
Room connections, media tracks, participant events, screen capture, and recording egress.
I work with short-lived JWTs, workspace-scoped connection identity, channel authorization, access versions, and leases. A connected browser still needs permission to subscribe to a particular conversation, call, or shared resource.
Action Cable channels · AnyCable RPC · JWT · Redis broadcasting · scoped subscriptions
Presence heartbeats and cursor movement have different lifecycles from durable chat and business records. I use expiry, rate limits, sequence checks, and explicit presenter ownership to keep shared interaction coherent through delayed or stale updates.
Presence leases · cursor throttling · sequence validation · presenter/follow coordination
Room-scoped LiveKit tokens distinguish listening, publishing microphone or camera, and sharing a screen. Admission limits and device-specific participant identity sit alongside application access checks, with recording notices checked before entry when needed.
LiveKit room grants · publish-source restrictions · participant admission · device sessions
I handle track subscription and removal, participant changes, reconnect states, media-device errors, and audio playback restrictions. Capture and call teardown release tracks and subscriptions; the UI reflects the actual media lifecycle.
WebRTC integration · camera/microphone lifecycle · screen capture · reconnect UX · resource cleanup
My recording work connects explicit notice and acknowledgement with LiveKit Egress, asynchronous processing, and verification before playback becomes available. The product distinguishes recording, processing, ready, and failed states.
Provider callbacks are verified against the signed body digest and projected through durable event records. Private media delivery includes encrypted storage, time-limited playback access, retention, and deletion workflows. This brings consent, authorization, lifecycle state, and recovery into the same design.
LiveKit Egress · signed webhooks · MP4/HLS · S3 · KMS · CloudFront · lifecycle reconciliation
I work across the Rails application, AnyCable’s WebSocket/RPC boundary, and self-hosted LiveKit media infrastructure. The surrounding stack includes Redis/Valkey, TURN connectivity, recording workers, object storage, and private delivery.
That separation makes operational questions concrete: is the user authorized, is the event connection available, is the room connected, are tracks arriving, and has the recording been verified? Each answer belongs to a different boundary.
I favor readable Ruby, named services, explicit inputs, and focused adapters. The shape of the code should help the next person understand the business decision and where its effects belong.
Keyword arguments and injected collaborators make service boundaries easier to understand, replace, and test.
Validate at the boundary. Return structured results and useful domain errors. Keep transport concerns close to the adapter.
Distinguish invalid input, missing authority, temporary deferral, retryable failure, and terminal outcomes.
I look for what must stay true through duplicate delivery, concurrent requests, revoked permissions, partial results, and interrupted work.
def call(command)
validated = contract.validate!(command)
policy.authorize!(validated)
repository.transaction do
request = repository.claim_once!(validated)
outbox.stage_once!(request)
Result.accepted(
reference: request.public_reference
)
end
endSimplified to show the shape: validate, authorize, record intent, and stage delivery. The persistence layer owns uniqueness and conflict checks; external dispatch follows the commit.
Ruby and Rails are central to my application work. Around them, I use focused tools for data, interfaces, messaging, integration, and delivery.
Ruby · Ruby on Rails · SQL · JavaScript · TypeScript
Domain-rich applications, service objects, background workflows, and typed integration surfaces.
PostgreSQL · PostGIS · Active Record · SQLite
Relational modeling, multi-database boundaries, tenant context, transactions, spatial data, and query-driven product features.
NATS JetStream · Active Job · Solid Queue · Redis
Durable consumers, explicit acknowledgements, correlation, backoff, outboxes, and recoverable execution.
Hotwire · Turbo · Stimulus · Tailwind CSS · Hotwire Native · Swift · Kotlin
Server-rendered products, focused client-side behavior, live workflow state, and map-centered interfaces.
Action Cable · AnyCable · LiveKit · WebRTC · Redis / Valkey · TURN
Live subscriptions, presence, media permissions, room and track lifecycles, screen sharing, recording, and private playback.
REST · MCP · JSON Schema · OpenAPI · Faraday · OIDC
Discoverable capabilities, consistent request contracts, scoped access, provider adapters, and asynchronous results.
Neo4j · Cypher · OpenSearch
Relational-to-graph projections, bounded graph exploration, full-text retrieval, and knowledge-backed AI context.
Docker · Kamal · GitLab CI · Linux · AWS · Bash · Python
Container delivery, operational scripts, environment isolation, release artifacts, and repeatable local workflows.
Minitest · RSpec · Node.js test runner · RuboCop · Brakeman · OpenTelemetry
Contract and invariant tests, security checks, structured diagnostics, and tracing hooks across application boundaries.
My AI work includes building the interfaces models act through: tool catalogs, input schemas, authorization context, cost boundaries, execution policies, and retained results. I use deterministic validation and explicit workflow state around model-driven operations.
Architecture has to arrive as a useful product. I work on both the backend workflow and the interface that makes its state understandable.
Rails, Turbo, and Stimulus let me keep product behavior close to the domain while adding targeted interaction. I design status views around the real lifecycle of the work, including partial and delayed outcomes.
Maps are connected to geographic models, polygon validation, overlap and containment queries, area measurements, and data provenance. I work across the database and the browser so a map represents the underlying data coherently.
My Hotwire Native client foundations use Swift and Kotlin for secure device-side integration, including Keychain and Android Keystore. Business state stays with the platform; authenticated commands cross explicit boundaries.
I carry the work through verification and release, and record what the evidence actually establishes at each stage.
Inputs, ownership, authority, failure states, and acceptance criteria.
Focused tests, boundary checks, replay, and concurrency where it matters.
Source identity, build artifacts, configuration, migrations, and runtime evidence.
Browser behavior, persisted outcomes, and the workflow the user set out to complete.
Use environment checks, controlled execution, redacted diagnostics, and targeted recovery. Know which component owns the next action and what that action can change.
I write technical notes, contracts, runbooks, and handoffs that capture decisions, current evidence, remaining limits, and a clear continuation path.
My background spans founding, agency delivery, commerce, and CTO work. I connect technical decisions to operating cost, customer experience, maintainability, and the next business milestone.
For conversations about architecture, platform engineering, commerce, and technical leadership.
Talk about your project Back to my story