Services

End-to-end delivery for regulated and high-stakes work

Skeptic Dog Software is the independent practice of a software engineer taking compliance-critical platforms, data and telemetry pipelines, and cross-platform mobile from first spec to production. I own the whole arc — architecture, build, verification, and the client conversation — with the discipline that fault-intolerant domains demand.

Regulated, high-stakes production systems

Full-stack architecture and build for environments where an audit can fail you — SOC 2, FedRAMP-High, PCAOB, HIPAA, HITRUST, PCI DSS, and ISO — with reasoning and audit evidence traceable to the controlling standards.

Who it's for: teams shipping into attested environments: healthcare, cybersecurity, audit and controls testing, and other domains where a single compliance finding can stop the business.
The problem: compliance is usually bolted on after the build, so evidence is reconstructed by hand and the architecture can't actually prove the controls it claims to enforce.
What I deliver: backends on the runtime the problem demands: Rust on Lambda for zero-cold-start serverless surfaces, or Java virtual threads where massive I/O concurrency is the constraint, traceable reasoning to controlling standards, structured audit logging, and controls-testing surfaces — with architecture invariants like multi-tenant isolation and single-writer chokepoints enforced as executable tests, not documents.
The outcome: a platform whose compliance posture is designed in and demonstrable, with zero client-evidence egress to shared LLMs. Proven on the flagship: a four-service regulated controls-testing platform architected and shipped in under six months.

Data and telemetry platforms

Streaming ETL and evidence pipelines built for scale and correctness at the same time — for large files and high-rate feeds where volume and integrity pull against each other.

Who it’s for: organizations moving large or high-rate data: 10GB+ evidence files, industrial and IoT telemetry, healthcare feeds (DICOM/HL7), and real-time event streams feeding many consumers at consumer scale.
The problem: naive pipelines either fall over at scale or quietly corrupt the record teams later depend on, and by then the damage is in the temporal history.
What I deliver: streaming ETL in Rust and Polars that never loads large files whole, over Postgres, bitemporal XTDB for a temporal evidence store, Memgraph knowledge graphs, and Redis for exactly-once outbox/inbox and message brokerage — with STOMP/WebSocket delivery for realtime updates to the client — and Kafka where one event has to reach many consumers at once, as it does in hiring, telemetry, and operational feeds.
The outcome: pipelines that hold their throughput and their integrity under real load, backed by a temporal, queryable record of what happened and when.

Cross-platform and native mobile

Field-grade mobile built for real conditions — intermittent networks, live sensor streams, and data you cannot afford to lose.

Who it’s for: sports, outdoor, industrial, and enterprise teams capturing data away from a reliable network.
The problem: real field conditions mean patchy connectivity and continuous sensor input; apps that assume a live connection lose data exactly when it matters most.
What I deliver: Flutter and native iOS/Android built offline-first, with background sync and sensor/MQTT integration, applying the same data discipline as the backend — for field data capture, performance tracking, and logistics.
The outcome: apps that keep working off-network and reconcile cleanly on reconnect, so the captured record stays complete.

How I choose the stack

The problem picks the stack — not the other way around

I am not a Rust shop or a Java shop. I’ve shipped Rust-serverless architectures — an e-signature service, an investor data room, and an equity cap-table engine — alongside a Java audit platform over a bitemporal store, streaming Rust ETL, and cross-platform Flutter. Each stack is chosen for what the problem actually demands, not the other way around.

Rust: Zero cold start and no idle cost — memory-safe and garbage-collector-free, so serverless endpoints wake instantly and cost nothing when no one is calling.
Java 25: Virtual threads — tens of thousands of concurrent I/O operations without exhausting a thread pool or drowning in callbacks.
Flutter: One codebase, natively cross-platform — iOS, Android, and web from a single codebase instead of three parallel rewrites.
Dart on the web: Behavior that lives inside the browser and cannot be lifted by a scraper — interaction and logic that never reduce to a static page.
Polars: Stream 10GB+ files column by column, never loading them whole into memory — where a naive pipeline runs out of RAM.
XTDB: Bitemporal by design — answer what the record said and what was known as of any date, the question an audit trail lives on and a relational store cannot.
Kafka: Fan one event out to many consumers in real time — device telemetry, operational feeds, and event streams — where a request/response API collapses under the read volume and a nightly batch answers too late.
S3 + Apache Iceberg: Warehouse-grade tables — ACID commits, schema evolution, snapshot time-travel — on cheap, open object storage, without paying for a data warehouse.

How the work gets done

Three practices under every engagement

Whatever the domain, these keep the delivery fast, reliable, and defensible on cost.

AI-native delivery

spec-first, agent-fleet development in isolated worktrees, with adversarial multi-round review gating every merge. LLM output never touches a result directly: deterministic verification checks every model-generated artifact before it counts. Speed, without ever trusting a model blind.

Scale and soak testing

sustained-concurrency load testing on every serious path, targeting 10x expected average use where feasible. In deadline-driven domains the load concentrates, so peak arrives with peak customer stakes — I test for that, not the average.

Cost and margin engineering

unit costs metered as a first-class part of the pipeline, deterministic paths wherever determinism suffices, and inference reduced to the smallest surface that still does the job. Margin is designed into the architecture, and every choice is logged against its cost rationale and reversal criteria.

Engagement model

One engineer, end to end

Uncompromising on discipline — from first spec to production and into real-world adoption.

Sized to the work: engage me for a defined scope, or for end-to-end ownership of the whole build.
End-to-end ownership: one engineer responsible for architecture, build, verification, and the client conversation.
Spec-first: the feature is specified and its edges interrogated before code, then adversarial review gates every merge.
Architecture enforced as executable tests: multi-tenant isolation, single-writer chokepoints, and thread discipline fail the build rather than living in a document.
Provenance by default: every architectural decision logged with reversal criteria, and a cryptographically signed, verifiable history throughout.

Start a conversation

If you’re building into a regulated or high-stakes environment and want it owned end to end, let’s talk about the work.

Start a conversation