I work on data infrastructure, agent systems, and application platforms. A few things tend to recur: data durability and consistentcy as a starting point, schema and specs as infrastructure, reactive data flows, and a small operational surfaces. KISS. The problems vary — the structural instincts are astonishingly reliable.
I start with how a system recovers, not how it runs. Get the durability model right — write-ahead logs, immutable versions, append-only records, idempotency of data and infra — and the rest of the design has a foundation to build on. Schemas are a first-class concern: inferred at boundaries, declared in domain models, enforced at parse time. Multi-tenancy always goes into the data model early, not the application layer late.
I'm drawn to reactive systems — architectures where state changes propagate outward and clients converge without coordination. That shows up as event streams, change-data capture, push delivery — whatever the domain calls for. And wherever possible, the deployment target is a single process in a binary or a lambbda function: fewer moving parts, less to operate, no God damn clusters.
The problem: getting heterogeneous, messy data from operational sources into a queryable warehouse — reliably, without a platform team. Skippr infers schemas from samples, evolves them as sources change. Truely unmergeable records (and they have to be really bad) are routed to dead-letter tables rather than dropping or corrupting them. A write-ahead log absorbs ingestion, a compactor produces columnar files and registers catalog partitions. One process, multi-threaded, crash-safe, no coordination layer. Consistency across threads with competing schema evolution writes in knarly... as is infering schemas based on record field values, and handling event time, and determinsitc WAL writes so their crash-safe even when your disk FS lies to you.
The problem: getting language models to do useful, governed work against live data systems. Also trying to avoid the hype-cycle. The runtime defines suites — tool registries, adptors, plugins,policies, prompt strategies — that scope what an agent can do. A data engineering suite walks a phased workflow: discover a catalog, plan transformations, author models, validate against a warehouse, review, publish. Agents that need human input or approval hit interrupt gates. Sessions persist and resume across connections. Frankly, it's much better thought through than OpenClaw, and so can realyably perform useful work.
The problem: modelling structured case progression for regulated industries without hard-coding business logic into the application. Decisioning lives in a rules engine — routing, applicability, gating. Presentation lives in content definitions — question types, validation, evidence requirements, completion criteria. Workflows compose a versioned rule set with a versioned content set and an optional lifecycle state machine. Published versions are immutable and instances pin to the version they started with.
The problem: coordinating state across devices, notification channels, and app store payment systems in a consumer product. Matching, messaging, and feed interactions propagate through an event-driven backend. Push delivery manages device token lifecycles, deduplicates against active connections, and handles platform differences between APNs and FCM. Deep linking resolves through server-side association files for both iOS and Android. Purchases verify through App Store Server Notifications with a transaction audit trail.
The problem: designing a reward system that drives engagement without crossing regulatory boundaries. Users accumulate XP through learning; monthly pools distribute rewards by tier using weighted random selection. The constraint — payouts are promotional spend, not investment returns — shapes every design decision: the ledger structure, the pool sizing model, the compliance copy. A structural framing problem, not just a product one.
The problem: shared awareness during operational incidents. Alarms arrive from monitoring, get parsed and enriched with ownership metadata, and enter a lifecycle: triggered, acknowledged, silenced, resolved. State changes propagate through event streams to a dashboard so every participant sees the same picture. The goal is convergence and consistnecy — eliminating the gap between what the system knows and what the people responding to it know.
Ingestion, schema management, columnar storage, catalog registration. Getting data from where it is to where it's useful — correctly and without operational overhead.
Tool-use orchestration, action parsing, policy enforcement, phased workflows. Making language models operate on real systems with governance and human oversight.
Event-driven architectures, change propagation, push delivery, state convergence. Systems where participants see the same data without asking for it.
Rules engines, structured case progression, version-pinned instances, lifecycle state machines. Encoding domain logic declaratively so it can evolve without rewriting applications.
Incident management, cloud platforms, developer and data tooling. Tools that keep engineering teams building and systems running.