Practical pieces on engineering leadership, AI strategy, and what actually works when you're shipping software in the real world.
81 posts
You matched the comp. You offered equity. They still left. Here's what actually drives senior engineer attrition at startups — and the retention playbook that works.
Read →Every startup adopts Agile and then wonders why it doesn't work. Here's what actually happened: you confused Agile principles with Agile theater (ceremonies, velocity, standups). I'll show you what actually matters and what I use instead.
Read →A fractional CTO's opinionated case for six-week cycles, appetite-based planning, and the shaping discipline — plus the five situations where Shape Up will hurt more than it helps.
Read →The impulse to split your monolith into microservices hits every growing startup. Here's the framework I use to decide whether the split is premature or overdue — and the modular monolith pattern that buys you time.
Read →Short-lived branches, feature flags, CI hygiene. How to migrate from long-lived branches and why it matters for shipping velocity.
Read →Tech lead is your go-to move for scaling a team. But if you promote too early, you lose a great IC and gain a half-time manager. Here's when it actually makes sense.
Read →How to make the hardest people decision as a technical leader. Structure, timing, communication, legal basics, and how to protect your remaining team.
Read →Traditional technical due diligence misses the AI-specific risks. Here's the checklist I developed for evaluating AI features in startup acquisitions and funding rounds — model provenance, data rights, eval evidence, and vendor lock-in.
Read →Technical debt isn't something you 'get to eventually.' It's a line in your engineering budget. I use a debt register, an interest rate calculation, and a framework to decide when refactoring is more valuable than shipping new features.
Read →You don't need a Spotify-model org chart if you have 15 engineers. Here's how to structure teams that actually work at your size, without premature complexity.
Read →Balanced metrics without surveillance. When to use DORA. When to use SPACE. How to avoid turning metrics into hammer tools.
Read →The RTO debate is over. Here's what actually matters for engineering velocity, and how to choose what works for your team.
Read →Stop talking about psychological safety. Start building it. Concrete behaviors that change how your team operates: blameless postmortems, disagree-and-commit, code review culture, and what you do when someone fails.
Read →Before you add Redis, Elasticsearch, a message queue, a cron service, and a vector database, consider that Postgres can do all of those things. Here's how — and where the pattern breaks.
Read →A simple, no-BS framework for evaluating engineers when you don't have an HR department. Structure, execution, and how to use reviews as a leadership tool instead of a compliance checkbox.
Read →You don't need a $5K/month Datadog bill to know what's happening in your application. Here's the observability stack I install at seed-stage startups — effective, cheap, and ready to scale.
Read →Adding features is easy. Removing them is where the real product leadership happens. Here's the sunset playbook I use to cut features without losing customers or breaking the team's morale.
Read →Why 2-week sprints are overhead at small scale. Ditching ceremony for flow and shipping velocity.
Read →On-call doesn't have to be painful. I run incident response for startups with 3–10 engineers using blameless postmortems, lightweight on-call rotation, and a culture where failures are learning, not punishment. Here's the exact playbook.
Read →A founder-friendly template for 1:1s with senior engineers. What to ask, how to listen for signals, and why this is your most valuable hour each week.
Read →Investors are about to look under the hood. Here's the founder prep guide I wish every startup had before the DD call — what to fix, what to document, and what to stop worrying about.
Read →Move fast and break things does not work in fintech. Here are the compliance shortcuts seed-stage fintech founders take that become existential problems at Series A — and what to do instead.
Read →Feature flags aren't toggles for features. They're an operational delivery pattern that decouples deployment from release, enables progressive rollouts, and gives you kill switches in production. Here's how I use them as a methodology.
Read →Bet-sized planning, appetite vs. estimate. Why Shape Up's appetite-setting beats story points every single time.
Read →Updated Definition of Done for the agent era. AI-generated code review, test coverage, security pass, spec match. What actually matters in 2026.
Read →AI features create new data privacy obligations that most startups are not prepared for. Here's what GDPR, CCPA, and the EU AI Act actually require when your product sends customer data through an LLM.
Read →Your team structure isn't just about org charts. It's encoding itself into your architecture. And if they're misaligned, you're shipping slower than you think.
Read →Most seed-stage startups can't afford a full team of W-2 engineers. Here's how to blend contractors, agencies, and employees into a hybrid engineering org that ships — and the mistakes that make it expensive.
Read →A practical playbook for building and scaling distributed engineering teams. Written culture, decision logs, async code review, and the myth of the synchronous overlap window.
Read →The conventional wisdom says never rewrite. Sometimes the conventional wisdom is wrong. Here's how to decide when a rewrite is justified, and the phased approach that keeps the business running while you do it.
Read →Single agents hit a ceiling fast. Multi-agent systems are what comes next — and they bring orchestration, governance, and architectural challenges most startups are not ready for. A fractional CTO's field guide.
Read →A practical guide to building multi-tenant SaaS on Postgres — why shared-schema with row-level security wins at seed stage, the implementation patterns that work, and the five mistakes that cause data leaks.
Read →A practical 90-day playbook for your startup's first engineering manager — the mindset shifts, the weekly cadence, and the mistakes that derail most IC-to-manager transitions.
Read →The three most consequential engineering hires a founder will ever make, what each role should actually do, and the specific mistakes I watch founders make over and over.
Read →Your cloud bill is telling you what your engineering team actually values. Here's how to read it, the specific waste patterns I find in almost every audit, and how to cut 20-40% without touching user-facing functionality.
Read →A practical guide to building retrieval-augmented generation features that actually work — chunking, embeddings, retrieval, re-ranking, evals, and the mistakes I see in almost every first attempt.
Read →The single piece of infrastructure that separates AI features that improve from AI features that drift — what a real eval suite looks like, how to build one, and what to measure.
Read →An opinionated decision framework for picking a software development methodology based on your team size, product stage, and what you're actually trying to optimize for.
Read →A plain-English explainer for founders: what a fractional CTO actually does, how the model works, and the five specific moments when hiring one pays for itself many times over.
Read →A 30-minute weekly engineering review a non-technical founder can run with confidence — the exact agenda, the questions to ask, and the signals to watch for.
Read →An opinionated, deliberately boring tech stack for seed-stage SaaS startups — the specific tools I recommend, the ones I avoid, and why the exciting choices almost always slow you down.
Read →Real numbers on what a fractional CTO costs, what a seed-stage startup actually saves, and the break-even math that tells you whether the investment pays off.
Read →Why the traditional 12-month engineering roadmap fails at seed stage, and the lightweight planning artifact I use with clients instead — one that survives contact with reality.
Read →Why the Model Context Protocol matters for SaaS in 2026, how to expose your product to agents safely, and the specific implementation steps for a seed-stage team.
Read →Why LLM feature costs quietly explode as you scale, the specific decisions that drive the curve, and the handful of optimizations that reliably cut your bill by 50% or more.
Read →The exact Claude Code workflow I use across every fractional CTO engagement — from planning to PR — and the guardrails that keep it safe for production.
Read →A week-by-week breakdown of exactly what a fractional CTO should deliver in the first 30 days of an engagement — with the specific artifacts, conversations, and decisions you should expect.
Read →AI coding tools multiply the output of experienced engineers and often slow down inexperienced ones. Here's why the gap exists and what teams can do about it.
Read →An honest, fractional CTO's review of the AI-native developer tools in 2026 — what each one is best at, what they cost in productivity versus oversight, and what I actually use on client work.
Read →The specific patterns I see again and again when I open a seed-stage codebase for the first time — what they mean, why they happen, and how to fix them before they cost you a fundraise.
Read →A founder-friendly translation of the Team Topologies framework, with practical advice on when and how to apply it at a 10-, 25-, and 50-person engineering org.
Read →Claude Code becomes dramatically more useful when you configure it properly for your team. Here's how I use subagents, skills, and hooks to turn it from a single-player tool into a team-level force multiplier.
Read →A practical, non-theatrical security baseline for seed-stage SaaS startups — the 15 things that actually matter, why, and how to implement them in a single focused sprint.
Read →AI coding tools are only as good as the spec you give them. Here's the practice of writing structured specifications that make AI-generated code predictable, reviewable, and correct.
Read →A practical guide to SOC 2 for early-stage SaaS founders — when it is actually worth pursuing, what it costs, how long it takes, and the specific shortcuts that do and do not work.
Read →The honest signals that your fractional CTO engagement has served its purpose, how to have the conversation with them, and the clean paths from fractional to a full-time engineering leader.
Read →AI-generated code introduces specific security failure modes that standard code review misses. Here's the security-focused review checklist I use on every engagement where AI tools are producing production code.
Read →AI-authored pull requests fail in different ways than human-authored ones. Here's the specific review heuristics I teach teams to catch the mistakes AI makes.
Read →The shift from clever prompts to context assembly pipelines — why the 'prompt engineer' role is dissolving, and what replaced it.
Read →A practical decision framework for picking the right LLM for each feature — by cost, latency, quality, privacy, and lock-in — without turning it into a religious debate.
Read →The Model Context Protocol lets coding agents talk to your databases, APIs, and internal tools. Here's a developer-level walkthrough of building and deploying MCP servers for real engineering workflows.
Read →The exact weekly cadence I set up with every fractional CTO client — standups, reviews, 1:1s, planning — and why most engineering teams don't need a new process, they need a working one.
Read →What a real technical due diligence looks like from the inside — the eight categories I evaluate, the specific questions I ask, and the red flags that kill deals.
Read →A non-technical founder's guide to engineering interviews — the questions that actually predict performance, the signals you can read without a CS degree, and the traps to avoid.
Read →A founder's interview guide for hiring a fractional CTO — the twelve questions I would ask if I were on the other side of the table, the red flags to watch for, and the reference check that matters most.
Read →There are at least six distinct ways to use AI in a development workflow, from autocomplete to autonomous agent swarms. Here's the taxonomy, what each pattern is good for, and which ones are production-ready.
Read →A founder's decision framework for choosing between a fractional CTO, a full-time CTO, and a development agency — with real cost math, honest tradeoffs, and the stage-by-stage answer.
Read →What healthtech founders specifically need from a fractional CTO — HIPAA, BAAs, AI in regulated workflows, the cost of compliance, and the trade-offs unique to building in healthcare.
Read →After two years of 'just prompt it,' fine-tuning is quietly winning back ground. Here's when distillation, LoRA, and small specialized models actually beat calling a frontier API.
Read →A founder-friendly guide to the four DORA metrics, what good looks like at a startup, and how to start measuring them without buying an enterprise observability platform.
Read →The quality of an AI coding agent's output depends on what it reads before it writes. Here's how to engineer the context — repo maps, symbol graphs, file selection — so the agent starts with the right information.
Read →An honest operational guide to running coding agents on real codebases — the tasks they handle well, the traps they fall into, and the guardrails that keep them from causing damage.
Read →A practical, section-by-section guide to writing a CLAUDE.md file that turns a generic AI coding agent into an engineer who has read the onboarding doc.
Read →A real engagement (anonymized) where a 4-person startup had a working AI prototype but no path to production. Here's the six-week plan that got them shipped — and the trade-offs we made.
Read →A real engagement (details anonymized) where a Series A startup was bleeding $38K/month on LLM APIs. The specific audit I ran, the changes we made, and the final bill.
Read →The architectural patterns that define AI-native SaaS in 2026 — vector stores, semantic caches, tool-use orchestrators, eval infra, and the stack decisions founders get wrong.
Read →A decision framework for founders trying to figure out whether to build, buy, or wrap when adding AI features to a product — with the specific questions that tell you which path fits.
Read →The 25 specific capabilities a B2B SaaS startup needs in place before selling into enterprise — what each one is, why it matters, and how to phase the work.
Read →A practical safety baseline for AI features at seed-stage startups — injection defense, PII protection, red-teaming, and audit trails you can implement in a single sprint.
Read →TDD gets a second life with AI coding tools. Write the tests first, hand them to the agent, and the agent writes the implementation. Here's how that workflow actually plays out.
Read →The shift from copilots to agents is restructuring how SaaS gets built, priced, and defended. A fractional CTO's honest read on what that means for founders right now.
Read →