Blog
Practical insights on building MVPs, choosing the right tech stack, and turning ideas into production-ready apps.
SQLite Partial Indexes and Expression Indexes in Mobile Apps: The Query Optimization Techniques That Cut Our Room Database Read Times by 80%
Deep dive into SQLite's underused partial indexes (CREATE INDEX ... WHERE) and expression indexes for common Room/mobile patterns — filtering by is_synced, crea
Subscription Recovery Architecture for iOS and Android: Grace Periods, Billing Retry, and the Server-Side Webhook Pipeline That Recovers 15% of Involuntary Churn
Deep technical walkthrough of implementing server-side subscription lifecycle handling across StoreKit 2 and Google Play Billing 7 — processing DID_FAIL_TO_RENE
ARM NEON SIMD for real-time audio on Android NDK
Deep dive into using ARM NEON SIMD instructions via Android NDK for real-time audio DSP — covering lock-free ring buffer design for the audio thread, vectorized
Kotlin Coroutine Structured Concurrency Pitfalls in Production: SupervisorScope, Exception Propagation, and the Cancellation Architecture That Prevents Silent Data Loss
Deep dive into how structured concurrency actually behaves in production Kotlin backends and Android apps — covering the subtle differences between coroutineSco
Adaptive Bitrate Model Loading on Android: Dynamic GGUF Shard Selection Based on Runtime Memory Pressure and Thermal State
Build an adaptive model loader that monitors ActivityManager.getMemoryInfo(), thermal callbacks via PowerManager, and GPU memory headroom to dynamically select
gRPC Bidirectional Streaming in Mobile Apps: Connection Resumption, Deadline Propagation, and the Flow Control Architecture That Handles Unreliable Networks
Practical implementation of gRPC bidirectional streaming on Android (grpc-kotlin with coroutine Flows) and iOS (grpc-swift with AsyncSequence), covering mobile-
eBPF observability that replaced our $4K/month APM
Walk through building a practical eBPF-based observability pipeline for a startup's Kubernetes cluster — covering BPF CO-RE for portable probes, per-pod HTTP la
Gradle Build Cache Deep Dive: Content-Addressable Storage, Remote Cache Invalidation, and the Configuration That Cut Our KMP CI Times by 65%
Walk through how Gradle's build cache actually works internally — content hashing, relocatability requirements, and the specific cache poisoning scenarios that
KV Cache Quantization for On-Device LLM Inference on Android: INT4 Attention States, Sliding Window Eviction, and the Memory Architecture That Fits a 7B Model in 4GB RAM
Deep dive into KV cache memory management for on-device LLM inference — covering how quantizing key-value attention caches from FP16 to INT4 with group-wise sca
Streaming LLM Tokens to 10K Concurrent Users: Backpressure, Coroutine Channels, and the SSE Fan-Out Architecture That Scales Without Melting Your Server
Engineering deep-dive into scaling server-sent event streams for LLM token-by-token delivery — coroutine-per-connection with structured concurrency, bounded cha
Eliminating Android ANRs in Production: Strict Mode Traps, Binder Transaction Limits, and the Background Thread Architecture That Dropped Our ANR Rate From 2.1% to 0.08%
Deep dive into the three most common ANR root causes in production Android apps — accidental main-thread disk I/O triggered by SharedPreferences.apply() during
PostgreSQL Connection Pooling Under Pressure: PgBouncer Transaction Mode, Prepared Statement Workarounds, and the Pool Sizing Formula That Actually Works for Multi-Tenant SaaS
Deep dive into the real-world pain points of PostgreSQL connection pooling — why transaction-mode PgBouncer breaks prepared statements (and the DEALLOCATE ALL /
SDK: google-generativeai (pip install google-generativeai)
Practical guide to integrating voice input and voice output in chatbots using Gemini APIs. Two different approaches: standard API for pre-recorded audio transcr
What Happens in the 400ms Between Your API Call and the LLM Response
Deep dive into the full infrastructure journey of an LLM API call: API gateway, load balancer, tokenization, model router, prefill/decode inference, post-proces
Claude Code Slash Commands That Actually Save You Hours
Practical guide to the most useful Claude Code slash commands and shortcuts. Not a full list of 93 but the ones that matter most for daily dev workflow: context
Kotlin lazy {} Has 3 Modes and You're Probably Using the Wrong One
Deep dive into LazyThreadSafetyMode in Kotlin: SYNCHRONIZED vs PUBLICATION vs NONE. When to use which, performance implications, and why blindly using the defau
Agentic gatekeeping: how AI controls what you buy
How InPost, Amazon, Alibaba and Xiaohongshu use AI ranking algorithms to control purchase intent. The mechanism behind semantic filtering in e-commerce: who ran
The Perfectionism Trap: When Your Developer Brain Fights Your Founder Brain
How engineer-turned-founders struggle with perfectionism, shipping before ready, and the painful shift from code quality to business perspective. Practical advi
Kotlin Name-Based Destructuring: The Silent Bug Fix Most Devs Missed
Kotlin 2.3.20 introduces name-based destructuring (experimental). For years, data class destructuring was position-based, causing silent bugs when property orde
Zero downtime schema migrations in distributed DBs
How distributed databases (CockroachDB, YugabyteDB, TiDB, Spanner) handle schema changes vs single-node PostgreSQL. Cover online DDL, schema versioning, and mig
Expand-Contract Pattern vs Blue-Green Deployment for PostgreSQL Schema Migrations
Compare two major strategies for zero-downtime schema changes. Expand-contract: add new column, migrate data, drop old. Blue-green: run two schemas in parallel,
Zero Downtime Database Migrations: A Practical Guide for PostgreSQL
Step-by-step guide to performing schema migrations in PostgreSQL without any downtime. Cover ALTER TABLE tricks, CREATE INDEX CONCURRENTLY, adding columns with
Investing in Top Companies and ETFs: A Developer's Practical Guide to Building a Portfolio
Practical investing workshop for tech professionals — how to identify market leaders, evaluate ETFs, build a diversified portfolio covering stocks, commodities,
Stop using OFFSET for pagination — it won't scale
Deep dive into why LIMIT+OFFSET degrades linearly with dataset size, and how keyset (cursor) pagination solves it. Cover the scan-and-discard cost, index seek v
CLAUDE.md best practices: 8 patterns that work
Practical guide to CLAUDE.md, skills, hooks, local context files, and progressive disclosure — how to structure your repo so Claude Code actually understands yo
Google Rejected My Developer Account So I Filed a Legal Complaint and Won — They Paid 250 EUR
Step-by-step guide on using ADR (Alternative Dispute Resolution) to appeal Google Play developer account rejection. Real experience: filed complaint, took one m
.github/workflows/migrate.yml
Head-to-head comparison of expand/contract pattern and blue-green deployment for PostgreSQL schema migrations. Cover advisory locks, ghost tables, CREATE INDEX
Distributed tracing on a budget with OpenTelemetry and Grafana
Walk through setting up a complete observability pipeline for a startup's backend using OpenTelemetry Collector with tail-based sampling policies, Tempo for tra
Replacing Your Message Queue with PostgreSQL: SKIP LOCKED Queues, LISTEN/NOTIFY Pub/Sub, and the Transactional Outbox Pattern That Eliminates Dual-Write Bugs Without Adding Infrastructure
Deep dive into PostgreSQL-native patterns that replace Redis/RabbitMQ for startups under scale: FOR UPDATE SKIP LOCKED as a job queue, LISTEN/NOTIFY for real-ti
nvidia-device-plugin ConfigMap
Deep dive into running mixed-priority LLM inference workloads on shared GPU nodes using Kubernetes device plugins, NVIDIA MPS for time-slicing, and a custom pri
Record thermal + sched + freq data for 60 seconds
Deep dive into how Android's thermal management framework (thermal HAL, cooling devices, trip points) actively sabotages long-running on-device LLM inference, w
Speculative Decoding on Android: Running Draft-and-Verify LLM Inference On-Device with Dual GGUF Models and the Token Acceptance Pipeline That Doubles Generation Speed
Implementing speculative decoding on-device using a small draft model (0.5B) paired with a larger target model (8B), covering the parallel verification algorith
WebGPU Compute Shaders for On-Device LLM Inference in Android WebViews: The GPU Pipeline That Bypasses NNAPI Limitations
Using WebGPU compute shaders via Android WebView to run quantized LLM matrix multiplications on mobile GPUs, bypassing NNAPI's operator coverage gaps and vendor
Idempotent API Design for Mobile Payment Flows: Request Fingerprinting, Server-Side Deduplication Windows, and the Exactly-Once Architecture That Prevents Double Charges on Flaky Networks
Deep dive into implementing idempotency keys with server-side deduplication using PostgreSQL upserts and TTL-based cleanup, client-side retry strategies with Ok
Kotlin/Native GC tuning that cut P99 latency by 60%
Deep dive into Kotlin/Native's modern memory manager internals — how the tracing GC with cycle collection actually works under the hood, practical mimalloc allo
Server-driven paywall A/B testing that moves revenue
Build a server-driven paywall system where offer presentation, discount tiers, and exit-intent triggers are controlled remotely without app updates. Cover the f
Predictive Prefetching in Android with TensorFlow Lite: Training Navigation Models on User Session Data and the On-Device Inference Pipeline That Cut Our P95 Screen Load Time by 40%
Building a lightweight sequential prediction model trained on anonymized navigation logs, converting to TFLite with dynamic quantization, running inference in a
Gradle build cache deep dive: how we cut 70% of redundant KMP compilation
Walk through how Gradle's build cache actually works at the hash level — task input fingerprinting, path sensitivity, relocatability pitfalls with KMP expect/ac
Zero-downtime schema migrations in production PostgreSQL
Deep dive into how tools like pg_osc and pgroll perform online schema changes — using advisory locks to coordinate migration workers, shadow/ghost table copy-an
.github/workflows/api-compat.yml
Deep dive into practical API versioning strategies beyond the usual REST basics — comparing URL-path versioning, custom header negotiation (Accept-Versioned), a
Container image caching in GitHub Actions: 12 min to 90 sec
Deep dive into Docker BuildKit's cache mount feature, registry-backed cache layers with --cache-to/--cache-from, and multi-stage build patterns specifically opt
How to calculate true startup CAC with organic traffic
Break down the difference between blended CAC and paid CAC, show how misattributing organic signups to paid channels inflates your unit economics, walk through
Streaming LLM responses to mobile: SSE vs WebSockets
Deep dive into the end-to-end plumbing of streaming token-by-token LLM output from a Ktor backend to a Jetpack Compose UI — covering SSE vs WebSocket tradeoffs
.github/workflows/ai-review.yml
Practical setup of a locally-hosted agentic coding loop using the new Qwen3.6-35B-A3B mixture-of-experts model — covering quantization choices (GGUF Q4_K_M vs Q
Modularizing Your Android Build with Convention Plugins and Version Catalogs: The Gradle Architecture That Cuts CI Time in Half
Deep dive into Gradle convention plugins using buildSrc vs build-logic composite builds, TOML version catalogs with bundle declarations, and the dependency grap
Keyword cannibalization in ASO: a data-driven fix
Deep technical dive into how App Store and Play Store search algorithms handle keyword weighting across title, subtitle, keyword field, and description — with a
Cohort retention curves: the PMF signal in your data
Move beyond vanity metrics with concrete PostgreSQL cohort analysis queries, specific retention benchmarks by app category (Day 1/7/30), the flattening-curve si
Building an LLM gateway that cuts your AI bill by 70%
A technical deep-dive into building a self-hosted LLM proxy layer that sits between your mobile/web clients and model providers — covering model routing and aut
Validating Your Startup Idea with a Landing Page, Waitlist, and Stripe Test Mode in One Weekend
A step-by-step technical walkthrough of wiring up a Next.js landing page with Posthog analytics, a Resend-powered waitlist, and Stripe test-mode checkout to mea
Spot node pool configuration
Deep dive into replacing GitHub-hosted runners with self-hosted runners on AWS/GCP spot instances orchestrated by actions-runner-controller, covering graceful j
SQLite on the server: the single-node architecture handling 100K req/s
SQLite on the server as a PostgreSQL replacement for indie and startup workloads — covering Litestream for continuous S3 replication, WAL mode tuning on ext4/bt
Fine-Tuning Whisper.cpp for On-Device Speech-to-Text in KMP: Quantization Strategies, Audio Preprocessing Pipelines, and the Streaming Architecture That Delivers Real-Time Transcription Without Cloud Costs
Deep technical walkthrough of integrating Whisper.cpp into a Kotlin Multiplatform project using expect/actual declarations for platform-specific audio capture (
Running Vision-Language Models On-Device in Android
Technical deep-dive into running VLMs (LLaVA/MobileVLM-class) on Android — covering the dual-model architecture (CLIP vision encoder + language decoder), INT4/I
Android Baseline Profiles and Macrobenchmark in 2026: Measuring Real Startup Time Improvements Across Dex Layouts, Cloud Profiles, and the ART Compilation Pipeline
Deep dive into how Baseline Profiles actually work under the hood — AOT compilation via cloud profiles vs on-device profile-guided optimization, how dex layout
Structured output from on-device LLMs on Android with GBNF
Move beyond raw text generation to building agentic features with on-device models — covering GBNF grammars for structured JSON output via llama.cpp, function-c
Change data capture replaces polling for mobile sync
Building a CDC-powered sync pipeline using PostgreSQL logical replication slots and Debezium to push granular data changes to mobile clients. Covers WAL decodin
On-Device RAG for Android: Running Embedding Models, Vector Search in SQLite, and the Retrieval Architecture That Keeps Sensitive Data Off the Wire
Build a fully offline retrieval-augmented generation pipeline on Android — quantized embedding models via ONNX Runtime, HNSW vector indexing inside SQLite with
Kotlin Context Parameters in Practice: Replacing Service Locators, Scoping Database Transactions, and the Zero-Boilerplate Patterns That Make Clean Architecture in KMP Actually Clean
Deep dive into Kotlin 2.2's context parameters as an architectural primitive — how they eliminate manual dependency threading across call chains, scope database
JSONB indexing: GIN vs expression indexes for mobile APIs
Deep dive into how mobile backends abuse JSONB columns as a 'schema-free' escape hatch, then suffer catastrophic query performance at scale. Cover GIN index int
PostgreSQL partial indexes: drop your app-layer uniqueness checks
Deep dive into combining partial unique indexes (WHERE deleted_at IS NULL) with deferred constraint checking and tenant-scoped composite indexes to enforce comp
gRPC and Protocol Buffers for Mobile API Backends: Binary Wire Format, Bidirectional Streaming, and the Code Generation Pipeline That Gives You Type-Safe Clients Across Android, iOS, and KMP with 60% Less Payload Than REST+JSON
Deep technical comparison of gRPC vs REST for mobile backends — covering protobuf schema design for mobile-friendly field evolution, gRPC-Web as a fallback for
PostgreSQL advisory locks beat Redis for rate limiting
Using pg_try_advisory_xact_lock with connection pooling (PgBouncer in transaction mode) to implement sliding-window rate limiting directly in PostgreSQL, elimin
Swift 6 + Kotlin coroutines: fixing KMP data races
Deep dive into the real friction points when KMP-exported Kotlin coroutine-based APIs cross into Swift 6's strict concurrency world — how @Sendable closures, gl
Compose Multiplatform's Skia Rendering on iOS: Profiling Metal Shader Compilation Stalls, Texture Atlas Thrashing, and the Platform-Specific Patterns That Actually Hit 120fps on ProMotion
Deep dive into the Skiko/Skia rendering pipeline on iOS — how Compose Multiplatform bypasses UIKit, why first-frame Metal shader compilation causes hitches, how
On-Device LLM Inference via KMP and llama.cpp: Memory-Mapped Model Loading, ANE/NNAPI Accelerator Delegation, and the Thermal Budget Patterns That Make 3B-Parameter Models Production-Ready on Mobile
Build a KMP shared module that wraps llama.cpp through cinterop (iOS) and JNI (Android), covering mmap-based model loading to avoid OOM kills, hardware accelera
Ktor at 50K connections: coroutines vs virtual threads
Deep technical comparison of Ktor's coroutine dispatcher vs JVM virtual threads (Project Loom) for high-concurrency mobile backends — thread pinning pitfalls, s
PostgreSQL RLS: your last defense against tenant data leaks
Deep dive into implementing RLS policies as the last line of defense against tenant isolation bugs — covering policy design with current_setting vs session vari
PostgreSQL LISTEN/NOTIFY as a lightweight job queue: replacing Redis for your startup's background tasks
Building a zero-dependency job queue using PostgreSQL's LISTEN/NOTIFY channels with SKIP LOCKED advisory locks, comparing throughput benchmarks against Redis-ba
SQLite WAL Mode, Connection Pooling, and Room's Query Planner: The Mobile Database Performance Patterns That Survive Offline-First at Scale
Deep dive into SQLite's WAL vs DELETE journal modes, how Room's InvalidationTracker triggers unnecessary recomputations, connection pool sizing for concurrent r
Compose stability: the recomposition model senior devs get wrong
Deep dive into how the Compose compiler assigns stability to types, how strong skipping mode (default since Compose Compiler 2.0) changes the old mental model o
Partial Indexes and Expression Indexes in PostgreSQL: The Query Optimization Patterns That Cut Our Mobile API P99 Latency by 80%
Deep dive into PostgreSQL's underused indexing strategies — partial indexes for soft-deleted rows, expression indexes for JSONB fields, covering indexes to enab
Recursive CTEs in PostgreSQL: kill N+1 queries in mobile apps
Deep dive into using PostgreSQL recursive common table expressions to efficiently query hierarchical data structures common in mobile apps — threaded comments,
Modular monolith in Kotlin: microservice boundaries without the tax
Step-by-step architecture for structuring a Ktor or Spring Boot backend as a modular monolith using Kotlin's internal modifier, JPMS module-info boundaries, and
HikariCP config (WRONG)
Deep dive into the connection pooling layer between your mobile backend and PostgreSQL — covering HikariCP misconfiguration antipatterns (maxLifetime vs server-
Embedding Local LLMs in Your Mobile App: llama.cpp via KMP, 4-Bit Quantization Tradeoffs, and the Streaming Architecture That Keeps Your UI at 60fps
Practical integration of on-device LLM inference in production mobile apps using KMP bindings to llama.cpp, covering GGUF model selection, Q4_K_M vs Q5_K_S quan
Row-level security in PostgreSQL: SaaS tenant isolation without query changes
Implementing PostgreSQL RLS policies with JWT-based tenant context using set_config/current_setting, combining it with connection pooling (PgBouncer in transact
Server-Sent Events as Your Mobile Real-Time Layer: Automatic Reconnection, Last-Event-ID Recovery, and Why SSE on Ktor Replaces 90% of Your WebSocket Use Cases
Deep dive into implementing SSE with Ktor for mobile backends — covering EventSource protocol semantics, Last-Event-ID replay for offline recovery, backpressure
Kotlin coroutines meet Swift 6 concurrency in KMP
Deep dive into how Kotlin coroutines map to Swift's async/await at the KMP boundary — covering SKIE vs KMP-NativeCoroutines, handling cancellation propagation a
Zero-downtime PostgreSQL migrations at scale
Deep dive into non-blocking schema migrations for PostgreSQL — covering advisory lock strategies to coordinate migration runners, the ghost table pattern (used
Designing Idempotent APIs for Mobile Clients: Retry Logic, Idempotency Keys, and the Patterns That Prevent Double Charges
Deep dive into implementing database-backed idempotency keys in Ktor/Spring Boot, client-side retry strategies with exponential backoff and jitter for unreliabl
Partial indexes in PostgreSQL: wins your mobile backend misses
Deep dive into PostgreSQL partial indexes (CREATE INDEX ... WHERE), expression indexes, and covering indexes (INCLUDE) — showing how targeted indexing strategie
Gradle at scale: how we cut KMP CI from 45 to 12 min
Deep dive into Gradle configuration cache compatibility in multi-module KMP projects, build cache hit optimization with remote caching (Develocity/Gradle Enterp
SQLite as your server database: a production guide
Deep dive into using SQLite as a production server database for early-stage startups — covering WAL mode configuration, critical PRAGMA settings (journal_mode,
Replacing Your Message Queue with PostgreSQL: LISTEN/NOTIFY, SKIP LOCKED Queues, and When Kafka Is Overkill for Your Startup
Deep dive into using PostgreSQL as a lightweight job queue and event bus using LISTEN/NOTIFY for pub/sub, FOR UPDATE SKIP LOCKED for reliable worker queues, and
The Modularization Trap: When Clean Architecture Becomes Your Startup's Bottleneck
A pragmatic breakdown of how over-modularized Android/KMP codebases create exponential Gradle build times, circular dependency nightmares, and onboarding fricti
Local RAG on mobile: vector search under 200ms
Implementing a fully offline retrieval-augmented generation system using sqlite-vss for vector similarity search, ONNX Runtime for on-device embedding generatio
Connection pool tuning: HikariCP defaults kill mobile backends
Deep dive into why the default HikariCP pool size formula (connections = CPU cores * 2 + 1) breaks down for mobile backends with bursty traffic patterns, how to
End-to-End Kotlin: Sharing Type-Safe API Contracts Between Ktor and Compose Multiplatform with Kotlinx.Serialization and Ktor Resources
Building a shared KMP module that defines your entire API surface — routes, request/response DTOs, validation rules, and error types — consumed identically by y
Zero-downtime PostgreSQL migrations at scale
Deep dive into the specific PostgreSQL migration patterns (CREATE INDEX CONCURRENTLY, advisory locks, gh-ost-style shadow table swaps, and NOT VALID constraint
Bridging Kotlin Coroutines and Swift 6 Structured Concurrency in KMP: Building Leak-Free Shared Async APIs
How to design KMP shared modules that expose idiomatic async APIs on both platforms — using SKIE and custom expect/actual patterns to map Kotlin Flows to AsyncS
Advanced Claude Code CLI skills that actually change how you work
Practical Claude Code CLI techniques for senior engineers: slash commands, MCP servers, custom hooks, and multi-file editing patterns that replace entire toolch
Connection pooling for serverless mobile backends
Deep dive into how serverless functions (Lambda, Cloud Run, edge workers) interact with PostgreSQL connection limits, comparing transaction-mode PgBouncer, Supa
MCP in Practice: Connecting Claude to Jira, Excel, and Building Multi-Agent Workflows in Minutes
How Model Context Protocol turns Claude into a Jira analytics engine — connecting via MCP connector, building agent teams, extracting Lead Time, sprint data, an
OpenCode vs Claude Code: free agentic coding setup
How to set up OpenCode with cheap or free model providers like OpenRouter, Pollinations, and Copilot subscriptions to get agentic coding without the 100/month p
Room 3.0 Migration Guide: From KAPT to KSP, Coroutines-First APIs, and KMP Web Support
What changes in Room 3.0 for existing projects: dropping KAPT for KSP-only codegen, Kotlin-only generated code, new coroutines-first API surface, and the new we
Running Gemma 3 on-device: memory, quantization, and KMP
Practical engineering deep-dive into shipping on-device LLMs — comparing 4-bit vs 8-bit quantization impact on output quality and latency, managing memory press
Self-hosting AI models on a budget VPS: a cost analysis
Practical guide to running open-source LLMs on cheap VPS instances — hardware requirements, model selection, performance benchmarks, and cost comparison vs API
Ktor 3 vs Spring Boot 3: Choosing your mobile backend
Head-to-head comparison of Ktor's coroutine-native request handling versus Spring Boot's Project Loom virtual threads — covering cold start times, memory footpr
Zero-downtime schema migrations at scale
Step-by-step implementation of expand-contract migrations using PostgreSQL advisory locks, transactional DDL, and blue-green deployment slots — covering the exa
Jetpack Compose Recomposition at Scale: How Strong Skipping Mode Changes the Stability Rules You Learned
Deep dive into Compose compiler's stability inference system, how strong skipping mode (now default) changes which classes need @Stable/@Immutable annotations,
PostgreSQL Partial Indexes and Expression Indexes: Cutting Your Mobile Backend Query Times by 90%
Deep dive into using partial indexes for soft-deleted records, expression indexes for JSONB columns, and covering indexes (INCLUDE) to eliminate heap fetches —
SQLite WAL Mode and Connection Strategies for High-Throughput Mobile Apps: Beyond the Basics
Deep dive into SQLite WAL2 mode, BEGIN CONCURRENT, connection pooling patterns for Room/SQLDelight, and how to avoid SQLITE_BUSY under real concurrency — with b
Unit Economics That Actually Matter: Calculating True LTV When Your Mobile App Has Both Subscription and IAP Revenue Streams
Build a practical unit economics model that accounts for blended revenue streams (subscriptions + consumable IAPs), cohort-based retention curves, and refund ra
Event sourcing with CQRS for mobile backends
Step-by-step implementation of event sourcing for a mobile app backend, covering event store design in PostgreSQL, projection rebuilds, snapshotting strategies
MVI state machines: one architecture for Compose & SwiftUI
Building a production-grade MVI state machine in pure Kotlin that drives both Compose and SwiftUI views, handling side effects, state restoration, and testing w
PostgreSQL Connection Pooling for Mobile Backends at Scale
Deep dive into PgBouncer vs Supavisor vs built-in pool sizing, covering transaction vs session mode tradeoffs, how connection storms from mobile clients differ
Running LLMs On-Device in Android: GGUF Models, NNAPI, and the Real Performance Tradeoffs
A deep technical walkthrough of shipping on-device LLM inference in production Android apps — covering model quantization formats (GGUF, QLoRA), hardware accele
Bridging Kotlin Coroutines and Swift in KMP
Deep dive into the practical patterns for exposing Kotlin Flow and suspend functions to Swift 6 structured concurrency — covering SKIE vs manual wrappers, cance
I Built an AI Content Pipeline That Publishes a Blog Post in 83 Seconds
How I replaced n8n, Zapier, and paid automation tools with a custom Node.js pipeline that generates, reviews, and publishes content using Claude CLI. Real metrics from production.
Kotlin Multiplatform Room: Shared DB Without the Tax
Now that Room has official KMP support, examine the real-world migration path from platform-specific persistence (Room on Android, Core Data/GRDB on iOS) to a s
Contract Testing for Microservices: Stop Breaking Production
Implementing consumer-driven contract tests with Pact and Spring Cloud Contract in Kotlin backend services, covering schema evolution strategies, CI pipeline in
I Built Custom Claude Code Skills for Android Development — Here's How They Work
How custom slash commands for Claude Code cut my setup time from 20 minutes to 5 seconds per feature. Open source on GitHub.
Compose Multiplatform Navigation: Best Pick in 2026
A deep architectural comparison of navigation frameworks for Compose Multiplatform apps — examining type-safe argument passing, lifecycle management across iOS/
Eliminating ANRs at Scale: Android Responsiveness Guide
Deep dive into the architecture patterns that prevent ANRs before they happen — structured concurrency with Kotlin coroutines, main-thread budget accounting, an
Dependency Injection Beyond Basics: Hilt's Hidden Cost
Examining how over-reliance on DI frameworks like Hilt leads to bloated module graphs, hidden runtime failures, and testability theater — contrasting with manua
How Custom MCP Servers Cut AI Token Usage by 95%
Building custom MCP servers as a dev tool strategy: how indie developers can reduce AI costs and improve coding workflows by giving LLMs structured context inst
Kotlin Flow Patterns Every Senior Android Dev Must Know
Advanced Flow operators for production Android apps: shareIn vs stateIn, conflate vs buffer, retry with exponential backoff, and testing Flows with Turbine
I Hardened My VPS in One Session — Here's the Checklist
A practical, step-by-step security hardening guide for solo developers running production apps on a VPS — covering WireGuard VPN, Docker port isolation, SSH loc
AI Governance Architecture for Solo Devs
How indie developers and small startups can build AI governance into their products from day one — practical patterns for solo devs shipping AI features into re
How Much Does It Cost to Build an MVP in 2026?
A detailed breakdown of MVP development costs by platform, features, and approach. Real numbers from a developer who builds them.
Why Agent Testing Is Broken (And How to Fix It)
LLM agents broke the testing contract. Here are practical, budget-friendly strategies for indie developers to test non-deterministic AI outputs without enterprise infrastructure.
Case Study: Building a Cross-Platform Health App with Kotlin Multiplatform
How we built HealthyDesk — a production-ready KMP app for Android, iOS, and Desktop — with clean architecture, 20+ modules, and 80% shared code.