Sean Bennett
Founder, 8Examples · Calgary, CanadaSoftware engineering / Selected work
From the first question
to a working system.
I build products, the integrations that make them useful, and the infrastructure that keeps them running.
This is the work behind 8Examples: business software, managed AI, commerce, mobile experiences, and the engineering investigations that support them. Explore the products, follow a workflow, or read the code.
01 / Product stories
Useful on the surface.
Considered all the way down.
A closer look at four products, the friction they address, and the decisions that make the workflow hold together.
Managed AI · Product + operations
OpenClaw + Hermes
An AI worker needs a whole service behind it.
For a small business, a useful AI worker needs an inbox, tools, a place to run, and someone keeping it working.
The managed service around OpenClaw and Nous Research's Hermes Agent: customer onboarding, isolated worker environments, subscriptions, business email, phone capabilities, model access, and fleet telemetry.
Inside the engineering
- A control plane provisions capabilities and configuration for each customer's worker.
- A shared model gateway handles failover and per-tenant usage budgets.
- Account and provisioning events preserve the history of trials, assignments, and recovery.
- Next.js
- TypeScript
- Docker
- Stripe
- SQLite
The managed service
/
Workspace · Configuration · Capabilities
Commerce · Client application
Disc Republic
Every disc is unique. The workflow should know that.
A disc golf shop sells individual discs with their own weight, color, and photograph. Entering each variant by hand holds up restocking.
An inventory workflow that starts at the counter: select a mold, take a photo, confirm the suggested color, record the weight, and send the individual disc to Shopify.
Inside the engineering
- Image processing prepares the product photo and estimates its color.
- Background jobs create individual Shopify variants and record success or failure.
- An append-only history explains where each disc is in the workflow and why.
- Next.js
- Shopify API
- SQLite
- Node.js
Logistics · SaaS product
CargoPax
Forward an email. Follow the whole delivery.
Shipment information is scattered across inboxes, carrier websites, and tracking formats. Following a parcel becomes a repeated manual task.
A shipment tracking product that receives forwarded emails, extracts tracking links, reads carrier pages in a browser, and emails updates as packages move.
Inside the engineering
- A dedicated mailbox per account makes email the natural entry point.
- Browser rendering and model-assisted extraction interpret carrier tracking pages.
- Number-format detection suggests a carrier, with an explicit choice when formats overlap.
- Next.js
- IMAP
- Browser automation
- SQLite
Marketplace · SaaS product
Nestled
One waitlist. A real offer. A place to start.
Families need a daycare place; providers need to fill openings. Separate waitlists make it difficult for either side to see a match.
A two-sided daycare platform: families join a city waitlist, providers make offers with dates and rates, families book tours and accept, and providers are invoiced when a place fills.
Inside the engineering
- Separate family and provider journeys meet in the same offer workflow.
- A nightly matcher introduces compatible families and providers by email.
- Matching, offers, and acceptance are recorded as events that explain the current state.
- Next.js
- TypeScript
- SQLite
- Event sourcing
The family side of the marketplace
02 / Client work + reference implementations
The difficult part is
where the work gets interesting.
Coordination under contention. Callbacks arriving out of order. Legacy SQL that compiles but changes the answer. These case studies show how those problems were worked through.
Cloud test infrastructure
Finning International
Make the regression suite fast enough to use.
An hours-long Playwright suite distributed across eighty Azure workers, with shard allocation, Terraform-managed infrastructure, and one merged report. Missing shard reports fail the run instead of leaving a misleading green result.
80-way fanout · 3-minute run in the case study
Azure Functions · Container Apps · Terraform · Playwright
Read the case study for Finning International→Client integration
Streamline Landlord Service
Keep a reliable record of every signature.
A DocuSign workflow for leases, condition reports, and maintenance contracts with multiple signers. Idempotent commands absorb duplicate and out-of-order callbacks while the event history shows who signed and who is still required.
Multiple signers · One traceable document history
DocuSign · Webhooks · CQRS · Event sourcing
Read the case study for Streamline Landlord Service→Migration reference implementation
SQL Server → PostgreSQL
Prove the behavior survives the migration.
A working proof of concept for a legacy database migration: convert schemas, repair unsupported SQL, and run the same behavioral checks against both engines. The reference includes orchestration designed for an estate of 3,000 databases.
39-table reference schema · 136 differential tests
SQL Server · PostgreSQL · AWS · C# · xUnit
Read the case study for SQL Server → PostgreSQL→03 / The wider body of work
Keep exploring.
More products, integrations, mobile work, and focused technical experiments. Search by problem or technology, and open the engineering notes for a closer look.
19 of 19 projects
Monitoring product
StatusNest
Domain monitoring that connects an outage to a person who can act on it, with customer dashboards and public website status pages.
- Next.js
- Playwright
- SQLite
- Event sourcing
Engineering notes
Customer monitors detect transitions to offline and hand urgent delivery to AlertTray. A separate Playwright browser checker powers public status pages. Per-user SQLite event stores keep each customer's monitoring history separate.
Notification platform + iOS
AlertTray
One notification API with delivery matched to urgency: iOS push, email, SMS, and a phone call for the alerts that need attention.
- Next.js
- Node.js
- APNs
- iOS
Engineering notes
A separate processor delivers queued notifications from an event-sourced backend. High and critical alerts use the phone gateway for calls and SMS; lower priorities use email alongside Apple push notifications. The native iOS app receives the same notification stream.
PDF signing workspace
Signet
Upload a PDF, type or draw a signature, place it across pages, and download a signed copy without creating an account.
- Next.js
- TypeScript
- PDFium
- SQLite
Engineering notes
Signature placement accounts for rotated and cropped pages while preserving selectable text. Browser workspace keys authorize server-side documents; version checks and command IDs handle conflicting edits and retries. These are visible electronic signatures, not certificate-based digital signatures.
Bilingual hiring platform
8Examples ATS
An English/French applicant tracking system covering job postings, applications, screening, interviews, scoring, and offers.
- Next.js
- PostgreSQL
- CQRS
- en-CA / fr-CA
Engineering notes
The implemented core includes tenant isolation, scoped staff roles, independent scoring, consensus gates, interview booking, and rebuildable projections over PostgreSQL. Its repository explicitly separates delivered features from deferred integrations and audits.
Self-hosted file delivery
File Share
The sender signs in; the recipient opens a link. A deliberately simple way to share files and short notes.
- Next.js
- TypeScript
- iron-session
Engineering notes
Uploads stream to disk, files receive UUID-based addresses, and unpinned content expires automatically. Authentication stays on the upload side, keeping the receiving workflow short. A recorded walkthrough demonstrates uploads, notes, links, and expiration.
Client application
Private Photo Sharing
A private travel photography site with albums for friends and family, accessed through shareable links.
- Next.js
- SQLite
- Event sourcing
Engineering notes
Album changes, uploads, moves, rotations, and access keys are recorded as events. Photos live on the application's own disk, while the ledger preserves the history behind the current gallery. The design fits a personal collection and its actual operating budget.
Shared AI infrastructure
Model Gateway
A common model endpoint for a fleet of AI workers, with upstream failover, tenant accounting, and controlled token budgets.
- Go
- HTTP / SSE
- Circuit breakers
- Quotas
Engineering notes
Circuit breakers bypass unhealthy providers, tenant stickiness preserves prompt caches, and quotas persist across restarts. Failover happens before a response starts streaming; an answer is never silently spliced between models midstream.
Voice integration
Phone Call Gateway
A WebSocket control stream that lets an AI application speak into a real phone call and receive the caller's transcribed reply.
- TypeScript
- WebSockets
- Twilio
- Speech APIs
Engineering notes
Streaming speech synthesis and transcription connect to Twilio calls. Local signal processing annotates speech volume and pace. Protocol-compatible fake providers let integration tests exercise the call pipeline without placing real calls.
SwiftUI + Apple Wallet
Gym Pass + Wallet API
Turn a membership number into a scannable Apple Wallet pass that is available on an iPhone and Apple Watch.
- SwiftUI
- PassKit
- Node.js
- PKCS#7
Engineering notes
The SwiftUI app gathers the member ID and hands the returned pass to PassKit. A separate service assembles and signs the .pkpass bundle. Deterministic serial numbers allow regeneration to replace a pass rather than create duplicates.
Network observability
LAN Observatory
A local-network honeypot that makes unexpected TCP, SSH, and web traffic visible in an authenticated dashboard.
- Python
- Docker
- SQLite
- Next.js
Engineering notes
A collector records protocol events into SQLite. SSH interaction runs inside a constrained Docker sandbox with no network or host mounts, and the web decoy records requests and responses. The result is an inspectable timeline of what touched the network.
Executable reference
C# Language Features
C# language evolution explained through individual examples and assertions, with projects pinned to the version being demonstrated.
- C#
- .NET
- xUnit
- FluentAssertions
Engineering notes
A separate project for each language version lets the compiler enforce the historical syntax boundary. Feature examples sit beside their xUnit assertions, and tooling regenerates the documented results from test output.
Executable reference
TypeScript Language Features
Version-by-version examples that test both what TypeScript does at runtime and what its type system accepts or rejects.
- TypeScript
- Jest
- Compiler API
Engineering notes
Jest exercises behavior, type assertions check compile-time contracts, and compiler API tests cover flags and emit behavior. Each example points back to the relevant release notes, making the repository useful as a working reference.
Executable reference
JavaScript Language Features
ECMAScript features organized by standard edition, with runnable examples tested directly on Node.js.
- JavaScript
- Node.js
- Jest
Engineering notes
Edition-specific folders make language changes easy to inspect. Tests run natively without Babel or polyfills, so the result demonstrates support in the runtime itself. CI produces a per-edition test summary.
Compiler tooling
Custom C# Analyzer Rules
Turn a domain modeling convention into a compiler rule that catches violations while the developer is writing the code.
- C#
- Roslyn
- Static analysis
Engineering notes
The SMART001 Roslyn analyzer enforces the repository's Smart Enum convention. A compliant sample and intentional violations demonstrate both sides of the rule, making the architectural constraint executable.
Performance investigation
.NET Thread-Pool Starvation
A reproducible comparison of blocking and asynchronous request handling, with telemetry to explain the difference.
- ASP.NET Core
- xUnit
- Telemetry
Engineering notes
An ASP.NET Core API exposes blocking, async, and telemetry endpoints. The test suite drives a workload against both implementations and asserts on thread-pool behavior, turning a production failure mode into a repeatable experiment.
Database investigation
SQL Server Indexes
A SQL Server performance lab comparing index structures against repeatable datasets, with measured timings and logical reads.
- SQL Server
- SQL
- .NET
Engineering notes
Docker hosts SQL Server while xUnit runs index scenarios against deterministic data. The lab compares heaps, covering indexes, columnstores, full-text search, and other structures. Generated reports capture observations from the test environment without turning local timings into universal performance promises.
.NET query investigation
IQueryable vs. IEnumerable
A focused exploration of how a .NET query's shape changes where work happens and what reaches the database.
- C#
- LINQ
- Entity Framework Core
- xUnit
Engineering notes
Entity Framework Core tests assert on the SQL generated for filtering, projection, and counting against SQLite. Separate in-memory examples instrument a yield enumerator to show when each element is pulled. The comparison exposes where a query crosses from database execution into application memory.
Reusable UI behavior
Vue Copy Directive
A Vue 3 clipboard directive with reactive values, success and error callbacks, and deliberate lifecycle cleanup.
- Vue 3
- TypeScript
- Jest
- Playwright
Engineering notes
Unit tests cover events, updates, failures, and listener removal. Playwright exercises the real browser Clipboard API, connecting the small reusable abstraction to the browser behavior it promises.
Application foundation
Event-Sourced Starter Sites
A reusable foundation for tenant accounts, command/query APIs, event history, and asynchronous processing.
- Next.js
- TypeScript
- SQLite
- CQRS
Engineering notes
A small item workflow demonstrates every layer: a user submits work, a processor finds it through a query, and a command records completion. Tenant databases, authentication, retry behavior, and health checks give new products an operational starting point.
A consistent engineering practice
Different domains.
The same care in the details.
Make the behavior concrete.
Walk through the user's timeline. Define what a command means, what becomes true, and what the next person should see. This is where the product's real requirements emerge.
See the inventory event model →Design for the second attempt.
Webhooks arrive twice. Providers fail. A worker restarts halfway through. Idempotency, explicit failure events, retry boundaries, and recoverable state make those cases part of the design.
See the signing workflow →Leave evidence behind.
Behavioral tests, readable event histories, repeatable deployments, and useful telemetry make a system easier to change and operate after the first release.
See the migration verification →The reasoning is part of the work
Implementation notes, in the open.
The blog follows the decisions behind these projects, from event sourcing and deployment to model gateways, voice integrations, and browser testing.
04 / Working together
What are you
trying to make work?
A new product, a difficult integration, a migration that needs proof, or an existing system that needs to become easier to operate. Bring the problem; we can work through the shape of the solution.