Insights
Notes on design, engineering, and getting cited by AI.
Practical writing on how we design and build products end to end — and on generative engine optimization, the work of getting your brand into AI answers.
No-Code MVP vs Custom MVP: Choose by Risk, Not Fashion
A risk-based comparison of no-code and custom MVPs, including the point where platform convenience weakens the test itself.
Read →
Proof of Concept vs Prototype vs MVP
Three early-product artefacts, three different questions—and a sequence for using only the ones that reduce real uncertainty.
Read →
Prototype vs MVP: What Should You Build First?
A decision guide for choosing the cheapest credible test instead of calling every early artefact an MVP.
Read →
What Should an MVP Include—and What Should Wait?
A scope test for separating the complete product slice required for learning from features that merely make the release look larger.
Read →
How Long Does It Take to Build an MVP?
A realistic MVP schedule from problem definition through launch, with the dependencies and scope choices that control time.
Read →
How Much Does It Cost to Build an MVP in 2026?
Realistic MVP planning ranges, the work behind them, and a method for cutting uncertainty and scope without building a disposable demo.
Read →
How to Measure Whether a Website Redesign Worked
A measurement plan that connects user tasks, business value, search, quality, and operations without claiming the website caused everything.
Read →
How to Build a Redirect Map for a Website Migration
A spreadsheet structure and decision process for mapping old URLs to relevant final destinations without homepage dumping.
Read →
Changing Domains: What Happens to SEO and How to Protect It
The technical and editorial sequence for moving domains without casually discarding URLs, links, or search understanding.
Read →
The Website Migration Checklist: Before, During, and After Launch
A release checklist for preserving search value and operational reliability while changing URLs, domains, CMS, or rendering.
Read →
How to Plan a Website Redesign From Evidence, Not Taste
A redesign-planning sequence that protects earned value, exposes the real problem, and keeps preference from becoming strategy.
Read →
How Long Should a Website Redesign Take?
A realistic redesign schedule showing what happens in each phase and which dependencies quietly move the launch date.
Read →
How Much Does a Website Redesign Cost in 2026?
Realistic redesign ranges, the work behind them, and a method for reducing scope without weakening the foundation.
Read →
11 Signs Your Website Needs a Redesign
Eleven evidence-based warning signs—and how to tell a structural redesign problem from a smaller fix.
Read →
How Often Should You Redesign Your Website?
The evidence that justifies a redesign, the problems smaller improvements can solve, and a better rhythm than replacing everything.
Read →
How to Choose Website Hosting Without Overbuying Infrastructure
A hosting decision framework based on the system and its failure modes—not impressive specifications the website may never use.
Read →
Who Owns the Code, Domain, and Design After a Website Project?
A plain-language ownership and handover checklist for the assets, accounts, code, content, and licences behind a website.
Read →
What Website Maintenance Should Actually Include
A practical maintenance scope covering prevention, monitoring, recovery, reporting, and the work retainers often leave vague.
Read →
How Much Does Website Maintenance Cost?
Realistic planning ranges and a checklist for separating hosting, maintenance, support, warranty, and ongoing improvement.
Read →
Static vs Dynamic Websites: What Changes in Cost and Capability?
A plain-language comparison of static and dynamic delivery—and why most modern websites do not need to choose only one.
Read →
Headless CMS vs Traditional CMS: A Decision Guide
A practical architecture decision based on content reuse, editorial work, engineering capability, and total operating cost.
Read →
How to Choose the Right CMS for Your Website
A CMS decision framework built around actual editorial work, technical constraints, and the cost of owning the system.
Read →
How Many Pages Does a Business Website Actually Need?
A decision method for finding the right website page count without padding the sitemap or forcing unlike content together.
Read →
Website Requirements: A Practical Guide for Non-Technical Teams
A plain-language method for turning website needs into testable requirements without pretending to be the technical team.
Read →
How to Write a Website Brief That Produces Better Work
A practical website-brief structure that gives agencies enough clarity to think—and enough room to solve the right problem.
Read →
What Your Web Agency Needs Before the Project Starts
The client-side inputs and decisions that let a website team begin with evidence instead of expensive guesswork.
Read →
What a Good Website Proposal Should Include
The clauses and questions that turn a website proposal from persuasive sales material into a useful delivery agreement.
Read →
How to Choose a Web Design Agency Without Buying a Sales Pitch
Twelve practical tests for separating a capable web partner from a polished sales process.
Read →
Web Agency vs Freelancer: How to Choose for Your Project
A risk-based comparison of freelancers, agencies, and small studios for website projects.
Read →
Custom Website vs Template: Which One Does Your Business Need?
An honest comparison of custom and template websites—and a decision framework based on constraints, not status.
Read →
How to Redesign a Website Without Losing SEO
The evidence-led migration process for changing design, content, URLs, or technology without casually discarding earned search visibility.
Read →
How Long Does It Take to Design and Build a Custom Website?
A realistic phase-by-phase website timeline, the delays teams underestimate, and how to launch faster without lowering the quality bar.
Read →
How Much Does a Custom Website Cost in 2026?
Realistic 2026 planning ranges, the seven factors that change a quote, and a practical way to set the right website budget.
Read →
How to Build an Audit Log People Can Actually Use
A trustworthy audit log answers who changed what, when, where, and with what result—without forcing people to read raw system output.
Read →
How to Design Search Inside a Product
Product search is not an input connected to a database query. It is a ranking system built around what people are trying to find.
Read →
Internationalization Is an Architecture Decision, Not a Translation Task
Translation changes words. Internationalization changes the assumptions that let a product work across languages and regions.
Read →
How to Design Error States Users Can Recover From
Error messages are not explanations unless they help someone decide what to do next.
Read →
How to Model Product Data Before Writing Code
Turn product language into a durable data model before screens and endpoints make accidental architecture permanent.
Read →
How to Design Roles and Permissions Before the UI
A practical method for defining who can see, create, change, approve, and delete each part of a product before interface work begins.
Read →
The Tools Reshaping Front-End Development in 2026
Build tooling speed improvements, AI-assisted coding, and native browser capability growth are compounding into a genuinely different front-end stack.
Read →
Edge Rendering: What It Means for Your Site
What edge rendering actually changes about where and how a page is generated, and whether it's worth adopting for a given site.
Read →
Are We Past the JavaScript Framework Wars?
Whether the era of intense JavaScript framework competition has settled, and what that means for how teams should make choices now.
Read →
The State of CSS in 2026
Native features that have replaced preprocessor and JavaScript workarounds, and what this means for modern styling architecture.
Read →
What’s Actually New in Web Development This Year
Distinguishing genuinely new, adoptable web development capabilities this year from incremental noise.
Read →
Ship Small, Ship Often: A Studio’s Take
Why shipping small, frequent changes produces better outcomes than large, infrequent releases, from a working studio's perspective.
Read →
The Real Cost of Technical Debt
How technical debt actually costs a team over time, beyond the abstract metaphor, and why it's worth measuring and addressing deliberately.
Read →
Performance Is a Feature, Not a Phase
Performance should be treated as an ongoing product feature with continuous investment, not a one-time optimization phase before launch.
Read →
The Case for Boring Technology
Choosing proven, well-understood technology over exciting new tools for most of a project's technical decisions, and where to actually innovate instead.
Read →
Why We Run Design and Development as One Team
Treating design and development as one integrated team, rather than separate departments with a handoff, produces better products.
Read →
How to Optimize a Web Font for Speed
Subsetting, format choice, font-display strategy, and self-hosting versus third-party delivery for faster web fonts.
Read →
How to Set Up Automated Visual Regression Tests
Capturing baseline screenshots, tuning sensitivity to avoid false positives, and integrating visual regression testing into CI.
Read →
How to Migrate From WordPress to a Static Front End
Content export, URL preservation, redirect handling, and what to keep versus rebuild in a WordPress-to-static migration.
Read →
How to Secure a Static Site With HTTP Headers
Content-Security-Policy, HSTS, and the other HTTP security headers worth setting even without server-side logic.
Read →
How to Measure Real-User Performance
What to collect, how to segment it, and turning real-user performance data into action.
Read →
How to Add Dark Mode With CSS Variables
Theme scoping, respecting system preference, and avoiding a duplicated stylesheet when implementing dark mode.
Read →
How to Set Up Design Tokens in Code
From a design tool's token definitions to CSS variables or a build pipeline, and keeping the two layers in sync.
Read →
How to Set Up a CI/CD Pipeline for a Small Team
What to automate first, keeping the pipeline fast, and avoiding over-engineering for a team's actual size.
Read →
How to Add a Headless CMS Without the Bloat
When a headless CMS is actually needed, choosing a lean option, and keeping the front end static where possible.
Read →
How to Structure a Scalable Next.js Project
Folder organization, route grouping, shared component placement, and data-fetching conventions that scale past the starter template.
Read →
From Prototype to Production: Shipping Web Apps That Last
What changes between prototype and production, the checklist most teams skip, and building for maintainability from day one.
Read →
Modern Front-End Architecture: A Complete Guide
Rendering strategies, component structure, state management, and choosing the right approach for a project's actual needs.
Read →
Motion Design Patterns Worth Adopting Now
Systemized easing and duration tokens, purposeful micro-interactions, and where restraint beats spectacle in current motion design.
Read →
How AI Tools Are Changing the Designer’s Workflow
Where AI tools genuinely help the design workflow, where they fall short, and how the designer's role is actually shifting.
Read →
Bento Grids: Hype or Here to Stay?
What bento grids are genuinely good for, where they're overused, and whether the pattern has real staying power.
Read →
The Return of Editorial Layouts on the Web
The resurgence of editorial, print-influenced layouts on the web, what's enabling it technically, and how to apply it well.
Read →
Design Trends That Will Actually Stick in 2026
Distinguishing which 2026 design trends reflect durable shifts in how products are built versus which are likely short-lived visual fashion.
Read →
Accessibility Is Not a Feature
Accessibility should be treated as a baseline requirement of good design, not an optional add-on feature to be scoped separately.
Read →
Why Your Brand Is More Than a Logo
Brand identity extends far beyond a logo mark, and treating the logo as the whole deliverable undersells what actually builds recognition and trust.
Read →
Good Design Is Invisible Until It’s Gone
Good design is often unnoticed by users, and that invisibility is a sign of success rather than a lack of recognition.
Read →
Why Consistency Beats Creativity in Product UI
Consistency, not novelty, is what makes product UI usable — and where creative energy is actually better spent instead.
Read →
The Myth of the Pixel-Perfect Handoff
Pursuing a pixel-perfect design handoff misses the point of what actually makes design-to-development collaboration work.
Read →
UI vs UX: The Difference That Actually Matters
The practical difference between UI and UX, beyond the often-repeated dictionary definitions, and why conflating them causes real problems.
Read →
How to Run a Usability Test With Five People
Task selection, moderation technique, and how to turn five participants' observations into concrete fixes.
Read →
How to Design Dark Mode Without Doubling Your Work
Building dark mode into the semantic token layer from the start, rather than maintaining two entirely separate designs.
Read →
How to Document a Component for Handoff
States, spacing, content rules, and behavior specifications that let engineering build a component correctly the first time.
Read →
How to Prototype an Interaction Before You Build It
Choosing fidelity level, what to actually test, and when a prototype is good enough to build from.
Read →
How to Write Microcopy That Reduces Support Tickets
Writing labels, errors, empty states, and tooltips that prevent confusion before it becomes a support ticket.
Read →
How to Set Up a Type Scale With CSS Variables
Modular scale ratios, responsive sizing, and keeping design and code in sync when implementing a type scale.
Read →
How to Design Forms People Finish
Field reduction, inline validation, smart defaults, and error messages that actually help — the specifics that move completion rates.
Read →
How to Build a Spacing Scale You’ll Actually Use
How to build a spacing scale small enough and clear enough that teams reach for it by default instead of arbitrary pixel values.
Read →
How to Turn Figma Designs Into a Component Library
Naming conventions, variant structure, and keeping design and code components in sync as your product grows.
Read →
How to Run a Design Audit on Your Own Product
What to check for consistency, accessibility, and usability, and how to prioritize what to fix first.
Read →
A Complete Guide to Brand Identity for Startups
Positioning, naming, visual identity, voice, and how to sequence the work with limited budget and time.
Read →
The Rise of Answer Engines: A Field Report
AI answer engines have grown into a distinct category of information-seeking behavior. An honest look at where it stands and what it means.
Read →
Schema.org Updates Worth Knowing This Quarter
Staying current with schema.org and structured data changes, and a practical process for reviewing your markup periodically.
Read →
Zero-Click Search: The New Baseline
Zero-click search has become the default outcome for many query types. Here's how to build a strategy that still generates value from it.
Read →
How LLM Search Is Reshaping Buyer Journeys
AI-mediated search is changing buyer journeys — earlier research stages are moving into chat interfaces, reshaping what content needs to do.
Read →
What Google’s Latest Core Update Means for You
What actually changes with a core update, common overreactions to avoid, and a practical response checklist.
Read →
The State of Generative Engine Optimization in 2026
What's proven, what's still speculative, and where the generative engine optimization discipline is heading.
Read →
AI Overviews: What Changed in Search This Year
How AI-generated search overviews have changed the results page this year, and what it means for content and citation strategy.
Read →
Why Speed Is a Ranking Feature, Not a Nice-to-Have
Page speed is a core ranking and trust signal deserving the same priority as content quality, not an optional polish item.
Read →
The Case Against Chasing Every Keyword
Chasing every available keyword variation dilutes effort better spent building fewer, deeper pieces of content.
Read →
Why Your Brand Needs a Point of View to Rank
Neutral, consensus-restating content underperforms content with a genuine point of view, both for search and for AI citation.
Read →
Content Farms Can’t Win the AI Era
Thin, high-volume content strategies are especially poorly suited to an AI-mediated search era that rewards depth and trust.
Read →
Why Most SEO Advice Ages Badly
Most SEO advice has a short shelf life. Here's the small set of fundamentals that have actually held up over time.
Read →
The Death of the Ten Blue Links
Search results have moved past the ten-blue-links format. Here's what that shift actually means for how content should be built.
Read →
GEO vs SEO: Why You Now Need Both
GEO and SEO aren't competing strategies — they share a technical foundation and diverge only at the final content layer.
Read →
How to Measure Whether AI Engines Are Citing You
Manual prompt testing, referral traffic signals, and building a simple tracking routine without expensive tooling.
Read →
How to Turn One Pillar Post Into a Topic Cluster
Finding sub-questions, prioritizing which to write first, and linking it all together around an article you've already published.
Read →
How to Audit a Page for AI Visibility in 15 Minutes
A fast, practical checklist covering answer clarity, structured data, speed, and crawlability.
Read →
How to Fix the Core Web Vitals That Hurt Your Rankings
Concrete, common fixes for the three Core Web Vitals — Largest Contentful Paint, Interaction to Next Paint, and Cumulative Layout Shift.
Read →
How to Write Content That AI Answer Engines Actually Quote
Sentence-level clarity, self-contained claims, and the editing pass that makes the difference between readable and quotable content.
Read →
The Topic Cluster Playbook: Building Search Authority
Pillar page structure, supporting article selection, internal linking patterns, and how clusters build durable search authority.
Read →
Why Your Site Doesn't Need a Framework
Most content-driven sites reach for a JavaScript framework by default. Plain HTML, CSS, and vanilla JS would often serve them better.
Read →
How to Write CSS That Doesn't Fight You
Specificity discipline, a naming convention, avoiding !important, and structuring styles so they don't accumulate into unmanageable overrides.
Read →
How to Build an Accessible Modal From Scratch
Focus trapping, keyboard handling, ARIA roles, and the mistakes that break screen readers.
Read →
How to Cache Assets for Instant Repeat Visits
Cache headers, versioned filenames, and the difference between caching HTML and caching everything else.
Read →
How to Lazy-Load Images the Right Way
Which images to lazy-load, which to load eagerly, and the common mistakes that hurt Core Web Vitals instead of helping.
Read →
What Are Large Language Models (LLMs)? The Complete Guide
The complete, plain-English guide to large language models — how they work, the major models in 2026, what they get wrong, how to prompt them, and how they are changing search.
Read →
How to Ship a Static Site With Zero Build Step
When zero-build is the right choice, how to structure it, and how to still get componentization and content management without a bundler.
Read →
A Complete Guide to Web Performance
The metrics that matter, the biggest levers — images, fonts, JavaScript, caching — and how to build a performance budget that holds.
Read →
Why Design Systems Fail (and How to Save Yours)
Design systems fail from lack of ownership and governance, not bad initial components. Here's how to recover one that's already drifted.
Read →
How to Design Empty States That Guide Users
The three empty-state types, what each needs, and common mistakes that leave users stuck.
Read →
How to Design an Onboarding Flow That Converts
Reducing steps, showing value before asking for commitment, and where progressive disclosure beats a full tour.
Read →
How to Create Accessible Color Contrast
WCAG ratios explained, common failure points, and how to bake contrast into a design system instead of checking it late.
Read →
How to Choose Typography for a Digital Product
Legibility at UI sizes, weight range, pairing fonts, and building a type scale that holds up across a whole product.
Read →
How to Build a Color System With Design Tokens
Scale construction, semantic naming, dark mode support, and accessible contrast by default.
Read →
Building a Design System That Scales
Token architecture, component documentation, governance, and how to avoid the failure modes that quietly kill most design systems.
Read →
Why "Write for Humans" Is No Longer Enough
Writing for humans is necessary but no longer sufficient — content now has a third reader that needs structure, not just good prose.
Read →
How to Add JSON-LD Structured Data to Any Page
Which schema types matter most, how to nest them correctly in one @graph, and how to validate before shipping.
Read →
How to Optimize Images for Speed and Search
Formats, compression, sizing, alt text, and lazy loading done correctly — for both page speed and search visibility.
Read →
How to Build Internal Links That Actually Move Rankings
How link equity flows internally, anchor text that works, orphan pages, and building topic clusters that reinforce each other.
Read →
How to Create an SEO-Friendly URL Structure
Readable paths, folder logic, what to avoid, and how to handle changes without losing rankings.
Read →
How to Set Up Google Search Console the Right Way
Property type, verification, sitemap submission, and the reports actually worth checking weekly.
Read →
The Product Design Process, End to End
A complete walkthrough of the product design process: discovery, research, structure, interface design, prototyping, and handoff.
Read →
How to Write Meta Titles and Descriptions That Get Clicks
Length limits, what actually earns clicks, and the common mistakes that quietly waste a page's search listing.
Read →
How to Do Keyword Research Without Expensive Tools
Real keyword research using Google Search Console, autocomplete, People Also Ask, and competitor titles — no subscription required.
Read →
How to Structure an Article for Featured Snippets
The paragraph, list, and table formats Google pulls into position zero, and how to write for each.
Read →
Why We Deleted the Handoff
Why Troiana runs design and development as one team — and how the classic design-to-development handoff quietly wastes a project.
Read →
Technical SEO for Modern Websites: A Complete Guide
The crawlability, indexing, speed, and structure fundamentals that determine whether your content can be found at all.
Read →
How to Add FAQ Schema That Wins Rich Results
How to write and implement FAQPage structured data correctly, and why it matters beyond search rich results.
Read →
How to Build an llms.txt File for Your Site
What llms.txt is, what belongs in it, and how to keep it accurate as your site grows.
Read →
How to Get Your Brand Cited by ChatGPT, Claude, and Gemini
A step-by-step guide to get Your Brand Cited by ChatGPT, Claude, and Gemini.
Read →
The Complete Guide to Generative Engine Optimization (GEO) in 2026
The Complete Guide to Generative Engine Optimization (GEO) in 2026 — a complete, practical guide with clear takeaways.
Read →
What Is Generative Engine Optimization (GEO)?
Search is shifting from a list of links to a single generated answer. GEO is how you make sure your brand is in that answer.
Read →
What Is Product Design? The Discipline Behind the Screens
The part you don’t see: the flows, the states, and the decisions that make the interface worth drawing.
Read →
UI vs UX: What’s the Difference, and Why You Need Both
Two words, endlessly confused. The honest line between them — and why a product needs both.
Read →
What Goes Into a Brand Identity (Beyond the Logo)
The logo is the smallest part. The identity is the system that makes the logo mean something.
Read →
What Is Product Engineering? The Logic Under the Interface
Front-end turns a design into a screen. Product engineering builds the machine behind it.
Read →
What Makes a Website Fast, Accessible, and Built to Last
The quiet decisions, made early, that separate an effortless site from one that fights back.
Read →
GEO vs SEO: What Is the Difference, and Do You Still Need Both?
They share DNA, but they optimise for different moments. Here is how to run them together.
Read →
How to Get Your Brand Cited by ChatGPT and AI Search
The moves that make your content easy for an AI engine to quote — and trust.
Read →
Why the Design-to-Development Handoff Breaks Products
Every spec is a translation. Every translation loses something.
Read →
Design Tokens Explained: One Source of Truth for Design and Code
The smallest unit of a design system, and the reason it stays in sync.
Read →
Core Web Vitals: A Practical Guide for Product Teams
Three metrics that decide whether your site feels fast — and what to do about each.
Read →