8 min
How I stop re-renders in big React forms: uncontrolled refs
Production tactics for large React forms: use uncontrolled inputs, refs, and event delegation to kill keystroke re-renders while keeping validation sane.
FrontendReactTypeScript
Field Notes
Architecture, agentic AI workflows, and shipping production systems at AI-speed.
53 entries
9 min
How I orchestrate React with a typed event bus
A production pattern I use to coordinate React components without prop drilling or store-bloat: a strictly typed event bus with React-safe hooks.
ReactTypeScriptFrontend Architecture
10 min
Optimistic React UIs that don't drift from the server
How I ship optimistic UI in React without state drift: versioned writes, idempotency keys, React Query/Zustand patterns, and the rollback math.
FrontendReactStateArchitecture
8 min
When useMemo actually helps in React 19, and how to measure it
A blunt, practical guide to useMemo in React 19: where it genuinely helps, where it’s noise, and how to profile renders before you cargo‑cult memoization.
ReactFrontendPerformance
10 min
Stop mixing render and domain state in React dashboards
A pragmatic split for large React 18 dashboards: keep server/domain data out of UI stores, cut re-renders and payloads with a thin serialization adapter.
ReactFrontendArchitecture
6 min
How I Went From My First Dev Job to Building AI Systems
Five years, honestly told: an ASP.NET healthcare backend in 2021, full-stack MERN through the ChatGPT shift, nights of embeddings homework, and finally shipping five AI products solo. The journey, without the gloss.
Founder's LogCareerJourney
7 min
Tauri + sqlx + SQLite: migrations and WAL for local apps
Practical guide to embedding SQLite in Tauri with sqlx: file location, compile-time migrations, WAL pragmas, and failure modes for single-user datastores.
TauriSQLiteRust
9 min
Zero Network Leakage in CI: Deny-by-Default Egress Harness
A practical, cross-platform harness to prove your desktop app makes zero outbound network calls in CI by default—block, log, count, and assert.
SecurityCI/CDDesktop
8 min
Unifying Twitch and YouTube Live Chat: Ordered, De-duplicated
Build a single, ordered, de-duplicated event stream from Twitch IRC and YouTube Live Chat with Hybrid Logical Clocks, watermarks, and idempotent delivery.
BackendRealtimeNode.jsStreams
8 min
On-Device Twitch IRC in Rust: Reconnect State Machine + Backoff
Build a fully local Twitch chat ingestor in Rust with a resilient WebSocket reconnect loop, exponential backoff with jitter, and a pragmatic state machine that survives flaky networks.
RustBackendRealtime
7 min
Serverless local-first settings sync over LAN with Automerge + mDNS
Replicate user settings across devices on the same LAN without servers by combining Automerge CRDT sync messages with mDNS peer discovery and a tiny TCP transport.
BackendCRDTsNetworkingLocal-First
7 min
Encrypt Tauri local storage at rest with age + OS keychain
A zero-cloud, cross‑platform pattern to encrypt Tauri local storage at rest using age (X25519) and the OS keychain for seamless key management.
SecurityTauriDesktop
8 min
Zero-Account Auth: Device-Bound Identity + Capability Tokens
Build secure apps without accounts or an auth server: bind identity to device keys, mint PASETO capability tokens, and enforce DPoP for stateless, least-privilege access.
BackendSecurityArchitecture
7 min
Kill Async Deadlocks in Tauri with Tokio Task Dumps + Tracing
A field guide to diagnosing and terminating async deadlocks in production Tauri apps using Tokio task dumps, tokio-console, and end-to-end tracing spans.
BackendRustTauriObservability
8 min
Zero-copy scene caches with memmap2: instant loads, no RSS bloat
Use memory-mapped files to load massive scene assets instantly and safely without duplicating data in heap and page cache. Concrete Rust patterns inside.
RustSystemsGraphics
8 min
Flamegraphs over Tauri IPC: from Rust event to React paint
A practical, end-to-end method to profile Tauri apps: correlate Rust spans with React paints, align clocks, and read a single cross-IPC flamegraph.
TauriPerformanceRustReact
8 min
SIMD sentiment scoring in Rust via WASM workers (no UI jank)
Build a SIMD-accelerated sentiment scorer in Rust, ship it as WebAssembly, and keep chat analysis off the UI thread without hurting battery or FPS.
RustWebAssemblyAI
6 min
I Shipped 5 Products in 12 Months — Solo, Unfunded, and Faster Than Most Teams Ship One
Five production systems — a Rust desktop cockpit, a workflow engine, a local-first AI finance agent, and two autonomous pipelines — designed, built, and shipped by one engineer. Here's the operating model.
Founder's LogVisionProducts
6 min
Vision Over Syntax: I Design the Entire Product in My Head Before the First Commit
Syntax is solved; vision is not. How architecture-first thinking — data contracts, trust boundaries, and deliberate refusals — is the real engineering skill in the AI era, shown through shipped products.
Founder's LogVisionArchitecture
7 min
One Architect + Claude + MCP = A Full Engineering Squad: The Operating Model I'd Install at Your Company
The exact three-layer operating model — architect, Claude Code, MCP-wired systems — that lets one engineer ship like a squad, and the 30-day plan for installing it inside a real company.
Founder's LogClaudeMCP
7 min
Your Company Is Overpaying for AI by 80% — I Built a Live Simulator That Proves It
Most production AI traffic is simple or repetitive, yet it's billed at frontier-model prices. The cache → flash → frontier cascade that fixes the economics, with a live interactive cost simulator.
Founder's LogFinOpsAI Infrastructure
6 min
My Networking Runs Itself: The LinkedIn Pipeline That Grew My Reach While I Slept
How I engineered consistency: an autonomous GitHub Actions pipeline that turns real work into scheduled LinkedIn posts, tracks state in Git, costs $0 to run — and what the same pattern automates inside a company.
Founder's LogAutomationProducts
6 min
The $0 Content Engine: My Blog Writes, Commits, and Deploys Itself Twice a Week
A cron-scheduled pipeline drafts articles with Gemini, writes MDX, commits to Git, and redeploys the static site — no CMS, no server, no database, no bill. The architecture of refusing infrastructure.
Founder's LogAutomationProducts
7 min
I Built an AI Money Agent That's Structurally Incapable of Touching the Money
Sable is a local-first AI financial agent: all data in on-device SQLite, no cloud backend, and a Review & Confirm boundary where the model proposes but only a human commits. The trust architecture, explained.
Founder's LogAI SafetyProducts
7 min
Everyone Said 'Just Use Electron.' I Wrote streamerOS in Rust — Here's What That Bought
streamerOS runs on the most contested consumer PC there is — game, encoder, OBS, chat. Why a Rust + Tauri core, on-device chat ingestion, and a MessagePack IPC bridge were the product decision, not a preference.
Founder's LogRustProducts
6 min
The 94% Decision: One Architecture Call That Made IntegrateX Feel Instant
Persisting React Flow's UI objects nearly sank the product. Drawing a serialization boundary between view and domain cut payloads 94% — the reasoning behind the call, and how to audit your own product for it.
Founder's LogArchitectureProducts
6 min
Hire My Head, Not My Hands: What 5 Solo Products Prove That a Résumé Can't
AI made hands abundant; heads stayed scarce. The closing argument of the Founder's Log series — the architectural judgment pattern across five shipped products, addressed to the person deciding whether to interview me.
Founder's LogVisionCareer
7 min
Shrink streamerOS Rust binaries: opt=z, fat LTO, panic=abort
A practical, measured look at how opt-level=z, fat LTO, and panic=abort shrink Rust binaries for production systems like streamerOS—and the trade-offs.
RustBackendSystems
7 min
Rust structured concurrency: cap media decoders w/ tokio JoinSet
Use tokio JoinSet and semaphores to bound parallel media decoders, enforce backpressure, and build cancellation-safe ffmpeg workers with structured concurrency.
RustConcurrencyBackend
9 min
Pinning a 1.8% Idle CPU: Evented vs Polling in Tauri Tray Apps
A ruthless, code-first look at hitting a ~1.8% idle CPU budget in long‑running Tauri tray apps by replacing polling with event‑driven plumbing.
TauriRustPerformanceArchitecture
7 min
Crossbeam SPSC ring buffers for 60 FPS Rust audio meters
Build a zero-allocation, lock-free SPSC ring buffer with crossbeam to stream audio metering data to a 60 FPS UI in Rust without contention.
RustAudioConcurrencyPerformance
7 min
A reproducible RAM-regression workflow in Rust with dhat + heaptrack
A practical, deterministic workflow to catch and bisect memory regressions in a Rust media pipeline using dhat for budgets and heaptrack for call stacks.
RustPerformanceTooling
8 min
Halving Tauri v2 IPC: Batch Events + rmp-serde MessagePack
Cut Tauri v2 Rust↔WebView IPC overhead by batching events and serializing with rmp-serde MessagePack, with concrete code for both sides.
TauriPerformanceRust
6 min
serde_json to simd-json in streamerOS IPC: hot-path deserialization
We replaced serde_json with simd-json in streamerOS’s IPC layer and benchmarked the deserialize hot path, showing where SIMD wins and where it doesn’t.
RustBackendPerformance
7 min
Tauri Rust Backpressure: Bounded vs Unbounded Channels for Chat Floods
Design a Tauri Rust core that survives chat floods without memory blowups using bounded channels, drop-oldest semantics, and time-based batching.
RustTauriBackend
7 min
Zero-copy Twitch IRC parsing in Rust with Bytes + nom at 5k/s
Build a zero-copy Twitch IRC parser in Rust using bytes::Bytes and nom to sustain 5,000+ messages/sec without heap churn or unnecessary allocations.
RustBackendStreaming
8 min
Rust arena allocation to keep streamerOS under 152 MB for 12h
Practical, code-first arena allocation patterns in Rust that kept our live-streaming OS under 152 MB RAM for 12-hour broadcasts with zero leaks.
RustSystemsStreaming
8 min
Tauri v2 + tokio-console: 1.8% CPU with 4 concurrent streams
A field-tested workflow to profile and tune a Tauri v2 Rust backend using tokio-console, slashing wake storms and sustaining 1.8% CPU across 4 streams.
RustTauriPerformance
7 min
Serialization Adapters: How I Cut Payloads by 94%
Rich UI objects make terrible database records. A Serialization Adapter I built for IntegrateX split render model from transport record and cut payloads by 94%.
PerformanceArchitectureReact Flow
8 min
WebSocket Telemetry at Scale: When One Process Isn't Enough
A single WebSocket server is a weekend project; streaming telemetry to thousands across instances broke for me on streamerOS — Redis pub/sub, rooms, coalescing.
WebSocketsReal-TimeBackend
7 min
MongoDB Aggregation Pipelines: Stage Order Is the Win
Profiling a clinical API taught me MongoDB aggregation pipeline optimization lives or dies on stage order: $match first on indexes, $lookup join performance, then explain.
MongoDBPerformanceBackend
9 min
Budgeting the Claude Context Window Before It Truncates You
The Claude context window is one token budget shared by prompt, tools, thinking, and reply. I count tokens and guard it in code so a reply never truncates.
AIAnthropicClaudeLLM Architecture
6 min
The AI-Native Portfolio: Landing Lead Roles by Shipping the System
A portfolio that lists 'used ChatGPT' reads junior. One that demonstrates systems architecture — RAG, agents, guardrails, latency budgets — reads like the lead they're trying to hire. Here's how to build the second one.
CareerAIArchitecture
8 min
The 10x Reality: How AI Replaced the Traditional MERN Squad
AI shifted the engineer's job from writing syntax to directing architectural flow. Why one architect with Claude now outships a traditional 10-person MERN squad.
AI OrchestrationMERNArchitecture
6 min
The Day ChatGPT Changed Full-Stack Engineering
Late 2022 dropped the cost of writing software overnight. Why the bottleneck moved from syntax to judgment — and why MERN engineers were positioned to win.
AIIndustryMERN
7 min
How I Run Agents Off a React Flow Canvas, Not a Diagram
On IntegrateX, the React Flow graph a PM drags is the exact spec the runtime executes — typed nodes and ports make it a debuggable agent orchestration layer.
React FlowAgentic AIArchitecture
8 min
Compressing the Wire: A 94% Payload Reduction in React Flow
Node-graph editors serialize enormous JSON. A custom Serialization Adapter pattern that separates the React Flow render model from the transport record cut IntegrateX payloads by 94%.
React FlowZustandPerformance
7 min
When Logs Lie: Tracing LLM Agents with OpenTelemetry
The live RAG concierge on this site ships a span per step — tokens, cost, latency in OpenTelemetry — which is how I trace LLM agents, not guess from logs.
AIObservabilityArchitecture
8 min
How I Compile a React Flow Graph So It Actually Runs
On IntegrateX a React Flow canvas stayed inert until I compiled it: a dependency map, a topological sort into a runnable plan, and cycle detection before it runs.
React FlowAgentic AIAlgorithms
9 min
Prompt Caching: the Ordering Discipline That Cuts the Bill
I treat prompt caching as FinOps: order the static prefix first, keep it byte-stable, and stop re-paying to re-read an 8K preamble on every request.
AIAnthropicClaudeCost Optimization
7 min
Semantic Caching That Actually Hits: Matching Meaning at the Edge
The streamerOS support agent kept re-answering the same question phrased ten ways, so I built a semantic cache that matches meaning, not the string.
RAGPerformanceCost Optimization
8 min
Real-Time Telemetry: Why Polling Lies, and WebSockets Don't
Polling dashboards lie between ticks — I learned that the hard way. Now I push telemetry over WebSockets for sub-second parity across every React client.
WebSocketsReactReal-Time
6 min
Cutting a Payload 94% With Custom Serialization Patterns
I cut a React Flow agent-graph payload 94% without losing a node — not with gzip, but by shaping a custom serialization format around the data: schema, not prose.
PerformanceArchitectureFrontend