Caching Is a Product Decision, Not an Infrastructure Toggle
Why stale-while-revalidate and edge latency budgets matter more than cache-hit ratios for real products.
Read noteBlog
185 posts
Conversational AI UX: The Interface Contract Nobody Signs
Shipping conversational AI means designing for uncertainty — here's how to build interfaces that survive real user behavior.
Read noteOnboarding Is the First AI Contract Your Product Signs
Why AI onboarding is a state machine and latency problem, not a UX copy issue—and how to ship adaptive flows that build trust.
Read noteAI Agent Observability Is a Product UX Problem, Not Just an Ops One
AI agents need observability that serves both engineers and end users. Here's how to design it.
Read noteAI Performance Isn't a Backend Problem — It's a UX Design Constraint
How Apple's iOS 27 launch metrics and AWS Kiro's native approach show that AI features live or die on perceived speed, not model accuracy.
Read noteThe Interface Contract Is Dead: Designing for AI-Native Products in 2026
Why fixed screens and navigation menus are giving way to AI-composed UIs—and what this means for product engineers shipping real systems.
Read noteSecurity UX Is a Product Problem: What the 2026 MFA Deadline Teaches Us About Auth Design
Salesforce MFA enforcement starts June 2026 — here's how to ship auth flows that treat security as a product feature, not a compliance checkbox.
Read noteTransparency Is Not a Feature — It's an Architecture Decision
How SaaS and AI products confuse PR stunts with real transparency, and what to do when your product has to tell the truth.
Read noteVoice UI Is Not a Chatbot with a Mic: Shipping Conversational Interfaces That Earn Trust
Voice UI demands a different product contract than chatbots. Here's what shipping judgment looks like when the interface has no screen.
Read noteEdge Caching Isn't a Knob — It's a Product Contract
Why treating edge caching as infrastructure plumbing misses the real UX and product design opportunity.
Read noteThe Shortcut Manifesto: Why Your App Needs a Keyboard Overlay
Keyboard shortcuts are a product surface, not a power-user secret. Here’s why discoverability defines quality.
Read noteOnboarding Is the New Homepage: Why AI-Driven Adaptation Is Your Highest-Leverage Product Investment
Forget redesigning the home page. In 2026, the biggest gains come from making onboarding adaptive—using AI to personalize step logic, reduce hesitation, and push activation by double digits.
Read noteUX Engineering Is Not a Service — It's a Shipping Discipline
UX engineering isn't a vendor service or a design handoff. It's the discipline that decides whether your product works under real conditions.
Read noteThe Interface Contract: Why Prompt Engineering Is a UI Problem
When the AI answers wrong, the UI is broken. Shipping applied AI means designing the surface that sets honest expectations and handles inevitable failures.
Read noteObservability Is Not a Dashboard — It's a Product Contract You Sign With Every Deploy
The best LLM observability tools in 2026 don't just surface traces — they encode the quality bar your team can't afford to repeat.
Read noteYour Auth Flow Is a Product Decision, Not a Security Checklist (and It's Probably Already Calcified)
Why early design decisions around login, recovery, and onboarding embed themselves so deeply that they dictate support volume, drop-off, and trust for months — and how to run experiments before it's too late.
Read noteDesign Tokens Are Not a Design Problem: Shipping a 2026-Ready UI System
Design tokens hit 84% adoption and a stable spec in 2026. Here's what that means for engineers who actually ship product.
Read noteThe Transparency Tax: Why Your AI Product Needs Honest UX Before Compliance
Regulatory pressure is coming for AI products in 2026. The smartest move isn't a compliance team — it's a UI that earns trust by showing what the system actually knows and doesn't know.
Read noteThe Edge Is Your New Frontend: Why CDN Strategy Is a Product Decision in 2026
Edge compute lets you run logic closer to users—not just cache assets. Here's how product engineers should treat routing, personalization, and latency as UX decisions.
Read noteKeyboard Accessibility as Release Criteria, Not a Checklist Pass
Why shipping keyboard-accessible interfaces is a product and engineering discipline, not a compliance checkbox — with real examples from PowerToys, Power Platform, and WordPress 7.0.
Read noteThe Prompt/UI Contract: Why Your AI Feature Feels Broken and How to Fix It
How the surface promise of an AI feature and the backend's actual capability create a contract that most teams break — and what to do about it.
Read noteAI UI Tools Are Useless Without an Interface Contract
AI-generated UI is fast, but shipping it without breaking your design system requires a hard contract between outputs and production code.
Read noteThe Low-Code Trap: When the Platform Becomes the Product
Why low-code platforms can accelerate prototypes but stall shipped products—and how to decide when to build vs buy.
Read noteObservability Is a Product Interface: What AI Features Teach Us About Trust
Why product engineers should treat observability as a UX concern, not just an ops dashboard — lessons from shipping AI features.
Read noteAI Products Need Incident Response, Not Just Model Accuracy
Why shipping AI without embedded incident response and transparency is a product risk, and how to design for it.
Read noteAuthentication Is a Product Surface: Why MFA Mandates Demand Better UX Engineering
Salesforce's 2026 MFA mandate exposes a hard truth: auth flows are product surfaces. Here's how to ship security without wrecking conversion.
Read noteVisual Regression Testing Is a Product Engineering Problem
Why treating visual diffs as product decisions, not test failures, changes how you ship interfaces.
Read noteAccessibility Is a System Constraint. Treat It Like One.
Stop treating accessibility as a checklist. Ship it as a first-class system constraint—baked into components, tokens, and CI.
Read noteEdge Computing Is Not About Latency — It's About What You Stop Sending to Your Origin
Edge computing's real win isn't speed; it's blocking junk, routing smart, and keeping your origin clean.
Read noteOnboarding Is Not a Tutorial: What 2026 SaaS Products Get Wrong About the First Session
Most SaaS teams over-engineer the first session. Here is what product engineers should ship instead in the AI era.
Read noteAgentic Web Experiences Need Product Engineering, Not Model Benchmarks
Shipping AI agents well demands citation placement, latency budgets, and undo boundaries—not just a smarter model.
Read noteYour Design System Is Your AI Prompt Contract
Why AI-generated UI is only as good as the component library it's constrained to, and how to build for that now.
Read noteRUM Is Table Stakes. The Real Bet Is Observability That Ships.
SaaS engineers waste days on dashboards nobody trusts. Here's how to buy real user monitoring and observability as one product decision.
Read noteThe Authentication Interface Is Your Product's First Test of Trust
Why login screens, MFA flows, and recovery paths are product surfaces — not security checklists — and what most teams get wrong about them.
Read noteThe System Design Roadmap Is a Trap: Ship the Interface, Not the Architecture
Why most system design advice misses the point for product engineers, and what to focus on instead in 2026.
Read noteVulnerability Prioritization Is a Product Decision — Stop Treating It Like a Compliance Checklist
CISA's BOD 26-04 shifts from patch-everything to risk-based triage. For product engineers, this is a UX and architecture problem, not just a security one.
Read noteCDN Metrics Are Lying to You: What Product Engineers Should Track Instead
Why standard CDN metrics like cache hit ratio and byte offload hide real user latency, and what to measure for product-level performance.
Read noteKeyboard Accessibility Is the Next Design System Frontier
Why treating keyboard shortcuts as an accessibility feature, not a power-user bonus, makes your product more robust for AI interfaces and real-world use.
Read noteOnboarding That Ships: Why Product-Led Growth Dies on a Broken First Session
Most onboarding fails because it decorates the UI instead of diagnosing user data. Here's how to build first-session flows that actually convert.
Read noteThe Design System That Designers Didn't Build: Why shadcn Won 2026
shadcn/ui became the most influential design system of 2026 by living in GitHub, not Figma — a lesson in developer ownership and workflow.
Read noteObservability Overload Is a Product Problem, Not a Data Problem
Why more dashboards and alerts make products worse — and how to ship observability that engineers actually use.
Read notePerformance Monitoring Is a Product Contract, Not an Ops Dashboard
Why end-user experience monitoring belongs in your product spec and how to ship monitoring that survives real user behavior.
Read noteAI Products That Disappear: Why the Best Interfaces Don't Ask for Your Attention
The Microsoft Copilot redesign proves that AI succeeds when it integrates into workflows, not when it demands a separate mode. Here's what product engineers can learn.
Read noteThe Product Engineer's Case for Minimalist Dashboards
Why dense, feature-heavy dashboards fail and how to design interfaces that survive real users with real data.
Read noteTransparency as a Product Interface: What Security Incidents Taught Me About Shipping Trust
Security incidents expose product trust faster than any feature. Here's how to design transparency into your UI before you need it.
Read noteAccessibility Is a Component API Contract, Not a Compliance Checklist
How treating accessibility as a design system architecture decision—not a post-hoc audit—reduces rework and ships better products for everyone.
Read noteYour CDN Dashboard Is Lying: Why Real User Latency Demands Edge Percentiles
Standard CDN metrics like average latency hide the experience of users at the tail. Here’s how to measure what actually matters for product UX.
Read noteOnboarding Is Not One Flow: Why Your Activation Metrics Are Lying to You
Most SaaS products design onboarding for the wrong user — the demonstrator, not the doer. Here's how to segment by intent and fix activation.
Read noteContext Drift Is the New Null Pointer: Observability as Product Infrastructure for AI Agents
Most teams treat agent observability as debugging. The ones that ship reliably treat it as the product contract for trust, audit, and iteration.
Read noteContext Engineering Is the New Product Engineering Discipline You Can't Ignore
Why context consistency, not model choice, determines whether your AI agent ships reliable product features.
Read noteCore Web Vitals Are Revenue Metrics — Ship Accordingly
Why treating LCP, INP, and CLS as engineering KPIs instead of business metrics is a product mistake that costs real money.
Read notePasswordless Authentication Is a UX Decision Before a Security One
Why treating login as a product surface—not a backend checklist—determines whether your app feels trustworthy or fragile.
Read noteTrust Is a UI Component: Shipping Resilience in AI Products
Regulators are demanding transparency. Your product interface is where trust lives — not legal docs. Here's how to ship it.
Read noteThe TypeScript Tax: What You Actually Buy with Static Types in 2026
Why TypeScript's real value in 2026 isn't type safety—it's the patterns it forces you to build.
Read noteAccessibility Is a Shipped Product Decision, Not a Compliance Checklist
In 2026, WCAG 2.2 and EU laws make accessibility a hard requirement. Here's how to treat it like any other product feature—with tradeoffs, testing, and engineering discipline.
Read noteCDN Is Not Just a Speed Knob: Edge Infrastructure as Product Interface
Why product engineers should treat CDN and edge compute as part of the UX architecture, not a deployment afterthought.
Read noteOnboarding Is a Product Decision, Not a UX Exercise
Most onboarding fails because it treats all users as one. Here's how to decide who you're willing to lose.
Read noteYour Design System Isn't Ready for AI — And That's the Product Gap
Why static design tokens fail when AI generates UI, and how structured spec files become the new API contract between interfaces and agents.
Read noteObservability Is Not a Dashboard — It's a Product Contract for AI Agents
Why tracing, evaluation, and diagnosis must live inside your workflow, not a separate dashboard — and how that changes what you ship.
Read notePWA or Native in 2026? The Product Engineering Decision Framework
Most teams over-invest in native apps. Here's when PWA wins and when it doesn't — based on shipped product experience.
Read noteThe Prompt Is the New Component API
Why shipping AI features means designing a contract between what the UI says and what the model can prove — and what breaks when you don't.
Read noteTransparency Is Not a Proxy for Trust (Especially in AI Products)
Why showing the model's reasoning doesn't always earn user trust, and what to do instead.
Read noteWhy Your Login Flow Fails in a World of AI Agents — and What to Build Instead
Authentication designed for human clicks breaks with AI agents. Here's how to redesign login, MFA, and recovery flows for a machine-first product world.
Read noteAccessibility Is a Product Requirement Now — Ship Like It
WCAG 2.2 is now the legal baseline. Here's how to treat accessibility as a shipping discipline, not a compliance checkbox.
Read noteYour CDN Is Not a Commodity — It's Your Product's Edge Architecture
In 2026, choosing a CDN is about edge compute, security, and compliance — not just caching. Here's how to evaluate it as product infrastructure.
Read noteOnboarding Is a Signal-Propagation Problem, Not a Tutorial
Most onboarding flows fail because they treat the first session as a linear tutorial. The real work is designing a system that negotiates context between user and product.
Read noteThe Design System Contract: Why 2026 Demands Machine-Readable Tokens, Not Figma Files
Design systems that survive AI-generated UIs must be token-first, typed, and parseable by tools like Codex and Claude — not just documented in Figma.
Read noteEval-Driven Observability: Why Your AI Agents Are Failing in Production
Tracing alone won't fix AI quality. The only path to trustworthy agents is unifying evals, observability, and guardrails into one closed loop.
Read noteThe Product Interface of Agentic AI: What Claude Opus 4.8 Proves About Shipping Judgment
Why the hardest part of AI product engineering isn't the model — it's the UX contract between streaming latency, citation placement, and undo design.
Read noteAI Product Engineering in 2026: The Interface Contracts That Make Features Ship
The real skill in 2026 is engineering the contracts between user intent and model output — not building agents in isolation.
Read noteThe Prompt/UI Contract: Why Your AI Product Feels Untrustworthy
Shipping AI features means designing the contract between what the UI promises and what the model can prove. Here's how to get it right.
Read noteThe Prompt/UI Contract: Why Your AI Product Feels Untrustworthy
How the gap between what your interface promises and what your backend can prove erodes user trust — and how to close it.
Read noteAccessibility Is Your AI Product's UX Contract — Not a Compliance Sticker
How shipping inclusive AI UX means designing for low-literacy users, low bandwidth, and underrepresented data — and why 'I don't know' is a product quality signal.
Read noteYour AI Feature Is Burning 30% of Revenue: The Product Engineer’s Guide to Unit Economics in 2026
How to design AI interfaces that survive the unit-economy reality of inference costs—without killing the user experience.
Read noteThe Prompt/UI Contract: Why Your AI Product Feels Broken Even When the Model Works
Shipping AI products means designing the interface contract between what the UI promises and what the backend can prove. Here's how.
Read noteAI Agents Fail When You Build Them Backwards — Here's the Product-First Fix
Why most agent projects crash from bottom-up architecture and how encoding product constraints as DESIGN.md flips the approach.
Read noteEvals Are Not a Sidecar: Why AI Quality Demands a Closed Loop
Most AI observability tools log traces but never close the feedback loop. Real product quality requires evaluation that is observability, not bolted onto it.
Read noteThe UI/UX Redesign That Ships: Why Launch Speed Beats Portfolio Polish
Founders rank agencies by shipping velocity, not pixel precision — here's what product engineers should steal from that playbook.
Read noteThe Agent Interface Contract: Why Your AI Product Feels Like a Demo
Shipping AI means designing the handshake between what the UI promises and what the backend can prove. Here's how.
Read noteThe AI Coding Agent Is Not Your Senior Engineer
Why treating Claude Code skills like a checklist misses the real leverage — and what product engineers should actually evaluate.
Read noteFeedback Loops Are the Missing Interface in AI Products
Why treating user feedback as a product feature—not a support channel—is the highest-leverage investment for AI teams shipping in 2026.
Read noteAccessibility Is a Product Spec, Not a Compliance Checklist
How shipping with focus order, contrast ratios, and keyboard navigation as release criteria improved our product for every user.
Read noteThe Real Cost of AI Is Not the API Bill: Why FinOps for Inference Is a Product Engineering Problem
Shipping AI products means managing inference costs as a UX constraint—not just a cloud bill. Here's how to design for cost-aware reliability.
Read noteThe Real Work of Applied AI: What Meta's 7,000-Person Task Force Gets Right
Meta moved 7,000 engineers into Applied AI. The lesson isn't about models—it's about product discipline, latency budgets, and interface contracts.
Read noteDesign Systems Are Dead. Long Live the Design Contract.
Why shipping AI-generated UI means replacing static design systems with a runtime contract between prompt, component, and product.
Read noteThe UI Is the Contract: Shipping Honest AI Products
Why the hardest part of building AI features isn't the model — it's managing user expectations through interface design, latency budgets, and failure states.
Read noteContext Engineering Is Usually the Answer. Fine-Tuning Is for the Tail.
A grounded framework for deciding when to fine-tune vs. engineer context in shipping AI products, based on real constraints like iteration speed, cost, and debuggability.
Read noteThe Interface Is the Audit Trail: Why AI Governance Is Now a Product Engineering Problem
As AI regulations shift from principles to enforceable rules, the compliance burden lands on product interfaces. Here's how to design audit trails, human oversight, and transparency into your AI product.
Read noteFeedback Loops Are Not an ML Problem — They're a UI Problem
Ship AI products that improve with every user interaction by designing feedback into the interface, not the training pipeline.
Read noteVibe Coding Is Not a Shortcut to Great Products
Why the ease of AI code generation makes product engineering discipline more essential, not optional.
Read noteAccessibility Is a Product Decision, Not a Compliance Checklist
Why treating accessibility as a release criteria instead of an audit changes how you build components, manage states, and ship with confidence in 2026.
Read noteMultimodal Isn't a Feature Toggle — It's a New Interface Contract
Shipping multimodal input means rethinking state management, error boundaries, and user trust, not just wiring up vision APIs.
Read noteThe UI Contract: Why Your AI Product Feels Like a Black Box
Shipping AI means designing the interface between what the model can prove and what the user expects. Here's how to build that contract honestly.
Read noteYour Design System Needs to Be Machine-Readable First
Why structuring design tokens for AI coding agents yields better prototypes and faster shipping — and how Claude Design and DESIGN.md prove it.
Read noteThe Interface Contract Is the Product: Why AI Features Fail Before the Model Runs
Latency budgets, failure modes, and the unglamorous discipline of shipping AI that users trust.
Read noteThe System Prompt Is a Product Interface — Treat It Like One
Why the invisible prompt that governs your AI feature needs versioning, evals, and error states — just like any UI component.
Read noteAI Governance Is a Product Interface Problem — Ship It Before August 2026
The AI Act's transparency rules hit in August 2026. Here's how to engineer compliance into your product's UI, data flows, and audit trails — not just a policy doc.
Read noteConcentric Feedback Loops: The Engineering Discipline That Makes AI Products Actually Improve
Why passing AI-generated tests isn't enough, and how to design feedback loops that turn production errors into training signals.
Read noteVibe Coding Is the Easy Part. The Review Layer Is Where You Ship or Fail.
Why AI-generated code alone isn't enough—and how a product engineer's real value is in the review layer that ensures quality, performance, and coherence.
Read noteAccessibility Is a Product Boundary, Not a Compliance Checkbox
Why shipping accessible products in 2026 means treating WCAG as a design constraint, not a QA gate — and how that changes your architecture.
Read noteMultimodal AI Is Not a Feature — It's a New Interface Contract
Shipping multimodal AI means designing for latency, modality switching, and honest failure modes — not just wiring up a model.
Read noteTrust as a UX Contract: What AI Products Must Prove to Users
Shipping AI features means earning user trust through interface design, not privacy policies. A product engineer's take on the 2026 trust landscape.
Read noteAI Evaluation Is a Product Interface Contract, Not a QA Step
Why evaluation belongs in the product engineering workflow, not as a post-hoc ML task — and how to design for it.
Read noteYour Design System Is Already Dead — Here’s What Comes Next in 2026
The shift from component libraries to token-driven, AI-native design systems—and how product engineers should adapt.
Read noteExplainable AI UI Is a Product Contract, Not a Feature
Why explainable AI interfaces are the most important product decision you'll make in 2026 — and how to ship them without the hype.
Read noteWhy Your Frontend Agency Is Shipping the Wrong Thing
How to evaluate frontend partners by product judgment, not portfolio polish — and why most teams get this wrong in 2026.
Read noteThe Trust Layer Is the Product: Shipping AI in 2026
Why transparency, citation design, and governance are the real differentiators in AI products — not model quality.
Read noteVibe Coding Is Not Enough: Why Shipping Judgment Is the New Engineering Discipline
In 2026, AI generates code faster than ever. But shipping a product you can stand behind requires a different skill: knowing when to trust the output, when to override, and when to say no.
Read noteThe Hard Part of AI Video Isn't the Model Quality — It's the Latency Contract
Shipping AI video features means designing for 2-5 second generation times, fallback chains, and UI states that don't lie.
Read noteRUM Is Cheap. Observability Is Where You Learn What Users Actually Experience.
Why integrating real user monitoring with full-stack observability is the only way to understand what your product feels like to real users.
Read noteEngineering case study pages that rank (not just look pretty)
Brent Haskins structures /projects pages for search: specific titles, stack tags, outcomes, and blog posts that point inward.
Read noteRUM Is Not a Dashboard Problem: Why the Honeycomb-Embrace Partnership Matters for Product Engineers
Frontend observability has been siloed from backend traces. The Honeycomb-Embrace integration changes how we debug real user issues.
Read noteThe Slider Is a Lie: Why Most Range Controls Fail in Production
A product engineer's take on when sliders work, when they don't, and how to design them so they survive real users.
Read noteTypography Is Infrastructure: Building Type Systems That Ship
How to build a type system that ships — with performance, consistency, and accessibility, based on real product experience.
Read noteThe AI Agent Interface Is a UX Contract, Not a Chatbot Window
When AI agents handle 75% of data analysis, your UI job becomes designing trust, transparency, and undo — not charts.
Read noteBackground Agents Are the New Frontend: What Product Engineers Need to Know
Shipping reliable background agents requires product engineering discipline, not just platform hype. Here's what I've learned from building them.
Read noteTypography Is a Performance Decision: Why Font Loading Belongs in Your Product Engineering Backlog
Typography is a performance and product decision. Here's how to treat font loading as a system, not a design asset.
Read noteYour Architecture Is a Product Decision, Not a Technical One
Why the most important architectural choices are about iteration speed, team autonomy, and customer trust—not just scalability.
Read noteDark Mode First: Why Your SaaS Dashboard Should Default to Dark and How to Ship It
Opinionated lessons from shipping a dark-first admin dashboard template built on Next.js 16, React 19, shadcn/ui, and Tailwind CSS v4.
Read noteThe Real Cost of a UX Audit in 2026: When to Pay $2,500 and When to Walk Away
Focused flow audits beat full product audits for most teams. Here's how to decide—and when AI tools are the smarter.
Read noteWhy Your AI Feature Needs a BEAM-Native Architecture (and What That Actually Means)
Most SaaS teams bolt on AI without rethinking architecture. Here's why concurrency and resilience primitives matter more than model accuracy.
Read noteAn engineering blog beats LinkedIn for hiring SEO — if the posts are real
Why Brent Haskins publishes on brenthaskins.com: E-E-A-T, long-tail queries, and proof that survives an AI-slop filter.
Read noteNext.js vs React in 2026: The Framework Decision That Actually Matters
Why choosing React alone in 2026 means choosing to build infrastructure you don't need, and how Next.js changes the performance calculus.
Read noteYour SaaS Dashboard Is a Data Dump. Here’s How AI and UX Fix It.
How to build a SaaS dashboard that uses AI for real decisions, not just data dumps — grounded in shipped product experience.
Read noteReact vs HTMX in 2026: The Framework Debate That Misses the Point
Why the React vs HTMX debate is a distraction — and what actually determines frontend success in shipped products.
Read noteYour SaaS Dashboard Is Probably Overengineered: What I Learned Shipping AI-Powered Admin Panels in 2026
Most teams build dashboards for the demo, not for daily use. Here's how to ship one that actually works, with AI, in 2026.
Read noteSkeleton Screens Are Not Free: The Real Cost of Perceived Performance
Skeleton screens feel like a UX win, but they introduce real engineering debt. Here's when to use them, when to skip them, and how to ship them without regret.
Read noteThe React Compiler Won't Save Your Product — Here's What Will
React 19.2's compiler automates memoization, but product engineers still need to architect for performance, not just rely on tools.
Read noteSkeleton Screens Are Not a Performance Hack — They Are a UX Contract
Why skeleton screens fail when treated as loading placeholders and how to design them as perceived-performance guarantees.
Read noteCore Web Vitals in 2026: Why Indexing Matters More Than Speed
A real-world case shows fixing indexing issues had a bigger traffic impact than speed optimization. Here's what product engineers should prioritize.
Read noteCore Web Vitals in 2026: Why Your Product's Performance Strategy Is Probably Wrong
The metrics that matter have shifted. Here's what shipped product experience teaches about INP, indexing, and the real cost of slow JavaScript.
Read noteAI Agents in 2026: From Demos to Production with Security and Control
A grounded look at the 2026 AI agent landscape: practical automation, security gaps, and what builders need to know.
Read noteAI product engineering needs clear interfaces before bigger models
A practical note on why AI products need strong interfaces, evaluation loops, and security boundaries before adding more model complexity.
Read noteDark Mode Isn't a Theme — It's a Design System Stress Test
How shipping dark mode forced our team to finally get design tokens right, and why yours will too.
Read noteRallyLeads pipeline: tags, notes, and CSV export brokers actually use
Lead capture is step one; officers live in tags, notes, and export until the LOS catches up.
Read noteAuri music-aware posts: one media type without hijacking the feed
Native social design choice: music attachments with controls that stay secondary to the post.
Read noteProduct engineer in Phoenix, Arizona — Brent Haskins
Senior product engineering from Phoenix, AZ: SaaS, applied AI, iOS, and studio delivery. Open to relocate; remote-friendly shipping record.
Read noteHow this site's sitemap sets lastModified for blog posts
app/sitemap.ts uses file mtime from getAllBlogPosts when present—what that means after you edit or add markdown.
Read noteLoan Finder shows borrowers which documents lenders accessed
Secure sharing needs a consent log borrowers can read—not a black box behind the lender dashboard.
Read noteHow this blog links posts to /projects case studies
Mortgage, forms, and Mac utility clusters on brenthaskins.com—manual internal links Brent Haskins maintains when adding posts.
Read noteSMT loan analysis puts course math on scenarios officers bring from work
Smart Mortgage Training ties modules to a loan analysis tool—not only video completion metrics.
Read noteRate limits on public form endpoints are part of UX
Formably-style abuse protection: per-IP throttling, honest 429 responses, and owner-visible spikes—not silent drops.
Read noteDrawer verifies duplicate files by size and hash before delete
Mac Downloads cleanup: Brent Haskins built Drawer to cluster related files and only flag duplicates when size and hash agree.
Read noteFormably blocks unusable brand color pairs before publish
WCAG contrast checks in the form builder—not an afterthought in the CSS file.
Read noteThe summary field on each post is written to stand alone
brenthaskins.com renders frontmatter summary under the title—here is how Brent Haskins writes those blocks without repeating the FAQ or body.
Read noteHow to hire a product engineer (and what to look for in a portfolio)
A hiring guide from Brent Haskins: evidence in shipped URLs, component judgment, and scope control—not framework trivia or AI buzzwords on a resume.
Read noteFreelance product engineer vs studio: how to choose
Brent Haskins runs Asper Studio and ships personal products—when a solo IC fits versus a small senior team.
Read notegenerateMetadata on each blog and project route
Exact Next.js App Router metadata on brenthaskins.com—title, description, canonical, Open Graph article fields.
Read noteLead email alerts on RallyLeads and Formably are transactional, not marketing blasts
Instant notification email when a form or broker lead submits—what we optimized and what we measure.
Read noteFAQ sections on this blog: frontmatter, HTML, and JSON-LD
How brenthaskins.com only emits FAQPage schema when two or more FAQs render on the page—implementation detail from app/blog/[slug]/page.tsx.
Read notePortfolio motion should respect reduced motion by default
How brenthaskins.com uses GSAP and Lenis on desktop—and stacks projects on mobile when users ask for less motion.
Read noteMortgage broker blogs need local SEO pages, not WordPress neglect
RallyLeads ships broker blogs with sitemaps and site structure—why content pages rank and how to write for borrowers in your service area.
Read noteWho is Brent Haskins? Applied AI product engineer
A direct profile for search and answer engines: Phoenix-based product engineer shipping mortgage SaaS, AI forms, iOS apps, and studio work at Asper.
Read noteWhat this site's blog markup actually does (not AEO guarantees)
Precise documentation of brenthaskins.com: frontmatter summary, visible FAQs, BlogPosting and FAQPage JSON-LD, and markdown sanitization—written by the engineer who built it.
Read noteCo-founder product engineers split vision from implementation on mobile
Lessons from Auri as co-founder: encrypted messaging, accessibility, and beta discipline when two people wear product and engineering hats.
Read noteNative Swift beats Electron for file-heavy Mac apps
Brent Haskins compares Shelf, Drawer, and Draft: when Vision OCR, filesystem watchers, and thermal limits push you off cross-platform shortcuts.
Read noteA Next.js MVP wins when you cut scope, not when you win framework debates
Brent Haskins on shipping Formably and broker sites: one workflow, honest SEO, server boundaries for secrets—without a twelve-week architecture tour.
Read noteScreenshot search fails without Finder tags and date groups
Shelf Studio: why a visual grid plus on-device OCR still needs the file metadata users already maintain in macOS.
Read noteRadix and Tailwind work for desktop utility UIs—not only marketing sites
Draft uses Electron, React, Radix UI, and Tailwind for a fast palette UI—patterns Brent Haskins reused from web SaaS on a local-first tool.
Read noteOn-device OCR is a product feature, not a privacy footnote
Lessons from building Shelf and Drawer—desktop utilities where local text recognition, hashing, and review-first UX define trust.
Read noteBorrower–lender matching works when you trade noise for structured signal
Building Loan Finder: how matching algorithms, document sharing, and dashboards should read to borrowers who are not mortgage experts.
Read noteSAFE exam prep needs practice loops, not slide decks
Smart Mortgage Training: flashcards, loan analysis, and module quizzes as one study loop for loan officers.
Read noteMortgage training platforms need job tools, not just CE checkboxes
Lessons from Smart Mortgage Training: courses, loan analysis, flashcards, and Mortgage AI as one workspace loan officers actually open at work.
Read notePublic form spam is a product problem, not only a CAPTCHA checkbox
Lessons from Formably: rate limits, honeypots, field validation, and alert noise—before marketing turns on unlimited responses.
Read noteFix dashboard empty states before you add another chart
Brent Haskins on broker pipelines and training analytics: readable zero-data UX, role-aware copy, and why most 'AI insights' panels fail.
Read noteReal-time status beats socket theater for most SaaS
Brent Haskins on loan pipelines and training dashboards: polling, SSE, and honest stale indicators before you add a WebSocket layer.
Read noteSwift iOS apps ship when you treat App Store review as part of engineering
Brent Haskins on shipping Auri, Floom, and Story World: TestFlight rhythm, privacy manifests, and native UX choices that pass review without fire drills.
Read noteSelling Unreal Engine tools on Fab is a product job, not a upload
Asilo Studios and the Modular Horror System: listings, docs, version compatibility, and support load for Blueprint frameworks buyers expect to drop in.
Read noteLegacy modernization without a big-bang rewrite
Asper Studio approach: strangle the riskiest user paths first, ship parallel UIs, and measure adoption before decommissioning.
Read noteBlueprint frameworks are products too — lessons from shipping horror systems on Fab
Asilo Studios’ Modular Horror System shows how indie game infrastructure wins when docs, defaults, and modular boundaries ship alongside Blueprints.
Read noteChild-safe multimodal AI needs a bedtime contract, not a bigger model
What shipping Story World taught about narrated, illustrated stories—parental controls, voice selection, and predictable rituals beat raw generation quality.
Read noteFor mortgage brokers, the marketing site is the product — not a brochure
Why broker-in-a-box products win when SEO pages, lead forms, and pipeline tools ship as one surface instead of three vendors.
Read noteWebhooks are a product surface, not an integration afterthought
From RallyLeads and Formably: how Zapier-friendly webhooks, retries, and failure copy keep SaaS products honest when customers wire their own stack.
Read noteFintech product engineer for mortgage software — what to expect
Brent Haskins on building broker sites, training platforms, and matching tools: compliance copy, document flows, and shipping speed in a regulated vertical.
Read noteCustom domains for broker sites need SSL, redirects, and honest SEO
RallyLeads-style setup: when brokers attach their domain, product engineering owns TLS, www rules, and sitemap URLs—not a DNS tutorial in support.
Read noteIn social apps, encryption and accessibility belong on the same roadmap
Building Auri showed that creator-first social products cannot treat E2E messaging and accessibility as separate betas—they shape the same trust surface.
Read noteFigma handoff ends at states, not pixels
Brent Haskins on shipping UI without drift: component APIs, real empty/error flows, and why engineers should pair in Figma before the ticket queue.
Read noteHalf-asleep idea capture needs structure later, not forms now
Floom by Brent Haskins: fast mobile input, tags and search, and AI categorization that runs after the spark—without sending your notebook to the cloud by default.
Read noteA product engineering studio ships code, not strategy decks
How Asper Studio works: AI integration, web and mobile apps, and modernization—100+ deliveries across fintech, healthcare, and SaaS by founder Brent Haskins.
Read noteA local-first prompt library beats another cloud notes app
Brent Haskins on building Draft: desktop prompt storage, a global hotkey palette, and JSON you can back up—without accounts or sync servers.
Read noteMortgage AI should cite curriculum, not guess policy
Shipping Mortgage AI inside Smart Mortgage Training: scoped Q&A, compliance tone, and why training chatbots fail when they behave like general assistants.
Read noteForm builders should not tax growth with per-response fees
Why Formably ships unlimited submissions: pricing psychology, backend cost discipline, and SEO for teams comparing Typeform alternatives.
Read noteWhat is a product engineer? Brent Haskins explains the role he ships under
Product engineers own UI, APIs, and product tradeoffs together—not handoffs between design tickets and Jira. How Brent Haskins works across SaaS, AI, and native apps.
Read noteAI form generation needs a brand contract, not just a prompt
How Formably-style products keep natural-language generation trustworthy with WCAG-aware branding, global defaults, and per-form overrides.
Read noteApplied AI systems need operational UI, not demo chat
Brent Haskins on shipping AI in production: retrieval boundaries, human confirmation, and screens that show what the system can prove.
Read note