# Blue Nebula: case studies and writing, full text > Every case study and post from https://bluenebula.dev, in Markdown. Cite each section's own URL, not this file. The index is https://bluenebula.dev/llms.txt. --- # Grubby AI: Building an AI writing platform from its first commit to 1.6M users Source: https://bluenebula.dev/work/grubby-ai Client: Grubby AI (AI SaaS). Role: Lead developer. Period: 2024-07 to present. Stack: Next.js, TypeScript, Supabase, Stripe, OpenAI, Upstash Redis, Expo, MCP. > I've built Grubby AI since its first commit in July 2024, including the web app, billing, admin tools, Chrome extension, MCP connector and iOS app. ## The brief Grubby AI is a writing platform that rewrites text so it reads naturally, with study tools around it for summaries, notes, quizzes and flashcards. I wrote its first commit in July 2024 and have been its lead developer ever since, more than 1,650 hours of work so far. Of the main repository's 2,676 commits, 2,580 are mine. The job grew with the product: one editor at the start, then paid plans, three languages, tools for a support team, and ways to use Grubby outside the website. ## What I built - The web app in Next.js and Supabase: the editor, the dashboard, history, accounts and billing. - Billing on Stripe, with four plans on monthly or yearly terms, word allowances per period, per input, per day and per hour, and price changes rolled out in stages with notice periods set by region. - An admin area the support team runs the business from. It covers accounts and billing, a queue for approving refunds and cancellations, A/B tests and coupons, and an AI assistant that can look up any account through read-only tools. - Grubby Desk, a support inbox inside the admin that replaced Gmail and Zendesk. It syncs with Gmail both ways, drafts replies with AI and shows each customer's plan and usage next to their ticket. - A Chrome extension that works inside Google Docs, Gmail, ChatGPT, Claude and LinkedIn, among other sites. - An MCP connector, so people can use Grubby from Claude, ChatGPT and Cursor. It signs people in with OAuth through Supabase, and when a rewrite runs long it returns a job ID that the assistant checks back on. - An iOS app in Expo, live on the App Store, that signs in with the same accounts and runs on the same backend as the web app. - English, Spanish and Italian versions of the site. Figure: The editor. The bar along the top counts this input against the plan's per-input limit and the words left this month. (Screenshot: Grubby's editor: an empty input pane with buttons to paste text or upload a file, the output pane on the right, and a bar counting the input and the plan's remaining words) ## How it's built The app runs on Vercel, with Supabase for sign-in, Postgres, Realtime and file storage. A few decisions have held up as usage grew. Rewrites run as background jobs. A request records the job and returns straight away, a worker does the rewrite, and the page picks up the result through Supabase Realtime, so a slow model never ties up a request. If a job times out, its words go back to the user's balance automatically. Word quotas are enforced in the database. Each rewrite reserves words against a locked row before it starts, then commits or refunds them, and the server counts the words itself rather than trusting a number from the browser. The model layer can fail over. When the main model servers start returning errors, a circuit breaker whose state lives in Upstash Redis takes them out of rotation on every server instance at once, and requests fall back to Azure OpenAI. Paid plans attract abuse, so the endpoints that cost money sit behind Vercel BotID and rate limits, and the admin flags groups of accounts that share cards, IP addresses or emails. The extension and the MCP connector each have a thin API of their own, but behind it they run the same rewrite pipeline, quota checks and rate limits as the web app, so a change to how rewriting works reaches every surface at once. Along the way I've taken the app through two major Next.js upgrades, to 15 in November 2024 and to 16 in December 2025. ## Results Grubby has grown to more than 1.6 million users and 130K monthly active users, with $3M in revenue since launch, $988K of it in the first year (figures reported by the client). I'm still its lead developer. --- # One Divine Source: Taking over a two-sided marketplace and keeping it shipping Source: https://bluenebula.dev/work/one-divine-source Client: One Divine Source (Online marketplace). Role: Lead developer. Period: 2025-11 to present. Stack: Next.js, MongoDB, NextAuth, Stripe Connect, PayPal, Pusher, Redis, OpenAI, Builder.io. > In November 2025 I took over One Divine Source, a spiritual-guidance marketplace, from a previous agency, and have shipped new features every month since. ## The brief One Divine Source connects people with spiritual advisors for live readings, paid for with credits. When I took it over from the agency that built it, the platform was live and earning, so the job was to learn a large codebase quickly and keep shipping without breaking what already worked. Every change since then has been mine, close to 300 commits so far. ## What I built - Card payments through Stripe next to the PayPal checkout that was already there, and payouts to advisors through Stripe Connect. - Intro offers with A/B tests, promo codes, tips, and a loyalty discount that grows with every 200 credits a customer buys, up to 25% off. - A rebuilt live chat, with a session timer kept in Redis, offline messages, image sharing, moderation, missed-call handling and a filter that stops people swapping contact details to take sessions off the platform. - The advisor side: applications with feedback when one is turned down, an agreement and onboarding flow, contracts, identity verification and public profiles. - Bookings, a reviews page, a community forum, and a blog where edits to published posts wait for approval. - An admin area that has grown from 8 pages to 27, with analytics dashboards, plus Builder.io so the team can build and edit pages without a developer. - An upgrade from Next.js 14 to 16 and React 18 to 19, with Sentry for error tracking. ## A free tarot reading In spring 2026 I added a free tarot reading as a new way into the site. Anyone can use it without an account: ask a question, choose a spread and a deck, then pick cards from all 78, fanned across the screen. The cards turn over one at a time, and each gets its own written interpretation. Figure: The reading from start to finish: choose a reading, pick the cards, watch them turn over, then read what each one means in its position. - Screenshot: The free tarot reading's start page, offering a one-card yes-or-no reading or a full past, present and future spread - Screenshot: Choosing cards from a fanned deck, with a five-card spread diagram showing which positions are filled - Screenshot: The chosen cards turning face up one at a time, The Tower shown reversed - Screenshot: The finished reading: five cards in a row, then a written interpretation for each card's position The interpretations come from OpenAI and stream onto the page as they're written, one stream per card plus one for the reading as a whole, all running at once. Each prompt carries the question, the card and whether it came up reversed, its place in the spread, Waite's traditional meaning and the other cards drawn, so a question about love gets an answer about love. The voice follows sample readings from the site's lead reader. The reading is a Builder.io component, so the team can change the page around it without me. When a reading ends, a button leads to the advisors who read tarot, with whoever is online listed first. Signed-in users can also keep asking questions in a chat with an AI reader: the first reply is free, later replies cost a credit, and the credit is only taken when the reply actually answers the question and comes through in full. On phones the fanned deck turns into a grid of cards to tap. The cards work from a keyboard, and the animations respect the reduced-motion setting. Figure: The homepage section that sends visitors to the free reading. (Screenshot: The free tarot section of the One Divine Source homepage: a gold-and-white serif headline about a free online tarot reading, buttons for a free reading or browsing advisors, and two glowing card backs) ## Where it stands The marketplace is live and I'm still its lead developer, shipping new features every month. Since I took over, the app has grown from 24 pages and 77 API routes to 84 pages and 240 routes. --- # Cypress Clothiers: A headless Shopify store for a multi-brand menswear shop Source: https://bluenebula.dev/work/cypress-clothiers Client: Cypress Clothiers (Menswear). Role: Lead developer. Period: 2024-05 to present. Stack: Next.js, TypeScript, Tailwind CSS, Shopify Storefront API, Supabase, Calendly. > A custom Next.js storefront on Shopify for a Dallas shop that carries designer menswear labels, with filters by designer and private appointment booking. ## The brief Cypress Clothiers is a menswear shop in Dallas's West Village. It carries designer labels such as Another Aspect, Carter Young, ssstein and Yoko Sakamoto, and sells online as well as from the shop, where customers can book a private appointment. The site had to feel as considered as the clothes, which a standard theme couldn't manage, so the front end is custom and Shopify runs the catalog, stock and payments behind it. I built the first version in 2024 and have worked on the store ever since. In June 2026 I shipped a full redesign of the storefront, and in September I added booking for private appointments. ## What I built - A Next.js storefront that reads products from Shopify's Storefront API. Each Shopify collection becomes a category tab, so a category the team adds in Shopify shows up in the shop with no code change. - Filters for designer, size and price, plus sorting, all run on the server as Storefront API searches. Every designer gets a page of their own, and the product grid switches between two and four columns. - Product pages with a full-screen gallery, size selection, a wishlist button and an "About the brand" panel for each label. - A cart and a checkout step that take the shipping address and fetch live shipping rates from Shopify, then hand off to Shopify's checkout for payment. - Customer accounts with sign-up by email code, a saved wishlist and order history. Orders come over from Shopify by webhook. - Booking for private appointments through an embedded Calendly calendar, styled to match the site in light and dark mode. - Automatic discounts shown as struck-through prices, and a maintenance mode that takes the store offline with one setting and tells search engines to check back later. Figure: The shop, with category tabs, sorting, filters and the grid toggle, and a product page with sizes, the wishlist button and the label's story. - Screenshot: The Cypress shop page: 185 products under category tabs from New Arrivals to FW26, with sort, filter and grid controls, and four Another Aspect pieces on hangers - Screenshot: A Cypress product page for the Another Aspect zip hoodie: a photo gallery on the left, and size buttons, add to cart, a wishlist heart and accordions for the description, the brand and shipping on the right ## How it's built Shopify is the source of truth. Shop and product pages ask it for fresh data on every request, so a change in the Shopify admin shows up on the site straight away, and signed Shopify webhooks keep the sitemap current. Supabase holds the accounts, wishlists and copied orders. Two Shopify details needed care. A cart is priced in the market it was created in, so every cart request pins the US market; without that, a shopper could see one price on a product page and a higher one in the cart. Shopify also sends shipping rates back as a deferred, multipart response, which the checkout step parses before it shows a total. For search, every product is in the sitemap, product pages carry structured data with shipping and return details, and filtered views point search engines back to the unfiltered page. ## Results The store has run on this setup since 2024 and brings in about $5K a month (reported by the client). When the West Village shop opened in 2025, D Magazine put it on its list of [the biggest Dallas store openings of the year](https://www.dmagazine.com/style-beauty-wellness/2025/12/best-new-dallas-stores/). I still work on the store, adding features as the shop grows. --- # Social Snitch: Turning an AI-built prototype into a production subscription app Source: https://bluenebula.dev/work/social-snitch Client: Social Snitch (Consumer SaaS). Role: Lead developer. Period: 2026-07 to present. Stack: Next.js, TypeScript, Tailwind CSS, Supabase, Stripe, OpenAI, Brevo, Docker. > Social Snitch began as a prototype built with Replit's AI agent. I rebuilt it on Next.js and Supabase as a live subscription app with Stripe billing. ## The brief Social Snitch tracks the public activity of Instagram accounts, such as new follows and liked posts, and sends subscribers a weekly report. It began as a prototype built on Replit with Replit's AI agent. My job was to turn it into a production app: real accounts, paid plans, data that syncs on a schedule, and code the client's team could keep working in. ## What I built - A new Next.js app on Supabase, with sign-in by email code, Google or Apple, and row-level security so each customer can only read their own data. - Weekly subscriptions through Stripe's hosted checkout, with promotion codes and a pricing page. - A background worker on its own server for the daily syncs and for jobs the admins start. It deploys automatically from GitHub, reports its health and emails the admins when a job needs attention. - An admin page that totals the app's API costs for the day, the week and the month. ## How it's built The web app runs on Vercel and reads Postgres through Supabase, where row-level security decides what each signed-in user can see. Anything slow or scheduled runs on the worker, so long jobs don't hold up the web app. Stripe is the source of truth for billing: its webhooks update an account when a subscription starts, renews, fails to charge or is cancelled. OpenAI models power the AI analysis features. ## Where it stands Social Snitch is live, and I'm still its lead developer. The client's team ships its own changes to the same codebase alongside mine. --- # Allgenda: Designing and building my own product for trans and queer people Source: https://bluenebula.dev/work/allgenda Client: Allgenda (LGBTQ+ consumer app). Role: Founder and sole developer. Period: 2026-04 to present. Stack: Next.js, TypeScript, Supabase, PostGIS, Stripe, OpenAI Realtime, Gemini, MapLibre, Python, Modal. > Allgenda is my own product for trans and queer people. I designed and built all of it, including a live AI voice coach and a map of more than 55,000 places. ## The idea Allgenda is a set of tools for the everyday parts of being queer, built with trans and gender-expansive people at the center. It's my own product, and I've been building it since April 2026. Three products are live. Voice Lab is for practicing your voice, Inclusive Spaces is a map for finding a restroom you can use, and the FFS Results Lab previews what facial feminization surgery (FFS) might do before someone books it. Two more are built and in invite-only pilots: The Agenda, a cited news brief with two-minute civic actions, and Commons, a moderated forum. Allgenda publishes the rules it runs by, and they set most of the engineering requirements. Every fact on the site shows where it came from and when it was checked. There are no ads or ad trackers, and nothing about a user is sold. Browsing is free, and credits pay only for the tools that cost money to run. Five percent of every charge goes to a nonprofit the buyer picks. ## Voice Lab Voice Lab helps people train toward the voice they want, whether that's more feminine, more masculine or androgynous. The free pitch meter needs no account, runs entirely in the browser and records nothing. A free account opens the full Voice Lab: solo practice, voice checks, a practice journal, lessons in five levels, 17 role-play scenarios and a live AI coach. Figure: A coached session. The trace is the speaker's pitch, measured in the browser, over the target band they set. Resonance runs along the bottom, and the panel on the right tracks the lesson plan and what's left before the next level. (Screenshot: A coached Voice Lab session at level 4: a live pitch trace over a shaded 165–255 Hz target band, a resonance meter along the bottom, and the lesson plan with its exercises and progress toward the next level on the right) In a coached session the browser holds a WebRTC call with OpenAI's realtime voice model, and it never sees an OpenAI key. My server mints a short-lived secret, seals it in an encrypted ticket tied to that user and session, and passes the call offer to OpenAI itself, which also lets it hang up the call later. The audio goes straight between the browser and OpenAI and never passes through my servers. Pitch and resonance are measured in the browser as the person speaks. The coach has 25 tools: it can read those numbers, pick the next exercise, play a reference tone or a demo clip, log how many reps landed and offer a move to the next level. It doesn't get the last word on progress, though. The server checks every reported set against the reps the meter counted and decides whether someone is ready to move up, and a level change still waits for the user to say yes. Coaching costs one credit per 30 seconds, and solo practice is free. Billing never takes the browser's word for anything. Charges run from the moment the server saw the call connect, the page checks in every 30 seconds, and a scheduled job hangs up and bills any session that goes quiet, hits its time limit or outruns its credits. People can drop the coach mid-session and keep practicing on their own, which closes the coached stretch and bills it by itself, so free practice is never charged. Saved recordings are analyzed by a Python service I run on a DigitalOcean server, which uses Praat to measure formants and voice quality. Recordings are private to their owner and delete themselves after 90 days. A note about hormone therapy is optional, and it never goes into logs or analytics. To change the coach without breaking it, I built an evaluation harness. It runs the real model in text mode, with the real instructions and tools, on a simulated clock, and grades each run with fixed checks plus a model acting as judge. Changes tested this way cut the median wait between finishing a set and hearing the coach's summary from 3.4–5.2 seconds to about 1.7. ## FFS Results Lab Facial feminization surgery is expensive, and clinic galleries show their best results from the best angle. The FFS Results Lab shows a range instead. Someone adds a photo of themselves, picks the procedures they're considering and sees conservative, typical and pronounced versions of the result, each measured against real before-and-after photos that people shared with consent. Figure: The FFS Results Lab. Each bar shows how far real results moved one measurement: the middle 80%, the middle half and the median, from 177 front-facing pairs. (Screenshot: The FFS Results Lab overview: a serif headline about what facial feminization surgery has actually done for people, and a chart of five facial measurements, each with bars for the middle 80%, the middle half and the median change in real results) Google's Gemini makes each edit, with OpenAI's image model as a backup. The three versions are chained, so each pass edits the one before it. After every pass, my own code on Modal lines the result up with the original photo using face landmarks and keeps the change inside the areas the user picked, so a jaw-only plan leaves the nose alone. Then it measures twelve facial proportions. Once an area has moved as far as real results go, later passes leave it where it is. A face is about as personal as data gets, so the privacy rules here are strict. The preview photo is used for that one render and never written to storage or a database. Someone can take the photo on their phone instead by scanning a QR code: the phone encrypts it with a key my server never sees, and the relay holding the encrypted copy deletes it on pickup or after five minutes. Contributed photos lose their location and device data without being re-encoded, and a person reviews each one before it's used. Withdrawing deletes them. Clinic galleries are only fetched with a written agreement on file, and a database constraint enforces it. ## Inclusive Spaces Figure: The map in San Francisco, with a listing open. Each pin is marked by how the place was checked, and anything not on record says so. (Screenshot: The Inclusive Spaces map of San Francisco covered in green pins, with the listing for the San Francisco Public Library's main branch open: verified, all-gender, ADA accessible, and fields with no data marked Not recorded) The map lists more than 55,000 inclusive restrooms and trans-friendly venues. It started from Refuge Restrooms, a public database of safe restrooms, which I brought in with an importer that resumes where it stopped and catches duplicates by distance and name. Every listing keeps a record of where its data came from, and its page shows who checked it, how and when, as one of four marks: verified, community-reported, low confidence or not checked yet. As the map moves, it asks for the places in view. A PostGIS query returns the 500 nearest the center, and a request that a newer pan replaces is cancelled. Anyone with an account can add a place by answering four questions, and owners can claim a venue and reply to reviews. Every review, reply and photo gets an automated safety check from OpenAI's moderation model, and Anthropic's Claude takes a second look at photos and anything the first check wasn't sure about. City, state and amenity pages built from the same data give search engines a way in. ## Paying for it Allgenda sells credit packs from $5 and a membership at $12 a month, through a Stripe checkout embedded in the site. Credits are granted from Stripe's webhooks, and each grant is tied to the Stripe event behind it, so a retried webhook can't add credits twice. When a payment clears, the webhook sets aside 5% for the nonprofit the buyer picked. A refund takes the credits back and leaves that 5% alone, so it comes out of Allgenda's share. Figure: Before a session, the coach costs credits and solo practice is free. The pricing page opens with the 5% that goes to nonprofits. - Screenshot: The Voice Lab session lobby for Intonation Patterns, level 4 of 5, with a pink Start with coach button, a free Practice solo option, and the mic, goal and credit balance listed below - Screenshot: The top of the Allgenda pricing page in dark mode: a large pink 5% beside the line that it goes back to the movement, the seven nonprofits buyers can pick, and credit packs from $5 or a $12 monthly membership ## How it's built Allgenda is a Next.js 16 app on Vercel with Supabase behind it. Each product keeps its data in its own Postgres schema, with row-level security deciding who can read what. Work that doesn't fit in a serverless function runs elsewhere: voice analysis and FFS dataset processing run in Python on a DigitalOcean server that GitHub Actions deploys to, and the preview geometry runs on Modal. Public forms are checked with Vercel BotID, and requests are rate-limited through Upstash Redis. Sensitive events go to an audit log, and server logs strip emails, phone numbers and tokens before anything is written. Analytics stay off until a visitor allows them. Voice Lab and the FFS Results Lab each launched behind a feature flag and opened to invited testers before everyone else. Six months in, the codebase is about 170,000 lines of TypeScript and 118 database migrations. ## Where it stands Allgenda is live at allgenda.app. Voice Lab and the FFS Results Lab opened to everyone with an account in September 2026. The Agenda and Commons are next. --- # Coop De Lavender: A calmer, mobile-first store that grew sales 180% Source: https://bluenebula.dev/work/coop-de-lavender Client: Coop De Lavender (Handmade goods). Role: Redesign and development. Period: 2023-11 to present. Stack: Shopify, Liquid, AI chatbot. > A Shopify redesign for a handmade lavender brand, focused on mobile shopping and a simpler checkout, plus an AI chatbot for customer questions. ## The brief Coop De Lavender makes handmade lavender products, and most of its visitors shop on their phones. The old store made that hard: conversions were low and the mobile experience got in the way of buying. ## What I built - A redesign of the Shopify store with a calm, natural look that matches the products. - A mobile-first shopping flow, with clearer product pages and a shorter path to checkout. - An AI chatbot that answers common customer questions on the site. ## Results In the four months after the redesign, sales grew 180% and average order value rose 35% (figures reported by the client). --- # Vibe coding cleanup: what it involves and when you need it Source: https://bluenebula.dev/blog/vibe-coding-cleanup By Luna R., Blue Nebula. Published 2026-11-14, updated 2026-11-14. > What a vibe coding cleanup covers for an app built with Lovable, Bolt, Replit or Cursor, the signs you need one, and what to ask the developer you hire. A vibe coding cleanup turns an app built mostly by prompting an AI tool into one you can safely put customers on and keep changing. It means moving the code somewhere you control, auditing it, fixing security and data access first, then payments and stability, and leaving notes the next developer can follow. Andrej Karpathy named the practice in February 2025, describing a way of coding where you "fully give in to the vibes" [1]. It's a fast way to get from an idea to a working demo. I do the cleanup half of it as [app rescue](https://bluenebula.dev/services/app-rescue), and [Social Snitch](https://bluenebula.dev/work/social-snitch), a prototype first built with Replit's AI agent that I rebuilt as a live subscription app, is the clearest example on this site. ## Why AI-built apps need cleaning up The tools are good at the parts a demo shows and weaker at the parts it doesn't, like a second user, a failed payment or a slow job. Developers who use these tools every day are wary of the output. In Stack Overflow's 2025 survey, more developers said they distrust the accuracy of AI tools (46%) than trust it (33%), and the most common frustration, named by 66%, was "AI solutions that are almost right, but not quite" [2]. The code also tends to grow by repetition. GitClear's analysis of 211 million changed lines from 2020 to 2024 found that copied-and-pasted code overtook moved code for the first time, rising from 8.3% to 12.3% of changed lines, while lines associated with refactoring fell from 25% in 2021 to under 10% in 2024 [3]. Those are the years AI assistants spread, though that's a correlation and GitClear doesn't claim AI wrote each copy. Sometimes the problem is the agent itself. In July 2025, Replit's agent deleted a live production database belonging to Jason Lemkin, the founder of SaaStr. Replit's CEO, Amjad Masad, called it "Unacceptable and should never be possible," and Replit began giving apps a separate development database so live customer data stays in production [4]. The security side, with Veracode's numbers and the Lovable row-level security reports, is in my [pre-launch checklist for vibe-coded apps](https://bluenebula.dev/blog/vibe-coded-app-launch-checklist). ## What a cleanup covers This is the order I work in, riskiest first. 1. Get the code into a repository you own. Lovable keeps a project's code inside its platform until you connect GitHub, which then syncs both ways [5]. v0 works similarly: once a GitHub repository is connected, it becomes the source of truth for the project's code [6]. Put the accounts the app depends on, such as hosting, database, Stripe and email, in your name too. 2. Audit before changing anything. I read the code and write up how it's organized, where the data and security risks are, what's slow and how it's deployed, with each problem ranked by risk. 3. Fix security and data access. Database rules come first, since apps built on Supabase depend on them, and I've written up the [Supabase row-level security mistakes](https://bluenebula.dev/blog/supabase-rls-mistakes-ai-built-apps) I find most often. Then secrets that reached the browser, gaps in sign-in and missing backups. 4. Test payments end to end, including webhooks, refunds, failed payments and plan changes. 5. Make releases boring: error monitoring, tests around the paths that bring in money, and preview deploys so a change can be checked before it's live. 6. Leave handover notes that explain how the app fits together, so you aren't tied to me or to the tool that started it. ## Signs you need one - Paying customers are about to use an app that has only been tried in a demo. - Every change you ask the AI tool for breaks something else. - You aren't sure whether one user can see another user's data. - The app only runs inside the tool that built it, and you can't deploy it anywhere else. - A developer you hired says they'd need to start over, and you'd like a second opinion first. ## Clean it up or rebuild it? Many apps can be fixed in place. A rebuild makes sense when the structure itself is the problem, for example when the data model can't support the product you're now selling or every screen talks to the database in its own way. Social Snitch was a rebuild: the prototype proved the idea, and the production app was written on Next.js and Supabase with Stripe billing. Make that call after an audit. My [launch checklist](https://bluenebula.dev/blog/vibe-coded-app-launch-checklist) walks through how I decide. ## What to ask a cleanup developer - Will you audit the code and give me a written list of problems before quoting the fix? - What will you fix first, and why? - Will the repository and every account end up in my name? - How will you test payments and user permissions? - What will I have at the end that lets someone else take over? If you have an app like this, I'm happy to look at it. The first step of [app rescue](https://bluenebula.dev/services/app-rescue) is the written audit. ## Sources [1] Karpathy, A. (2025, February 2). Post on X introducing "vibe coding", as reproduced on the American Dialect Society mailing list. [2] Stack Overflow. (2025). _2025 Developer Survey: AI_. [3] GitClear. (2025). _AI Copilot code quality: 2025 data suggests 4x growth in code clones_. [4] Sharwood, S. (2025, July 22). _Replit makes vibe-y promise to stop its AI agents making vibe coding disasters_. The Register. [5] Lovable Documentation. _GitHub integration_. Retrieved November 14, 2026, from [6] v0 Documentation. _GitHub_. Retrieved November 14, 2026, from --- # What is llms.txt? What it does, and what it doesn't Source: https://bluenebula.dev/blog/what-is-llms-txt By Luna R., Blue Nebula. Published 2026-11-14, updated 2026-11-14. > llms.txt is a Markdown file that tells AI assistants what your site is and where its key pages are. Here's the format, an example, and who actually reads it. llms.txt is a Markdown file at the root of a website, at /llms.txt, that gives AI assistants a short summary of the site and links to its most useful pages. Jeremy Howard proposed it in September 2024 [1]. Google says it doesn't use it, and most files get no AI traffic, so it's a cheap extra rather than a ranking tool. I publish one on this site and on [Allgenda](https://bluenebula.dev/work/allgenda), my own product, and both are generated from the same data as the pages. Here's what goes in the file, the related ideas that grew up around it, and what the evidence says about who reads it. ## What goes in an llms.txt file The proposal defines a fixed order [1]. Only the first part is required: 1. An H1 with the name of the site or project. 2. A blockquote with a short summary that explains the rest of the file. 3. Optional paragraphs with more detail. 4. Sections under H2 headings, each a list of links. Every link can carry a note after a colon. A section called "Optional" is, by convention, for secondary pages that an assistant can skip when it needs a shorter read [1]. For a small business, the whole file can be a dozen lines: ```md # Example Bakery > Example Bakery is a neighborhood bakery in Portland, Oregon, open daily from 7 am, with sourdough, pastries and custom cakes to order. Custom cakes need three days' notice. ## Menu and ordering - [Menu](https://example.com/menu): daily breads, pastries and prices - [Custom cakes](https://example.com/cakes): sizes, flavors and how to order ## Optional - [Our story](https://example.com/about) ``` You can see mine at [bluenebula.dev/llms.txt](https://bluenebula.dev/llms.txt), or make one with my free [llms.txt generator](https://bluenebula.dev/tools/llms-txt-generator). ## Markdown copies and llms-full.txt The proposal also suggests offering a clean Markdown version of each page at the same URL with `.md` added [1]. A model that fetches the Markdown gets the words without the navigation, scripts and layout around them. llms-full.txt is a separate idea. Mintlify, a documentation platform, started generating it in November 2024 as one file holding the full text of a site's docs [2]. It isn't part of the llms.txt proposal [1]. This site now has both: every case study and post has a `.md` copy, and [/llms-full.txt](https://bluenebula.dev/llms-full.txt) holds all of them. ## Does anything actually read it? Mostly no, as far as the evidence goes. Google has been the clearest. In July 2025, Search Engine Land reported that Gary Illyes said Google doesn't support llms.txt and isn't planning to [3]. John Mueller has compared it to the old keywords meta tag, and in May 2026 Search Engine Journal reported that Google's guide to its AI search features lists llms.txt among the things you don't need [4]. I haven't found any statement from OpenAI, Anthropic or Perplexity saying their crawlers use it. The traffic data points the same way. Ahrefs looked at 137,210 domains in June 2026 and found that 28% publish an llms.txt file, and that 97% of those files received no traffic at all in May 2026 [5]. Ahrefs notes its users lean technical, so 28% is likely higher than the web as a whole [5]. There are small signs the other way. One SEO reported in 2025 that his server logs showed OpenAI fetching llms.txt files on a few of his sites [6]. That's one person's logs, and OpenAI hasn't said what it does with them. ## Why I still add one It costs almost nothing when it's built from data the site already has. On this site, a route handler reads the same service list, case studies, posts and FAQ that the pages use, so the file can't fall out of date: ```ts // src/app/llms.txt/route.ts, shortened export const dynamic = "force-static"; export function GET(): Response { const lines = [ "# Blue Nebula", "", "> A one-person web development studio in Daly City, CA...", "", "## Services", ...SERVICES.map((s) => `- [${s.name}](${SITE_URL}${s.href}): ${s.summary}`), ]; return new Response(lines.join("\n"), { headers: { "content-type": "text/plain; charset=utf-8" }, }); } ``` What I wouldn't do is spend time on it before the things AI search demonstrably does use. The first is robots.txt. OpenAI says sites that block its OAI-SearchBot crawler won't be shown in ChatGPT search answers [7], so a rule meant to keep training bots out can take you out of AI search too. My [AI crawler robots.txt builder](https://bluenebula.dev/tools/ai-crawler-robots-txt) keeps the two apart. After that comes HTML that renders on the server, clear answers near the top of each page, and structured data that matches what's on the page, which I covered in [writing for Google's AI Overviews](https://bluenebula.dev/blog/writing-for-googles-ai-overviews-ai-mode). ## How to add one 1. List the pages someone would need to understand your business: services or products, pricing, docs, contact. 2. Write a one- or two-sentence summary that says what you do, for whom and where. 3. Build the file with the [generator](https://bluenebula.dev/tools/llms-txt-generator), or generate it from your CMS or code if your site has one. 4. Upload it so it opens at yoursite.com/llms.txt, and update it when those pages change. If you'd rather have it built into your site, along with the Markdown copies, that's the kind of thing I set up in [web app development](https://bluenebula.dev/services/web-app-development). ## Sources [1] Howard, J. (2024, September 3). _The /llms.txt file_. [2] Chen, T. (2024, November 20). _Simplifying docs for AI with /llms.txt_. Mintlify. [3] Search Engine Land. (2025, July). _Google says normal SEO works for ranking in AI Overviews and llms.txt won't be used_. [4] Southern, M. G. (2026, May 20). _Google's llms.txt guidance depends on which product you ask_. Search Engine Journal. [5] Linehan, L., & Guan, X. (2026, June 15). _llms.txt study_. Ahrefs. [6] Schwartz, B. (2025, July 24). _OpenAI crawling llms.txt files_. Search Engine Roundtable. [7] OpenAI. _Overview of OpenAI crawlers_. Retrieved November 14, 2026, from --- # Is your vibe-coded app ready for real users? Source: https://bluenebula.dev/blog/vibe-coded-app-launch-checklist By Luna R., Blue Nebula. Published 2026-10-12, updated 2026-10-12. > A pre-launch checklist for apps built with Lovable, Bolt or Replit Agent: who can read your data, secret keys, payments, slow jobs, errors and backups. A vibe-coded app is ready for real users when it passes seven checks: each user can only read their own data, no secret keys reach the browser, payments are confirmed by verified webhooks, slow work runs in the background, errors reach you, backups restore, and you own the code and the accounts behind it. I rebuilt [Social Snitch](https://bluenebula.dev/work/social-snitch), an app first made with Replit’s AI agent, as a production subscription app, and I take over apps like it through [app rescue](https://bluenebula.dev/services/app-rescue). This is the list I work through first. ## Why an AI-built app needs a second look By vibe-coded I mean an app built mostly by prompting an AI tool such as Lovable, Bolt, Replit Agent or Cursor. These tools are quick at producing something that works in a demo. The parts a demo never exercises, like a second user or a failed payment, get less attention. The research backs that up. In Veracode’s 2025 test of more than 100 language models on 80 coding tasks, the generated code introduced a security flaw in 45% of cases [1], and its spring 2026 update found security pass rates still stuck at about 55% [2]. The best-known case involved Lovable. In March 2025 a researcher scanned 1,645 apps from Lovable’s public showcase and found 303 endpoints across 170 of them, about 10%, with row-level security settings that let unauthenticated visitors read or write their database tables [3][4]. It was filed as CVE-2025-48757. Lovable disputes it, saying each customer is responsible for protecting their own app’s data [4]. In April 2025 it added a security scan that runs when you publish [5]. The researcher, Matt Palmer, works at Replit, a Lovable competitor [3]. So a working demo is a starting point. Before real customers sign up, check these seven things. ## 1. Each user can only read their own data Most of these tools keep your data in Supabase. Lovable apps run on Lovable Cloud, which is built on Supabase and is on by default, or on a Supabase project you connect yourself [6]. With Supabase, the browser talks to the database directly using a publishable key that anyone can read, so row-level security (RLS) is what decides which rows each request can reach [7]. Check that RLS is on for every table in the public schema, and that each policy ties rows to the signed-in user. The fastest way is the Security Advisor in the Supabase dashboard, which reports a public table without RLS as an error [8]. I wrote a separate guide to [the most common Supabase RLS mistakes](https://bluenebula.dev/blog/supabase-rls-mistakes-ai-built-apps), with the SQL to find and fix each one. If your app doesn’t use Supabase, the question is the same: can a signed-in user change an ID in a request and get someone else’s data? Make two test accounts and try it. ## 2. No secret keys in the browser Anything shipped to the browser can be read by anyone who opens the developer tools. Publishable keys are designed for that [7]. Secret keys aren’t. Supabase’s secret key, the newer name for the service\_role key, bypasses every RLS policy, and Supabase says never to put one in a browser, a shipped app or source control [7]. The same goes for Stripe secret keys and AI provider keys. Search your repository and the JavaScript your site serves for key prefixes such as `sk_live_` (Stripe), `sk-` (OpenAI), `sb_secret_` and `service_role` (Supabase). If one turns up, rotate it before anything else, then move the code that needs it to the server. ## 3. Payments are confirmed by webhooks A checkout page that says thank you doesn’t prove the payment went through. With Stripe, the reliable signal is a webhook: Stripe calls your server when a payment succeeds, a renewal fails or a subscription is cancelled. Check three things in the handler: - It verifies the `Stripe-Signature` header on every event, so nobody can fake a "payment succeeded" call [9]. - It can receive the same event twice. Stripe recommends logging the IDs of events you’ve processed and skipping repeats [9]. - It doesn’t depend on order. Stripe doesn’t guarantee events arrive in the order they happened [9], so read the current state from the event or from Stripe instead of assuming an earlier step already ran. If your server is down, Stripe keeps retrying a failed delivery for up to three days in live mode [9], so a short outage won’t lose payments as long as the handler can catch up. On Social Snitch, Stripe is the source of truth for billing: its webhooks update an account when a subscription starts, renews, fails to charge or is cancelled. ## 4. Slow work runs in the background It’s common for a prototype to do everything inside the web request, such as calling an AI model or pulling data from another service. That holds up with a handful of users. Under real traffic those requests time out, and the app looks broken even when nothing has failed. Move anything that takes more than a few seconds into a background job or a queue, and show the user progress while it runs. On [Grubby AI](https://bluenebula.dev/work/grubby-ai), the long rewriting jobs run in queues so they never block the interface. On Social Snitch, a separate worker server runs the daily data syncs. ## 5. You hear about errors before your users do Add error tracking to both the browser and the server, plus alerts for the jobs that matter most, like a failed payment webhook or a background job that stopped. The Social Snitch worker reports its health and emails the admins when a job needs attention, so a stalled sync gets noticed without anyone checking by hand. ## 6. Backups exist, and you’ve tried restoring one Find out what backups your database plan includes and how far back they go. Then restore one into a test project, once, before you need it. Back up anything that lives outside the database too, such as uploaded files. ## 7. You own the code and the accounts Keep the code in a GitHub repository you control. Lovable, Replit and Bolt can all sync a project to GitHub [10][11][12]. Put the hosting, database, domain, Stripe and email accounts in your company’s name, with your own email as the owner, so you can bring in a developer without asking anyone for access. ## Fix it or rebuild it? If some checks fail, the next question is whether to fix the app where it is or move it to a new codebase. I’ve done both. I kept One Divine Source, a marketplace [I took over from an agency](https://bluenebula.dev/work/one-divine-source), in its existing codebase and have shipped new features every month since. Social Snitch moved to a new Next.js and Supabase codebase. **Diagram: Fixing an AI-built app or rebuilding it** 1. Run the seven checks 2. Do they all pass? - If Yes: Launch (Run the checks again after big changes) 3. If No: Can it be fixed without rewriting most of it? - If No: Rebuild on a clean codebase (Keep the product and the data, and move both) 4. If Yes: Fix it in place (Usually RLS policies, server-side keys, verified webhooks and a job queue) ## Where to start If you only have an hour, do the first two checks: open the Security Advisor and search for secret keys. Those are the two most likely to be leaking customer data right now. > **If you’d rather hand this off** > > I audit AI-built apps and take them to production, starting with these seven > checks. That’s what [app rescue](https://bluenebula.dev/services/app-rescue) covers, and [Social > Snitch](https://bluenebula.dev/work/social-snitch) shows what the result looks like. ## Sources [1] Veracode. (2025, Jul 30). _AI-generated code poses major security risks in nearly half of all development tasks, Veracode research reveals_. Retrieved from [2] Veracode. (2026, Mar 24). _Spring 2026 GenAI code security update_. Retrieved from [3] Palmer, M. (2025, May 29). _Statement on CVE-2025-48757_ and the technical advisory _CVE-2025-48757_. Retrieved from and [4] NIST National Vulnerability Database. (2025, May 30). _CVE-2025-48757_. Retrieved from [5] Lovable. (2025, Apr 25). _Changelog: Lovable 2.0_. Retrieved from [6] Lovable Documentation. _Supabase integration_. Retrieved from [7] Supabase Documentation. _Understanding API keys_. Retrieved from [8] Supabase Documentation. _Database advisors: RLS disabled in public_. Retrieved from [9] Stripe Documentation. _Receive Stripe events in your webhook endpoint_. Retrieved from [10] Lovable Documentation. _GitHub integration_. Retrieved from [11] Replit Documentation. _Git interface_. Retrieved from [12] Bolt Support. _Git integration_. Retrieved from --- # Supabase RLS mistakes in AI-built apps, and how to fix them Source: https://bluenebula.dev/blog/supabase-rls-mistakes-ai-built-apps By Luna R., Blue Nebula. Published 2026-10-12, updated 2026-10-12. > The row-level security mistakes that leave Supabase data open in apps built with Lovable, Bolt or Replit, how to find each one, and the SQL to fix it. The Supabase mistake I look for first in an AI-built app is a table anyone can read, because row-level security is off or a policy allows every row. Your publishable key ships to the browser, so RLS is what stands between a visitor and your data [1]. Open the Security Advisor, fix every error, then test with a second account. When I rebuilt [Social Snitch](https://bluenebula.dev/work/social-snitch), an app first made with Replit’s AI agent, every table got row-level security from the start. These are the mistakes I check for when I take over an app built on Supabase, with the SQL to find and fix each one. ## How RLS protects a Supabase app Supabase serves your database through an API that the browser calls directly, using a publishable key (the older name is the anon key). Supabase calls that key safe to expose: anyone can read it, so it only reaches what row-level security allows [1]. RLS is a Postgres feature. Each policy is a condition on a table, and Postgres applies it to every row a query touches [2]. With RLS on and no policy for an action, the default is to deny, so nothing is returned and nothing changes [3]. That’s why a gap here matters. When a researcher scanned 1,645 apps from Lovable’s public showcase in 2025, 170 of them had inadequate RLS settings on at least one endpoint [4]. ## Mistake 1: RLS is off If RLS isn’t enabled on a table in the public schema, Supabase warns that anyone with your project’s URL can create, read, update and delete its rows. The Security Advisor reports it as an error, `rls_disabled_in_public` [5]. Tables made in the dashboard’s Table Editor get RLS automatically. Tables created with SQL, which is how migrations create them, don’t [6]. Supabase is narrowing the gap: new projects since May 30, 2026 no longer expose new tables to the API automatically, and existing projects switch over on October 30, 2026 [7]. Tables you already have keep their current access [7], and the change doesn’t turn RLS on, so check them. Find the tables without RLS in the SQL editor: ```sql select tablename from pg_tables where schemaname = 'public' and not rowsecurity; ``` Turn it on for each one, then add policies, since a table with RLS on and no policies returns nothing [3]: ```sql alter table public.notes enable row level security; ``` > **Watch for grants that undo the fix** > > Once new tables stop being exposed automatically, a query against one fails > until someone grants access. If an AI tool hits that error, it may add a grant > to make it go away. A grant on a table without RLS opens it up again. ## Mistake 2: a policy that lets everyone in Here RLS is on, so the table passes a quick look, but the policy says `using (true)` and lets every request read every row. Checking that a policy exists isn’t enough. According to the researcher behind the Lovable report, the platform’s first publish-time scan checked only that [4]. Find the policies whose condition is simply `true`: ```sql select tablename, policyname, cmd, roles, qual, with_check from pg_policies where schemaname = 'public' and (qual = 'true' or with_check = 'true'); ``` Replace each one with a policy tied to the signed-in user. Wrapping `auth.uid()` in a `select` lets Postgres call it once per query instead of once per row [2]: ```sql drop policy "Anyone can read notes" on public.notes; create policy "Users read their own notes" on public.notes for select to authenticated using ((select auth.uid()) = user_id); ``` A table that really is public, like published blog posts, can keep a `true` policy for `select`. Make sure that policy covers reading only. ## Mistake 3: writes that don’t check the new row Policies for `insert` and `update` take a `with check` condition, which decides what a new or changed row may look like. It’s what stops a user from saving a row under someone else’s `user_id` [2]. For updates, `using` picks the existing rows a user can change and `with check` validates the result. If you leave `with check` out, Postgres applies the `using` condition to the new row as well [2], but writing both makes the rule obvious to whoever reads it next. ```sql create policy "Users add their own notes" on public.notes for insert to authenticated with check ((select auth.uid()) = user_id); create policy "Users update their own notes" on public.notes for update to authenticated using ((select auth.uid()) = user_id) with check ((select auth.uid()) = user_id); ``` An update also needs a matching `select` policy, or it can’t reach the rows it’s meant to change [2]. The query in mistake 2 lists any `with check (true)` policies too. ## Mistake 4: trusting data the user can edit A signed-in user can update their own `user_metadata` (stored as `raw_user_meta_data`), so Supabase says it isn’t a place for authorization data. `app_metadata` can’t be changed by the user, which makes it the right place for roles [2]. A policy that reads a role from `user_metadata` lets anyone give themselves that role, and the Security Advisor flags it as `rls_references_user_metadata` [8]. ```sql -- Risky: users can edit user_metadata themselves using ((auth.jwt() -> 'user_metadata' ->> 'role') = 'admin') -- Safer: users can't change app_metadata using ((auth.jwt() -> 'app_metadata' ->> 'role') = 'admin') ``` A table of roles that users can read but not write works too. ## Mistake 5: a view that skips RLS Postgres views run with their owner’s permissions by default [9]. In Supabase that owner is usually the `postgres` user, so a view can return rows that RLS hides on the table underneath. Supabase calls this a security definer view, and the Security Advisor reports it as an error, `security_definer_view` [2][10]. On Postgres 15 and later, make the view respect the RLS of its tables [2]: ```sql alter view public.notes_summary set (security_invoker = true); ``` ## Mistake 6: the secret key in front-end code The secret key, the newer name for the service\_role key, bypasses every RLS policy, and Supabase says never to put one in a browser, a shipped app or source control [1]. Search your front-end code for `sb_secret_` and `service_role`. If either turns up, rotate the key and move that code to a server function. Supabase is retiring the legacy anon and service\_role keys by the end of 2026 [1]. Switching to the new keys is a good moment to check where each one is used. ## Check your project in 15 minutes 1. In the Supabase dashboard, open the Security Advisor and fix every error it lists [5]. 2. Run the two queries above in the SQL editor. 3. Call the API with only the publishable key, the way an anonymous visitor would (the request is below). For any table that holds private data, you should get an empty list or an error. 4. Sign in as two test users. Create a few rows as the first, then check that the second can’t see or change them. 5. Run the Security Advisor again after every database change, since a table created with SQL starts without RLS [6]. The request for step 3: ```bash curl "https://YOUR-PROJECT.supabase.co/rest/v1/notes?select=*" \ -H "apikey: YOUR_PUBLISHABLE_KEY" ``` > **If you’d rather hand this off** > > I check Supabase projects like this as the first step of an [app > rescue](https://bluenebula.dev/services/app-rescue). For everything else an AI-built app needs > before launch, see the [launch checklist](https://bluenebula.dev/blog/vibe-coded-app-launch-checklist). ## Sources [1] Supabase Documentation. _Understanding API keys_. Retrieved from [2] Supabase Documentation. _Row Level Security_. Retrieved from [3] PostgreSQL Documentation. _Row security policies_. Retrieved from [4] Palmer, M. (2025, May 29). _Statement on CVE-2025-48757_ and the technical advisory _CVE-2025-48757_. Retrieved from and [5] Supabase Documentation. _Database advisors: RLS disabled in public_. Retrieved from [6] Supabase Documentation. _Tables and data_. Retrieved from [7] Supabase. (2026, Apr 28). _Breaking change: tables not exposed to Data and GraphQL API automatically_ (GitHub discussion #45329). Retrieved from [8] Supabase Documentation. _Database advisors: RLS references user metadata_. Retrieved from [9] PostgreSQL Documentation. _CREATE VIEW_. Retrieved from [10] Supabase Documentation. _Database advisors: security definer view_. Retrieved from --- # AI shopping agents are rewriting e-commerce SEO and funnels Source: https://bluenebula.dev/blog/ai-shopping-agents-ecommerce-seo-funnels By Luna R., Blue Nebula. Published 2025-10-28, updated 2026-10-13. > AI shopping agents and in-chat checkout are changing how people find and buy products. How to get your product data and pages ready for them. AI shopping agents like ChatGPT, Google’s AI Mode, Perplexity and Amazon’s Rufus handle the comparison shopping people used to do across search results and product pages, and some can place the order themselves [2][8]. E-commerce SEO shifts toward product data an agent can quote, and the funnel shrinks to a recommendation and an in-chat checkout. In August 2025 the Financial Times reported that AI shopping agents were set to transform e-commerce, and that brands were already adapting [1]. Getting a store ready for them is mostly a product data project, and that’s where I’d start. ## When traffic stops at the answer AI answers already cut the clicks [news publishers get from search](https://bluenebula.dev/blog/publisher-squeeze-ai-answers-vs-referral-traffic), and shopping is next. If an agent can compare specs, confirm fit, surface reviews, check stock and then place the order, it has no reason to send the shopper back to a results page. The platforms spent 2025 moving that way. Google announced shopping in AI Mode in May [6], and Amazon’s Rufus handles guided discovery inside the Amazon app, so shoppers don’t have to tab out to research [7]. Each of these assistants is becoming a sales channel, and a product that’s missing from the answer, or vague in it, loses at the moment the shopper decides. For a store, that changes what you compete for. On a results page you compete for impressions. Inside an agent you compete to be the product it picks and can buy right now, which means being the safest answer and the easiest purchase. ### What answerability means Answerability is how confidently an agent can pick your product. Your data has to answer the question the shopper actually asked, and the facts have to agree everywhere the agent looks: product page, feed, reviews and schema. Ratings, GTINs, warranties and clear return terms make the pick less risky. Agents prefer products they can defend. ## How each funnel step changes Here’s each step of a purchase in the old funnel and in the agent-led one. | Step | Old SEO-driven funnel | Agent-led funnel | Business implication | | ------------- | ------------------------------------------------------ | ------------------------------------------------------------------------ | --------------------------------------------------------------------- | | Discovery | Ranking in search results and shopping ads | Recommendation inside an assistant (ChatGPT, Google AI Mode, Perplexity) | Data quality, price, availability and trust count as much as keywords | | Consideration | Skimming product pages, tab hopping, comparison tables | Agent synthesizes specs, reviews and brand claims into one answer | Missing or inconsistent fields = lost recommendations | | Decision | “Add to cart” after reading policies and Q\&A | Agent validates fit, price, shipping window and returns in-chat | Return terms, delivery dates and guarantees must be machine-readable | | Purchase | On-site checkout | Checkout from chat, run by the agent (Google, ChatGPT, Perplexity) | Your cart and payments must support delegated, tokenized checkout | Say a shopper asks an agent for the best carry-on for a two-day business trip. One bag’s listing states its internal dimensions and which airlines’ carry-on limits it meets, in structured data. Another bag is described as “perfect for the modern traveler.” The agent can reason with the first listing, so that’s the bag it recommends. ## E-commerce’s share of U.S. retail is growing slowly **Chart: U.S. e-commerce as % of retail (seasonally adjusted)** E-commerce sales as a share of all U.S. retail sales, by quarter. FRED series ECOMPCTSA, as revised in 2026 [4]. | | E-commerce share of retail (%) | | ------- | ------------------------------ | | 2024 Q1 | 15.9 | | 2024 Q2 | 16.1 | | 2024 Q3 | 16.2 | | 2024 Q4 | 16.2 | | 2025 Q1 | 16 | | 2025 Q2 | 16.3 | | 2025 Q3 | 16.4 | | 2025 Q4 | 16.7 | | 2026 Q1 | 17 | | 2026 Q2 | 17.1 | Source: E-commerce reached 17.1% of U.S. retail sales in Q2 2026, up from 15.9% in Q1 2024 [4]. That’s slow, steady growth. The interface people buy through is changing much faster, and once that interface is an agent, growth comes from your product facts and from being able to take the order in the chat. ### Discovery still starts on Amazon and search engines Agents haven’t replaced the older ways people find products. In 2024, 56% of U.S. consumers started product searches on Amazon and 42% on search engines, according to Jungle Scout [9]. In 2025, Morgan Stanley saw Gen Z shoppers tilting back toward Google for some shopping as AI tools improved discovery [10]. You don’t have to pick a side. Structure your data so that whichever interface a shopper uses, your product is the obvious, low-risk answer. ## Product data and schema for agent-led shopping An agent that’s going to choose you needs unambiguous data it can quote. That means thorough Product structured data on the page, and feeds that carry the exact attributes shoppers ask about. Google’s documentation says the more valid properties you provide, the more features your page is eligible for [5], and complete data is also easier for an AI to summarize accurately. Every SKU needs consistent identifiers (GTIN, MPN), normalized dimensions and materials, variant relationships, and current price and inventory in your feeds. Shipping windows and return policies should be machine-readable (JSON-LD where possible) and match what the product page says. If the agent can’t verify a promise, it won’t pick you. Write product copy for the way shoppers actually ask. For a request like “stable, wide-toe box daily trainer under $150 for flat feet,” the agent needs each of those facts stated on your page and in your schema. A name like “lace-up running shoe model 392” gives it nothing to match. It’s the same discipline as [writing for Google’s AI Overviews](https://bluenebula.dev/blog/writing-for-googles-ai-overviews-ai-mode): the specific answer is the one that gets quoted. > **What agents need from a Shopify store** > > I [build Shopify stores](https://bluenebula.dev/services/shopify-development), including a headless > Next.js storefront on the Shopify Storefront API for Cypress Clothiers. For > agents, the part of that work that matters most is the least visible one: > structured product data and a clean catalog. ## In-chat checkout: what to change in product pages and carts “Add to cart” is becoming an API call the agent makes on your customer’s behalf, and that changes what your product pages and cart have to provide. In July 2025 Reuters reported that OpenAI was building a checkout system inside ChatGPT [3], and in October OpenAI and Walmart announced that shoppers could buy Walmart products in ChatGPT directly [2]. Perplexity had already partnered with PayPal in May so buyers could complete purchases inside the chat [8]. If checkout can happen outside your site, your job is to supply certainty: the exact item, price, taxes, shipping options and return terms, in a form the agent can show the shopper and submit without guessing. Two changes help. 1. Make product pages decision-ready. Put the deal breakers near the top in a scannable, structured form: compatibility, fitment, warranty, a delivery estimate for your most common regions and a one-line returns summary. Keep the storytelling, and make the facts easy for people and machines to parse. 2. Make the cart safe for agents. Support a small set of stable calls a buyer’s agent can make reliably: check availability; create a cart from SKU, variant and quantity; get a tax and shipping quote for a ZIP or postcode; apply a promo code, or state clearly that it doesn’t apply; and submit with a tokenized payment and an idempotency key, so a retried request can’t create a second order. The simpler and more predictable that contract is, the fewer agent orders you’ll lose. Put together, the flow from question to order looks like this: **Diagram: From question to order in an agent-led purchase** 1. A shopper asks for the best carry-on for a two-day trip 2. If The agent compares: Structured product data (GTIN, dimensions, materials, rating) 3. If Checks stock and price: Offer details (Price, currency, inventory, shipping window) 4. If Weighs the risk: Policies and trust signals (Returns, warranty, reviews) 5. If Picks a product: Add to cart through an API (An idempotent call, safe to retry) 6. If The shopper confirms: Tokenized payment (PayPal or a stored card) 7. If Order created: Order status and receipt (Sent back to the agent by webhook) ## Where to start on your catalog You don’t need to fix the whole catalog at once. Start with the products that earn most of your margin, roughly the top 20% of SKUs. Check their identifiers (GTIN, EAN or UPC), dimensions, materials, compatibility details such as voltage, and care instructions, and make sure your JSON-LD Product and Offer markup and your feeds carry the same values. Google’s Search Central documentation is the reference for eligibility and validation [5]. Next, close the policy gap, because return and delivery terms often decide which product gets picked. Write the rules once as a single, unambiguous snippet (window, cost, method) and reference it as the canonical policy in your schema where that’s supported. If an agent can quote the policy, it can rely on it. Treat variants as data. A page that leans on design names (“Ocean Mist”) instead of attributes (“color=Teal”) leaves the agent guessing which option is which. Give each variant, and each item in a bundle, its own attributes. Keep prices in sync. If your catalog price conflicts with a marketplace listing or a cached feed, the agent will avoid the risk and recommend a competitor. Align prices and promotions across your feeds, and set short cache lifetimes (TTLs) so stale values expire. Make your reviews machine-readable. Ratings and review summaries are still strong tie-breakers. Use consistent `aggregateRating` markup, make sure the average on the page matches the one in your schema, and where you can, attribute reviews to the recognized platforms they came from. Finally, add a short Q\&A to each product page: who it’s for, when it’s the wrong choice and what it replaces. That candor gives an agent grounds to recommend you to the right shopper. ## Check the markup, then ask the agents - Mark up each product with `Product`, a nested `Offer` (price, currency, availability), and `aggregateRating` and `Review` where they apply. Keep the values current and consistent with your product pages and Merchant Center feeds, since agents and platforms cross-check them [5]. - Validate the markup in Google’s tools and watch Search Console for errors. Broken schema quietly disqualifies you [5]. Then test it. Run three real buyer prompts for each of your top products through ChatGPT, Google’s AI Mode and Perplexity, and through Rufus if you sell on Amazon. If you aren’t the recommended answer, or important facts are missing from it, you have a data problem, and rewriting the copy won’t fix it. ## Why cleaner product data pays off either way I won’t promise a payback period, because I don’t have solid conversion numbers from agent traffic to base one on. The work pays off regardless. Complete, valid Product markup makes your pages eligible for more of Google’s search features today [5], and accurate facts set expectations up front, which should mean fewer refunds. If agents keep taking over comparison shopping, the same data is what gets you picked, and a sale won on facts may cost less than one won with ad bids. Measure that before you budget around it. The risk in waiting is that while your data is thin, the agent recommends a competitor whose data isn’t. If you do one thing this quarter, take the products that earn most of your margin and make every fact a shopper asks about, from size and materials to delivery date and return window, read the same on the product page as it does in your feed and markup. That helps in search today, and it’s the data an agent checks before it recommends anything. ## Sources [1] Financial Times. (2025, Aug 30). _Rise of AI shopping 'agents' set to transform ecommerce_. Retrieved from [2] Associated Press. (2025, Oct 14). _OpenAI partners with Walmart to let users buy products in ChatGPT_. Retrieved from [3] Reuters. (2025, Jul 16). _OpenAI working on payment checkout system within ChatGPT, FT reports_. Retrieved from [4] Federal Reserve Bank of St. Louis (FRED). (2026). _E-Commerce Retail Sales as a Percent of Total Sales (ECOMPCTSA)_. Retrieved from [5] Google Search Central. (n.d.). _Product structured data_. Retrieved from [6] Google. (2025, May 20). _AI Mode in Search_. Retrieved from [7] Amazon. (2024, Sep 18). _How to use Amazon Rufus_. Retrieved from [8] Reuters. (2025, May 14). _Perplexity partners with PayPal to provide in-chat payment checkouts_. Retrieved from [9] Jungle Scout. (2024, Jun 4). _14 Amazon Statistics You Need to Know_. Retrieved from [10] Business Insider. (2025, Jun 13). Gen Z shoppers are loving Google right now. That could be bad news for Amazon. Retrieved from --- # Next.js 16 vs 15: breaking changes and how to fix them Source: https://bluenebula.dev/blog/nextjs-16-vs-15-7-breaking-changes-and-how-to-fix By Luna R., Blue Nebula. Published 2025-10-28, updated 2026-10-12. > The seven Next.js 16 changes most likely to break a Next.js 15 app, with the code to fix each one before you upgrade. In practice, Next.js 16 vs 15 comes down to a short list of changes that can break an existing app: `params`, `cookies()` and the other request APIs are async-only, Turbopack builds by default, `next lint` and runtime config are gone, `next/image` is stricter, and middleware is now called proxy. Codemods handle most of the mechanical work [2]. I lead front-end engineering on [Grubby AI](https://bluenebula.dev/work/grubby-ai), a Next.js app, and this site runs on Next.js 16.3 with React 19. I upgraded it myself, and I’ve noted below where these changes hit it. ## What changed in Next.js 16 Turbopack is now the default bundler for `next dev` and `next build`, which shortens builds and hot updates. Routing and prefetching were rebuilt to transfer less data per navigation. Cache Components, which you turn on yourself, make caching explicit: nothing is cached unless you mark it with `"use cache"`. And middleware has a new name, proxy [1]. ### Next.js 15 vs 16 at a glance Summarized from the release post and the upgrade guide [1][2]. | Area | Next.js 15 | Next.js 16 | | -------------------- | ------------------------------------------------ | -------------------------------------------------------------------------- | | Bundler | Turbopack stable for dev; optional for builds | Turbopack is the default for dev and build; top-level `turbopack` config | | Caching | Implicit App Router caching; PPR experiments | Opt-in Cache Components with `"use cache"`; PPR flags removed | | Routing and prefetch | Standard prefetching | Layout deduplication and incremental prefetching cut transfer size | | React Compiler | Experimental support | Stable support; opt in with `reactCompiler` | | Middleware | `middleware.ts` | `proxy.ts` replaces it and runs on Node.js; config flags renamed | | Linting | `next lint` available | `next lint` removed; use the ESLint CLI or Biome | | Images | Any `quality` value; 60-second minimum cache TTL | Stricter defaults and security checks; `priority` deprecated for `preload` | ## What’s faster in Next.js 16 According to the release post, Turbopack gives 2–5× faster production builds and up to 10× faster Fast Refresh [1]. Navigation is leaner too: a layout shared by several links is prefetched once, and Next.js only prefetches what isn’t already cached [1]. Expect more prefetch requests in the network tab, with a much smaller total transfer [2]. Cache Components are off by default and replace the old PPR flags. Turn them on with `cacheComponents: true` in `next.config.ts`, then mark what to cache with `"use cache"` [1]. At the top of a file, it caches every export: ```tsx // app/page.tsx "use cache"; export default async function Page() { // Any async data here is cached by key the compiler derives. // You can still tag or invalidate as needed. return
Welcome to Next.js 16
; } ``` If you tried [Partial Prerendering on a Next.js 15 canary](https://bluenebula.dev/blog/nextjs-15-partial-prerendering-ppr), note that `experimental.ppr` and the route-level `experimental_ppr` export are gone. PPR now comes through Cache Components and works differently, so the upgrade guide says to stay on your 15 canary until you’ve migrated [2]. ## Seven changes to fix before you upgrade These are the changes most likely to break a Next.js 15 app. The proxy rename (number 2) is formally a deprecation, since `middleware.ts` still runs in 16; it’s here because the upgrade codemod can apply it, and proxy doesn’t support the Edge runtime. ### 1) Request APIs and route params are async-only Next.js 15 made `cookies`, `headers`, `draftMode`, `params` and `searchParams` async but still allowed synchronous access, with warnings [3]. Next.js 16 removes that fallback, so every one of them has to be awaited, including `params` in pages, layouts, route handlers and `default.js` files [2]. The image functions in `opengraph-image`, `twitter-image`, `icon` and `apple-icon` now get `params` and `id` as Promises too, as does `sitemap` for the `id` from `generateSitemaps`. `generateImageMetadata` still gets plain `params` [2]. Update the signatures and await the values: ```tsx // Before (15 - sync access tolerated) export default function Page({ params, searchParams }) { const slug = params.slug; const q = searchParams.q; return (

{slug}: {q}

); } // After (16 - async access required) // PageProps is a global type generated by next dev, next build or // next typegen (15.5+), so there's nothing to import. export default async function Page(props: PageProps<"/blog/[slug]">) { const { slug } = await props.params; const query = await props.searchParams; return (

{slug}: {query.q}

); } ``` ```js // app/shop/[slug]/opengraph-image.js // generateImageMetadata still receives plain params export async function generateImageMetadata({ params }) { const { slug } = params; return [{ id: "1" }]; } // The image function gets params and id as Promises export default async function Image({ params, id }) { const { slug } = await params; const imageId = await id; // ... } ``` The upgrade codemod skips the async request API migration, so run it separately [2]: ```bash npx @next/codemod@canary upgrade latest # not part of "upgrade"; run it if you still read these APIs synchronously: npx @next/codemod@canary next-async-request-api . # and, if needed for types: npx next typegen ``` ### 2) `middleware.ts` is deprecated and renamed to `proxy.ts` Rename `middleware.ts` to `proxy.ts` and its exported function to `proxy`, and update config flags with “middleware” in the name (`skipMiddlewareUrlNormalize` is now `skipProxyUrlNormalize`). The upgrade codemod handles all of it [2]. Proxy always runs on Node.js, and its runtime can’t be configured. If your middleware needs the Edge runtime, keep `middleware.ts` for now; it still works in 16 but will be removed in a future version [1][2]. ```ts // proxy.ts (Next.js 16) import { NextRequest, NextResponse } from "next/server"; export default function proxy(request: NextRequest) { if (request.nextUrl.pathname === "/") { return NextResponse.redirect(new URL("/home", request.url)); } return NextResponse.next(); } ``` On this site, I removed `middleware.ts` instead of renaming it. If yours only sets headers or static redirects, `headers()` and `redirects()` in `next.config` can do that job. ### 3) Turbopack is the default, and its config moved Turbopack now runs for both `next dev` and `next build`, so the `--turbopack` flag can go, and Turbopack’s options move from `experimental.turbopack` to a top-level `turbopack` key. With a custom `webpack` config, `next build` fails on purpose so the config isn’t silently ignored. You can build with `--webpack` for now, but the recommendation is to migrate [2]. ```json // package.json { "scripts": { "dev": "next dev", "build": "next build", "start": "next start" } } ``` ```ts // next.config.ts import type { NextConfig } from "next"; const nextConfig: NextConfig = { turbopack: { // your options here }, }; export default nextConfig; ``` If the build complains about a webpack config you never wrote, a plugin is probably adding one [2]. Plugins can cause other config failures too. On this site, the installed `@next/mdx` (still a 15.x release) injected a `turbopack.conditions` option that failed Next 16’s config validation, so I removed it and compile MDX on the server with `@mdx-js/mdx` instead. Check that every plugin in `next.config` is on a version released for 16. ### 4) Local images with query strings need a `localPatterns` entry Local images with a query string in `src`, like `/assets/photo?v=1`, are now blocked unless `images.localPatterns` allows them, to prevent enumeration attacks [2]. Give `search` the exact query string, leading `?` included; leaving it out allows any query string, which undoes the protection. ```ts // next.config.ts import type { NextConfig } from "next"; const nextConfig: NextConfig = { images: { localPatterns: [ { pathname: "/assets/**", search: "?v=1", }, ], }, }; export default nextConfig; ``` ### 5) `next/image` has new defaults Several image defaults changed [2]. The easiest to miss: `images.qualities` now defaults to `[75]`, and other `quality` values are coerced to the closest allowed one, so `quality={90}` renders at 75 until you add 90 to the list. `minimumCacheTTL` went from 60 seconds to 4 hours, `imageSizes` lost `16`, images from local IPs are blocked, and the optimizer follows at most 3 redirects [2]. Two APIs are deprecated, too. `priority` gives way to `preload`, a switch I made on this site. And `images.domains`, deprecated since Next.js 14, should move to `images.remotePatterns`, which can also restrict protocol and path [2]: ```ts // next.config.ts const nextConfig = { images: { remotePatterns: [ { protocol: "https", hostname: "images.example.com", pathname: "/cdn/**", }, ], }, }; export default nextConfig; ``` ### 6) `next lint` is removed The `next lint` command is gone, and `next build` no longer lints, so a CI pipeline that relied on the build stops linting without any error [2]. Run ESLint (or Biome) directly: ```json // package.json { "scripts": { "lint": "eslint .", "build": "next build" } } ``` The upgrade codemod handles this, or run `npx @next/codemod@canary next-lint-to-eslint-cli .` on its own [2]. The `eslint` option in `next.config` is gone too, and `@next/eslint-plugin-next` now defaults to ESLint’s flat config [2]. ### 7) `serverRuntimeConfig` and `publicRuntimeConfig` are removed Runtime configuration through `next/config` is gone; use environment variables. To read one at request time, call `connection()` first in a Server Component or Route Handler [2]. Skip the `NEXT_PUBLIC_` prefix for these: `NEXT_PUBLIC_` values are inlined at build time, even in server code, so `connection()` can’t make them dynamic. ```tsx // app/page.tsx import { connection } from "next/server"; export default async function Page() { await connection(); // ensure runtime read // No NEXT_PUBLIC_ prefix: those values are inlined at build time. const apiUrl = process.env.API_URL; return

API: {apiUrl}

; } ``` ### Summary of the seven changes | Change | Impact | Your fix | | ---------------------------------- | --------------------------------- | ----------------------------------------------- | | Async-only request APIs and params | Sync access removed | `await` them; run the codemod | | `middleware.ts` → `proxy.ts` | Deprecated; proxy is Node.js only | Rename, or keep middleware for Edge | | Turbopack default and config move | Build fails with a webpack config | Top-level `turbopack`; `--webpack` for now | | Local images with query strings | Images fail to load | Add `images.localPatterns` with `search` | | `next/image` defaults | Other `quality` values become 75 | Set `images.qualities`; use `preload` | | `next lint` removed | CI stops linting | Run ESLint or Biome directly | | Runtime config removed | `next/config` breaks | Env vars; `connection()` for request-time reads | The upgrade guide lists more than these seven [2]. Two to check: parallel route slots now need a `default.js` file or the build fails, and AMP support is gone. ## Prerequisites and the order I’d upgrade in Next.js 16 needs Node.js 20.9 or later and TypeScript 5.1 or later; Node 18 is no longer supported [2]. If your app depends on custom Webpack loaders, plan time to map them to Turbopack, or build with `--webpack` while you migrate [2]. Then I’d go in this order: 1. Upgrade Node and TypeScript, then run the upgrade codemod. It moves the Turbopack config, switches `next lint` to the ESLint CLI, renames middleware to proxy and drops `unstable_` prefixes [2]. 2. Run the async request API codemod and fix what it flags for review, then check images for query strings, `quality` values, `priority` props and `images.domains`. 3. Test `proxy.ts` with logging on, or keep `middleware.ts` if it needs the Edge runtime. 4. Make sure CI runs ESLint or Biome itself. 5. Replace `next/config` with environment variables, adding `connection()` where a value must be read at request time. > **If you’d rather hand this off** > > I take over existing Next.js apps and bring them up to date, starting with an > audit of what’s there. That’s what [app rescue](https://bluenebula.dev/services/app-rescue) covers. ## Getting the speed gains after you upgrade Turbopack’s filesystem cache keeps compiled output on disk between runs. It was an opt-in beta in 16.0 [1] and is now on by default for `next dev` and `next build` [2]. For builds, it only helps if your CI keeps `.next/cache` between runs. The React Compiler is stable but off by default. It memoizes components for you, cutting unnecessary re-renders, but it runs through Babel, so compiles get slower [1]. Try it on a branch and compare. Routing improvements need no code changes [2]. `cacheLife` and `cacheTag` are now stable, so drop the `unstable_` prefixes [2]. Use `updateTag()` in a Server Action when the person who made a change must see it right away (read-your-writes), and `revalidateTag(tag, "max")` for content that can be briefly stale: visitors get the cached version while fresh data loads in the background [2]. The one-argument `revalidateTag(tag)` is deprecated and now a TypeScript error [2]. ```ts // app/actions.ts (Server Actions) "use server"; import { updateTag, revalidateTag } from "next/cache"; export async function updateUserProfile(userId: string, profile: any) { // write // await db.users.update(userId, profile); // immediate read-your-writes for this user updateTag(`user-${userId}`); } // revalidateTag also has to run inside a Server Action or Route Handler. // Here it keeps long-lived content fresh with stale-while-revalidate: export async function publishPost(postId: string) { // await db.posts.publish(postId); revalidateTag("blog-posts", "max"); } ``` ## Measure before and after you upgrade The measurable payoff is speed: faster builds and Fast Refresh from Turbopack, and lighter navigation between pages [1]. Explicit caching is harder to put a number on, but it makes what’s cached visible in the code. Before you start, record a baseline: time a production build and check how much a typical navigation downloads. Then upgrade on a branch, run the codemods there and compare. Next.js 16 no longer prints per-route `size` and `First Load JS` in the `next build` output, so use Lighthouse or your analytics for page weight on both sides [2]. Most of a 15-to-16 upgrade is mechanical: the codemods and the type checker walk you through the async APIs and the renames. Spend the time that saves on `next.config` and anything that writes to it, since that’s where my own upgrade failed. And if any `` sets a `quality`, add that value to `images.qualities` before you ship. ## Sources [1] Next.js Team. (2025, Oct 21). _Next.js 16_. Retrieved from [2] Next.js Documentation. (2025). _Upgrading: Version 16_. Retrieved from [3] Next.js Team. (2024, Oct 21). _Next.js 15_. Context on Async Request APIs and caching changes. Retrieved from --- # Next.js 15 PPR: when it shines and when it bites Source: https://bluenebula.dev/blog/nextjs-15-partial-prerendering-ppr By Luna R., Blue Nebula. Published 2025-09-06, updated 2026-10-12. > When Partial Prerendering in Next.js 15 pays off and when it gets in the way, with a decision tree for choosing between SSR, ISR and PPR. Next.js 15 partial prerendering (PPR) pays off on pages that are mostly static with one or two dynamic regions: the static shell is served immediately and the dynamic parts stream in behind Suspense boundaries [1][2]. It bites when dynamic content fills most of the screen, or when those boundaries are drawn in the wrong places. In Next.js 15, PPR is experimental and you can adopt it one route at a time, which keeps the risk contained [3][7]. Next.js 16 removed the experimental flag and folded PPR into Cache Components, so if you’re on 16, read the last section before you copy any config from this post. ## What PPR does on a real page Picture a landing page where the hero and testimonials are the same for everyone, but the pricing panel depends on the visitor’s segment or location. You want the shared parts cached and delivered fast everywhere, and you can’t safely cache one pricing panel for every visitor. Partial prerendering ships the prerendered hero and testimonials right away, then streams in the pricing panel as soon as its data is ready. First paint comes sooner, and the static parts aren’t re-rendered on every request, a saving that adds up at scale [1][4]. The mechanism is React’s ``. You wrap each dynamic component in a boundary and give it a `fallback`. Next.js prerenders the static parts along with those fallbacks, at build time or when the page is revalidated, then swaps in the dynamic content when it’s ready [1][2][4]. ## When Next.js 15 PPR shines PPR works best when a page is mostly static and its dynamic regions can arrive a moment later, like a stock-status box on a product page or a banner that changes by location. Visitors see real content right away and the dynamic parts fill in shortly after. Online stores are full of pages like this: on [Cypress Clothiers](https://bluenebula.dev/work/cypress-clothiers), a headless Shopify store I built with a Next.js front end, static product pages and a dynamic cart live side by side. It also helps with a global audience. On a host that supports it, the static shell is cached at the edge, close to visitors, and only the dynamic regions go back to your origin [1][6]. And it suits teams that change pages often. Clearly bounded regions let you change each region’s data strategy on its own, with less of the all-or-nothing coupling that turns small edits into regressions. Keeping stable layout apart from volatile data also makes routes easier to read and safer to refactor. ## When PPR bites Everything depends on where the boundaries go. Poorly placed Suspense boundaries lead to awkward loading states or unexpected client-side rendering. Calling `useSearchParams` without a boundary, for example, opts the entire page into client-side rendering, which can leave it blank until the JavaScript has loaded [5]. Library support is uneven. Some data libraries label Suspense for data fetching as experimental (TanStack Query’s v4 docs do), which can cause edge cases if you rely on them heavily [8]. PPR works without them. If your app depends on one, pin its version and isolate the components that use it, then cover those components with integration tests and error boundaries. Monitoring gets harder too. Parts of the page arrive later, so a single load-time number no longer describes what visitors see. ## SSR, ISR and PPR side by side Each mode fits a different kind of page. | Mode | Best for | Benefits | Trade-offs | | ---- | -------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------- | | SSR | Highly personalized or real-time data on every request | Accurate, request-specific content; simple mental model | Higher infrastructure cost at scale; slower first byte during peaks | | ISR | Content that’s mostly static with controlled staleness windows | CDN-level speed; amortized compute costs | Staleness risk within the revalidate window; cache invalidation considerations [9] | | PPR | Mixed pages: static shell + dynamic sections | Faster perceived load without making the whole page dynamic; incremental adoption in Next.js 15 [1][3] | Requires careful Suspense boundaries and more monitoring; library compatibility varies [2][8] | ISR usually has the fastest first byte, because a fresh page is already cached and goes out without any rendering [9]. PPR is close behind: its prerendered shell is sent immediately and the dynamic parts stream into the same response [7]. SSR has to wait for the page’s data before the first byte. Streaming with `loading.js` or Suspense lets it send a layout sooner [4], but that layout is still rendered on every request. ## Drawing Suspense boundaries A good Suspense boundary wraps one cohesive dynamic unit, with a fallback that holds the layout steady. Think of a `RecommendationsGrid` whose placeholder keeps every card at its final size. Avoid wrapping half of a hero banner or grouping unrelated regions under one boundary, since both make the page jump as content arrives. Hooks that read the URL need the same care. Wrap the smallest component that calls `useSearchParams` in its own boundary, so the rest of the page stays in the static shell and avoids a full client-side rendering bailout [5]. React’s documentation explains how Suspense shows a fallback and then reveals the finished UI once the data has loaded [2]. ## A decision tree for SSR, ISR and PPR The choice mostly comes down to how long the content stays valid and how much of it is specific to each visitor. Use this flow as a starting point, then adjust it for how much staleness you can accept and how quickly your data sources respond. **Diagram: Choosing between SSR, ISR and PPR** 1. A page route 2. Is most of the content stable for minutes or longer? - If No: Use SSR (Speed up the data source and cache what you can upstream) 3. If Yes: Does user-specific content have to appear instantly? - If No: Use ISR (Set the revalidate window to how fresh the page must be) 4. If Yes: Can the dynamic parts sit behind Suspense boundaries? - If No: Use SSR 5. If Yes: Use PPR (A static shell, with the dynamic parts streamed in) Real pages often fit more than one branch. Product pages with shared stock levels might do well with ISR plus on-demand revalidation for best sellers, while signed-in dashboards often suit PPR: the navigation and overview cards render immediately and the data-heavy widgets stream in. As a rule of thumb: - Choose ISR when some staleness is acceptable and the content is the same for everyone. It’s the fastest option and uses the least compute. - Choose SSR when every request needs its own data immediately and you can afford to keep backend latency low. - Choose PPR when you want a fast, cacheable shell with dynamic inserts that don’t hold up first paint. The more of the viewport the stable part covers, the more PPR tends to pay off. ## Rolling PPR out in Next.js 15 I’d start small. In Next.js 15, setting `experimental.ppr` to `'incremental'` lets you opt individual layouts and pages into PPR with a route segment export, so you can try it on a few high-impact routes and get used to drawing boundaries before you convert complex ones [3][7]. ```js // Next.js 15 (canary): next.config.js module.exports = { experimental: { ppr: 'incremental', }, } ``` ```tsx // Next.js 15: app/pricing/page.tsx opts in to PPR export const experimental_ppr = true ``` Put real work into fallbacks. A layout shift or a spinner that looks broken is the quickest way to make a PPR page feel worse than the version it replaced. Use skeletons that keep the final height and make it obvious something is loading. Then measure each stage. Keep tracking first byte and first paint, and add the time each key region finishes loading, because with streaming “done” is a series of moments. Check that caching and fallbacks behave the same across regions and devices. > **Planning a PPR rollout** > > I build Next.js apps for a living: I’ve led front-end engineering on Grubby > AI’s Next.js and TypeScript app since July 2024, and this site runs on > Next.js 16. Rendering decisions like this one are part of my > [web app development](https://bluenebula.dev/services/web-app-development) work. ## What changed in Next.js 16 Next.js 16 removed both `experimental.ppr` and the `experimental_ppr` route segment config. PPR is now part of Cache Components: you turn on the top-level `cacheComponents` option, and PPR becomes the default rendering behavior in the App Router. ```ts // Next.js 16: next.config.ts import type { NextConfig } from 'next' const nextConfig: NextConfig = { cacheComponents: true, } export default nextConfig ``` Switching takes more than renaming a flag. With Cache Components, data fetching is dynamic by default, and caching is opt-in through the `use cache` directive and `cacheLife`, which replace the `dynamic`, `revalidate` and `fetchCache` segment configs. In the decision tree above, the ISR revalidate window becomes a `cacheLife` setting. Uncached data outside a Suspense boundary can also fail the build. The Next.js 16 upgrade guide also says PPR in 16 works differently from the Next.js 15 canaries. It tells anyone using PPR today to stay on their current canary, and points to the Migrating to Cache Components guide for the move. You can still convert one route at a time: a codemod removes the `experimental_ppr` exports, and `export const instant = false` opts a segment out of validation until you get to it. The rest of the upgrade is in [Next.js 16 vs 15: breaking changes and how to fix them](https://bluenebula.dev/blog/nextjs-16-vs-15-7-breaking-changes-and-how-to-fix). The trade-off this post describes is the same in both versions. PPR earns its place when most of the screen can be prerendered and the personal parts can wait a moment behind a Suspense boundary: you get a faster first impression than SSR without forcing those parts into a cache. When dynamic content fills the viewport, SSR is simpler, and when nothing on the page is personal, ISR is hard to beat. ## Sources [1] Next.js Docs. (2025). _Getting Started: Partial Prerendering (App Router)_. Retrieved from [2] React Docs. (2025). _\ – React_. Retrieved from [3] Next.js Docs. (2025). _next.config.js: ppr (incremental adoption)_. Retrieved from [4] Next.js Docs. (2025). _File-system conventions: loading.js (Streaming with Suspense)_. Retrieved from [5] Next.js Docs. (2025). _Missing Suspense boundary with useSearchParams_. Retrieved from [6] Vercel Blog. (2023). Partial prerendering: Building towards a new default rendering model for web applications . Retrieved from [7] Next.js Blog. (2024). _Next.js 15 RC (Incremental adoption of PPR)_. Retrieved from [8] TanStack Query Docs. (2025). _Suspense (Experimental)_. Retrieved from [9] Vercel Docs. (2025). _Incremental Static Regeneration (ISR)_. Retrieved from --- # Publisher squeeze: AI answers vs referral traffic Source: https://bluenebula.dev/blog/publisher-squeeze-ai-answers-vs-referral-traffic By Luna R., Blue Nebula. Published 2025-09-06, updated 2026-10-12. > AI Overviews take clicks away from search results. How publishers can replace that traffic with channels they own, such as newsletters and video. AI Overviews are cutting the clicks publishers get from Google. Pew Research Center found that people clicked a traditional search result on 8% of visits when an AI summary appeared, against 15% when there wasn’t one [1]. Search still sends readers, but fewer of them, so publishers need other channels alongside it, such as email newsletters and video. For years, many publishers have built their budgets around a steady flow of search referrals. The AI Overviews traffic impact measured so far makes that a risky assumption. > **What I recommend** > > Spread your effort across four channels: search, an email list you own, > video on YouTube and Shorts, and AI tools, where the goal is citations and, > when possible, a licensing deal. Together they leave you less exposed to the > next change Google makes to its results page. ## What the click data shows Google began rolling out AI Overviews in May 2024 to hundreds of millions of users, with plans to reach over a billion by the end of the year [3]. Pew’s study, published in July 2025, measured the effect on clicks: with a summary on the page, people clicked a traditional result about half as often [1]. **Chart: How often Google users clicked a traditional result (U.S., March 2025)** Pew Research Center found that users clicked a traditional result on 8% of visits when an AI summary appeared, and on 15% when none did [1] | | Click-through on traditional results (%) | | --------------- | ---------------------------------------- | | With AI summary | 8 | | No AI summary | 15 | Source: Ahrefs found that when an AI Overview appears, the top-ranking page’s click-through rate is about 34.5% lower [4]. Zero-click searches are a parallel trend: in 2024, about 58.5% of U.S. Google searches and 59.7% of EU searches ended without a click [2]. If your revenue depends on free organic sessions, it’s riskier than it used to be. Search still sends traffic, but if it’s your main source, a change to Google’s results page can cut your clicks while nothing on your site changes. Online stores face their own version of this with [AI shopping agents](https://bluenebula.dev/blog/ai-shopping-agents-ecommerce-seo-funnels), which can answer a shopper’s questions before they reach a product page. ## How the four traffic channels compare When you’re deciding where the next dollar goes, look for channels that cover each other’s weak spots. The table compares the four main options. | Channel | Control & relationship | Margins & monetization | Risk & volatility | | -------------------------------------- | ------------------------------------------------------ | -------------------------------------------------- | ----------------------------------------------------- | | Search (classic SEO) | Indirect control via algorithms; intent-rich discovery | Strong when ranking; ad & affiliate revenue scale | High policy risk (AI answers), ranking volatility | | Owned audience (email/newsletters) | Direct relationship; segment & nurture | High margins over time; recurring revenue optional | Slow build; deliverability & churn management | | Platform-native video (YouTube/Shorts) | Algorithmic distribution but strong brand reach | Ads, sponsorships, commerce; evergreen catalog | Platform policy shifts; creative consistency required | | LLM exposure & licensing | Access to high-intent Q\&A surfaces; brand mentions | Licensing revenue; qualified referral when linked | Opaque attribution; evolving contracts & standards | Search stays in the mix, sized to what it delivers today. The other three depend less on how Google lays out its results, and what you build in them keeps adding up over time. ## Where search still pays off Search deserves a share of your effort, aimed at two kinds of queries: those where people click through, and those where they don’t. Links still get clicked when a summary isn’t enough, as on commercial and local queries where people want detail or prices before they decide. Open those pages with a few factual, sourced sentences that answer the question, and use the title and meta description to promise what an overview can’t give, like full pricing or a detailed comparison. If your site also sells something, [SEO for lead generation](https://bluenebula.dev/blog/seo-strategies-for-lead-generation) covers matching pages to buying intent. Many searches end on the results page whatever you do, and for those the thing to win is recognition. Treat each impression as a small ad, with a distinctive name and a consistent look, so people who don’t click today know who you are next time. ## Build an email list you own Email gives you the most control of the four. You own the list, so reaching the people on it doesn’t mean bidding against anyone for attention. Each send also shows you which segments read what. Start with one flagship newsletter carrying your analysis in the publication’s voice. Then add a niche newsletter for a sub-audience with a specific problem, and later a separate stream for offers. For a regional publisher, that might be a daily morning brief plus a weekly newsletter for local builders, a B2B audience that advertisers pay a higher CPM to reach. To grow a small list faster, offer a lead magnet tied to your strongest coverage, and make each sign-up prompt promise something specific. Co-registration with partner newsletters, where people signing up for theirs can opt into yours, adds subscribers quickly. Watch list growth and revenue per thousand subscribers. How quickly opens come in after each send is an early sign of whether readers want the newsletter. ## Turn video viewers into newsletter subscribers Across the markets the Reuters Institute surveys, the share of people consuming social video rose from 52% in 2020 to 65% in 2025, and the share consuming any video from 67% to 75% [5]. That favors publishers who make video the way each platform wants it: quick and clearly branded. YouTube and Shorts are friendlier to publisher IP than most social feeds because they reward a deep catalog, so build recurring formats that play as a series and keep older episodes in circulation. Point every video to the full story on your site or in your newsletter. When a Short takes off, pin a comment linking to your sign-up page, so the extra views turn into readers you can reach again. ## Get cited by AI tools, and paid where you can To get cited, publish pages an AI system can quote accurately: well-sourced explainers and definitions for the topics you cover most, and timelines for the stories you’ve followed longest. What helps a page rank also helps it get cited: clear headings, short paragraphs that state a claim and back it up, authoritative sources and accurate schema markup. Consistent naming across the site helps models attribute the work to you. My post on [writing for AI Overviews and AI Mode](https://bluenebula.dev/blog/writing-for-googles-ai-overviews-ai-mode) covers page structure in more detail. A citation won’t send the traffic a top ranking used to, but it puts your name in front of people researching your topic, and some of them click. Getting paid means licensing. Publishers and AI companies signed a wave of deals in 2024 [6]. Publishers with archives they hold clear rights to, or real authority in a niche, have the most to negotiate with. ## What to measure when fewer people click A dashboard built on search impressions can look healthy while the clicks behind it shrink. I’d change the scorecard in four ways. Start with signals that still register when nobody clicks. Brand searches and direct traffic show whether people remember you, and newsletter sign-ups per thousand search impressions show whether search visibility still turns into readers. Then track how often AI answers cite you. Check a fixed set of queries for your main topics, by hand or with a tracking tool, and note whether you’re cited and whether the citation links to you. The numbers are rough, so watch the trend more than any single check. For video, measure how many viewers go on to subscribe, and link your strongest series to a matching topic page or sign-up offer. Last, compare what a subscriber costs to acquire in each channel with what they earn over time, which depends on revenue per thousand visits (RPM) and how long they stay. Spend more where lifetime value beats acquisition cost. ## A 90-day plan to diversify Weeks 1–2: Pick two topics you can credibly own this year. Publish a canonical explainer for each, structured to be easy to cite, and refresh your ten best evergreen posts with a short box of sourced key claims. Weeks 3–6: Launch or relaunch one flagship newsletter with a promise readers can’t get elsewhere. Write a four-email welcome sequence that builds the habit of opening and points new subscribers to your best evergreen pieces. Add one co-registration partner to grow the list faster. Weeks 5–10: Start two recurring video series, one long-form and one made for Shorts. Script every episode and end each with one call to action pointing to the topic page or newsletter (“Get the full story” works). Treat each comment as a possible subscriber and reply the way a person would. Weeks 8–12: Open a licensing conversation with at least one AI company or publisher consortium. Bring a clear map of what you hold the rights to, plus analytics showing which evergreen topics draw demand other outlets don’t meet. If no paid deal is on offer yet, ask for attribution and links first. ## Search is now one channel among several Search still matters, but it can’t carry a publisher’s growth on its own anymore. AI summaries cut the clicks each search sends [1][4], and most searches already ended without a click in 2024 [2]. I’d use the next 90 days to get a newsletter and a video series running while search still brings readers in, because those readers are the ones you can ask to subscribe. ## Sources [1] Pew Research Center. (2025, July 22). Google users are less likely to click on links when an AI summary appears in the results . Retrieved from [2] Search Engine Land. (2024, July 2). _Nearly 60% of Google searches end without a click in 2024_. Retrieved from [3] Google. (2024, May 14). _Generative AI in Search: Let Google do the searching for you_. Retrieved from [4] Ahrefs. (2025, April 17). _AI Overviews Reduce Clicks by 34.5%_. Retrieved from [5] Reuters Institute for the Study of Journalism. (2025). _Digital News Report 2025 (Executive Summary)_. Retrieved from [6] Digiday. (2024, December 27). 2024 in review: A timeline of the major deals between publishers and AI companies . Retrieved from --- # AI in customer service: what to automate, what to keep human Source: https://bluenebula.dev/blog/ai-in-customer-service By Luna R., Blue Nebula. Published 2025-09-05, updated 2026-10-12. > How support teams use AI to answer routine questions faster and for less, while people still handle the conversations that need a person. AI in customer service pays off first on routine requests with clear policies, such as checking an order’s status or resetting a password. It also cuts the busywork around each ticket, like drafting replies and after-call notes. Keep people on anything that needs judgment or carries real risk, and give them AI tools that make them faster. ## Why support is a good first place for AI Support is one of the largest operating expenses at many companies, and one of the easiest to measure. In Salesforce’s State of Service survey, 95% of service decision makers at organizations using AI report cost and time savings, and 83% plan to increase their AI investment over the next year [1]. Zendesk’s CX Trends 2025 report found that 90% of the companies it calls “CX Trendsetters” see a positive return from AI tools for their agents [2]. **Chart: What service decision makers say about AI** Percent of service decision makers, from Salesforce’s State of Service report (6th edition) [1] | | Salesforce State of Service (2024) | | ------------------------------ | ---------------------------------- | | Report cost & time savings | 95 | | Say gen AI improves service | 92 | | Plan to increase AI investment | 83 | Source: I’d sort the savings into two kinds. The first kind comes from requests that never need a person. An AI front door, in chat or on the phone, resolves simple requests end to end and passes the rest to an agent with the context attached. Each request it resolves well protects your margin without hurting the customer’s experience. The second kind comes from making agents faster on everything else. An agent co-pilot drafts replies and pulls up the right help article while keeping a running summary of the conversation. That takes minutes off each case. Background automation handles the system updates and follow-ups that would otherwise eat into an agent’s day. > **Start with one narrow request type** > > “Password reset” is a better first project than “reinvent support.” Pick one > request type you can measure and prove it lowers a number such as average > handle time or cost per contact. Then move on to the next one. ## How much to read into the surveys The direction is clear enough: leaders expect to increase AI investment over the next three years [3], and most already see a return [1][2]. But adoption is uneven, and definitions differ. “AI agents handle half of all interactions” can mean a scripted phone menu (IVR) at one company and fully autonomous workflows at another. Benchmarks tell you which way things are heading. They’re too loosely defined to set targets for your own team. **Chart: AI investment plans in three surveys** Figures from McKinsey [3], Salesforce [1] and Gartner [6]. Each survey asked a different question, so compare them loosely. | | Leaders' 2025 AI Intentions | | -------------------------------------------------- | --------------------------- | | Increase AI spend (McKinsey, next 3 yrs) | 92 | | Increase AI spend (Salesforce, next year) | 83 | | Explore/pilot conversational GenAI (Gartner, 2025) | 85 | Source: ## A rough business case Say your support team handles 1 million contacts a year, and AI saves two minutes on each one through better triage and faster wrap-up. That’s about 33,000 agent hours. At the median U.S. customer service wage of $20.59 an hour [4], it comes to roughly $686,000 a year in wages, before benefits and overhead. Revenue from better retention, or from add-ons sold during support conversations, comes on top of that. Most of that saving happens on contacts a person still handles, so I’d plan AI as a change to how your whole support operation works, with a chatbot as one part of it. Work on throughput first (how many contacts your agents can close), since that’s what lowers cost per contact. Quality comes next, measured in customer satisfaction (CSAT) and first-contact resolution. Revenue comes last, when support conversations start preventing cancellations and selling add-ons. ## Who, or what, handles each request Here’s the flow I’d start from: **Diagram: Who handles each request** 1. A customer request comes in 2. AI triage (Works out what the customer wants and confirms who they are) 3. Then it splits: - If Simple, within policy: 1. Self-service (Resolved end to end in chat or on the phone) - If Needs judgment: 1. An agent with an AI co-pilot (The AI drafts replies and finds the right article) 2. If Complex or high risk: A specialist (With the authority to resolve it) 4. Learning after every conversation (A summary, plus updates to the help content) Think of it as a ladder: each request climbs only as high as it needs to. Whichever rung it ends on, the conversation finishes with a summary and any updates to your help content, so the next answer is better. The pressure to get this right is growing: contact volumes are rising, and leaders still expect significant efficiency gains from AI over the next few years [5]. ## Guardrails: clean data and human oversight Start with the data. Good answers depend on clean, current policies and product information, including what each customer is entitled to. Early on, put work into how your help content is organized and how well the AI retrieves it, because a co-pilot is only as good as what it can safely cite. If you sell online, the same product data feeds [AI shopping agents](https://bluenebula.dev/blog/ai-shopping-agents-ecommerce-seo-funnels), so the cleanup helps there too. Keep a person in charge of anything ambiguous or high-risk, and of conversations where the customer is upset. Even the operators most bullish on AI acknowledge it needs oversight, especially in sensitive workflows and when verifying a customer’s identity [5]. ## Salesforce’s 4,000 support roles, in context In 2025, Salesforce’s CEO said AI agents had let the company cut its support staff from about 9,000 people to about 5,000, with customer satisfaction scores about the same as before [7]. That’s a striking result from a company with deep data plumbing and its own AI-first platform, which most support teams don’t have. Take it as a sign of what’s possible, and expect smaller first wins: triaging billing questions, say, or summarizing long email threads so agents can get straight to the fix. ## Where to start Pick “boringly valuable” use cases. Password resets, order status, warranty lookups and simple returns have clear policies and plenty of data, so they’re safe to automate and quick to prove. > **The small-store version** > > On a small online store, the same idea can be as simple as an AI chatbot that > answers common customer questions. I built one for [Coop De Lavender’s Shopify > store](https://bluenebula.dev/work/coop-de-lavender) as part of a redesign. Build an agent co-pilot before a fully autonomous agent. Making your own people faster and more accurate carries little political risk and pays back well. Once the co-pilot’s answers are reliably right, point the same capabilities at customers. Don’t skip change management. The technology is the easy part; changing workflows and incentives is harder. Train your agents and consider new roles, such as an “AI supervisor.” Leaders who underinvest here see rollouts stall, even when the models are impressive [3][5]. ## Which numbers to track If the AI is working, it shows up in numbers you already report: - Average handle time (AHT): co-pilot summaries and suggested actions take seconds off each interaction. - First-contact resolution (FCR) and repeat contact rate: better triage and knowledge retrieval make it more likely the issue is fixed the first time. - Cost per contact: automation cuts the number of touches and escalations each issue needs. - CSAT and Net Promoter Score (NPS): less effort and faster answers show up in how customers rate you, sometimes right away. - Revenue influenced by service: count “saves” (customers talked out of canceling) and “attaches” (add-ons sold during a support conversation), so support isn’t seen purely as a cost center. > **Measure each use case against a baseline** > > Set a baseline for each use case, such as its cost per contact, and track the > change month over month. A single blended “AI score” would hide which use > cases are paying back. Keep what improves and cut what doesn’t. ## Protecting customer data and trust Customers want their information kept safe and their problem solved. Protect personal data (PII) and limit what each role can access. Add guardrail prompts that keep the AI within your policies. Make red-teaming a habit: have someone deliberately push the AI toward risky territory, like financial advice or a high-dollar refund, and set a clear escalation path for anything that looks wrong. Label automated conversations clearly and make it easy to reach a person. Log every action the AI takes, so you can audit it later. ## A 90-day rollout plan - Days 1–30: Find the three request types (intents) with the most volume and friction. Choose one channel, chat or voice, and launch a co-pilot for your busiest agent queue. Decide which single metric you’ll judge it by, plus a few supporting ones. - Days 31–60: Finish the security review and run targeted red-team tests. [Connect the AI to the systems it needs](https://bluenebula.dev/services/ai-integration), like order management and billing. Where it’s safe, turn co-pilot suggestions that have proven reliable into automated actions. - Days 61–90: Add a second high-volume request type. Set up an AI steering committee and write a one-page policy for how AI is used in support. Then send leadership a quarterly report that ties the automation to dollars saved and to churn. The test I’d apply to each request type: if the policy is clear and a wrong answer is cheap to fix, it’s a candidate for automation. If not, it belongs with a person, and the AI’s job is to make that person faster. ## Sources [1] Salesforce. (2024). _Inside the Sixth Edition of the State of Service Report_. Retrieved from [2] Zendesk. (2025). _CX Trends 2025: Human-Centric AI Drives ROI_. Retrieved from [3] McKinsey & Company. (2025). _AI in the workplace: A report for 2025_. Retrieved from [4] U.S. Bureau of Labor Statistics. (2025). _Customer Service Representatives: Occupational Outlook Handbook_. Retrieved from [5] McKinsey & Company. (2024). _Where is customer care in 2024?_. Retrieved from [6] Gartner. (2025). _Customer service AI use cases_. Retrieved from [7] San Francisco Chronicle. (2025). _Salesforce CEO says AI replaced 4,000 support jobs_. Retrieved from --- # AI Overviews SEO: how to win citations and traffic Source: https://bluenebula.dev/blog/writing-for-googles-ai-overviews-ai-mode By Luna R., Blue Nebula. Published 2025-09-05, updated 2026-10-12. > How to structure pages so Google's AI Overviews and AI Mode cite them, and how to keep your organic clicks while you do it. AI Overviews SEO comes down to writing pages Google can quote safely. Every section opens with a direct answer, and every claim has a source and a named author behind it. To keep the traffic, the page Google links to has to do more than the summary: answer the follow-up questions and offer a clear next step. AI Overviews work like a quick researcher: Google builds a short answer from top-ranking pages and shows it above the results, with links to the pages it used. AI Mode goes further and turns Search into a conversation built on follow-up questions [3]; in July 2025 Google added it to Circle to Search and Lens for visual searches [9]. If your pages are the ones being quoted, you reach buyers earlier and keep more of the organic traffic a summary would otherwise absorb. ## Why AI Overviews and AI Mode affect revenue When Google rolled out AI Overviews in the U.S. in May 2024, the regular results stayed, but the summary above them changed how people scan the page and decide what to click [1][2]. A year later, Google started rolling out AI Mode to everyone in the U.S. with no Labs sign-up, calling it its most powerful AI search [3]. The queries that trigger these features are changing too. BrightEdge’s tracking shows a shift toward longer, multi-part questions [4][5], the searches people run when they’re setting a budget or choosing a vendor. AI Mode then keeps the conversation going, so your pages need the next answer ready, usually a comparison or an honest list of trade-offs [3]. Say a buyer searches “ai overviews seo framework for multi-brand sites with international ccTLDs.” The overview might quote a definition from one page and link to a strategy guide and a case study, and when the buyer asks AI Mode about migration risk, the click goes to whichever site has a page that answers it. If your pages are easy to quote and clearly sourced, Google has a reason to cite them. If they read like thin listicles, the summary paraphrases them without a link, and that’s where the traffic goes. ## What a year of BrightEdge data shows In BrightEdge’s first-year data, AI Overviews showed up more often on long, complex queries and much less often for ranking-style content and comparison queries. Impressions rose 49% while click-throughs fell nearly 30% [5]. **Chart: Change since AI Overviews launched, May 2024 to May 2025** BrightEdge’s one-year analysis of AI Overviews [5] | | Change since May 2024 (%) | | ------------------------------------- | ------------------------- | | Longer complex queries (AIO presence) | 49 | | Ranking-style content surfaced | -60 | | Comparison queries surfaced | -14 | | Impressions on all content | 49 | | Click-throughs | -30 | Source: Pages that explain how something works and what to do next tend to gain from this, while glossaries and thin top-of-funnel listicles fade. If your business runs on referral traffic, [the publisher squeeze post](https://bluenebula.dev/blog/publisher-squeeze-ai-answers-vs-referral-traffic) covers how to replace those lost clicks with channels you own. BrightEdge also reported that AI Overview presence on longer queries rose by up to 100% between September and December 2024 [4]. That fits how buyers search when they have a specific problem: they type the whole question, conditions included, into one search. ## How to write sections Google will quote Google lifts a passage when it’s a precise answer it can stand behind. Your job is to make that easy, then to make sure the page behind the snippet converts. I cover the conversion side in [SEO for lead generation](https://bluenebula.dev/blog/seo-strategies-for-lead-generation). ### Put the answer in the first sentence AI Overviews summarize first and link second, so make quoting you the easy option. Give each section a descriptive heading and open it with a tight definition or a direct answer, in paragraphs short enough to lift cleanly. Then back it up with a number or a short example. Take a question like “How do we measure ROI from AI content automation?” The page with the best shot at a citation has a section headed “How to measure ROI from AI content automation” that opens with a one-sentence formula and names the tracking you actually used. Bury the answer in paragraph six and Google may still summarize it, just without citing you. ### Make every claim checkable AI Overviews lean toward sources that are specific and recent. Date your benchmarks and say how you got your numbers. When you cite an outside statistic, link to the primary source, such as Google or BrightEdge, and put the citation and its timeframe in the same sentence as the number. When you publish your own data, give the sample size and the time window. A sentence built like “Demo requests rose X% in the 90 days after the team restructured N comparison pages” can be quoted and checked. “Conversions improved” gives a summary nothing to use. ### Build sections that stand on their own AI Overviews and AI Mode often surface a single sub-section, so give them sections worth lifting: a cost model, an implementation sequence, risk trade-offs, decision criteria or ROI assumptions. Each one should open with a one-sentence definition and a short paragraph that makes sense without the rest of the page. Some formats that work: - Decision criteria: define the criterion in one sentence, then spend two or three on how it affects cost, timeline or risk. - ROI assumptions: a compact formula with its inputs and time horizon, plus a note on what the result is most sensitive to. - Implementation sequence: short phases named for their outcome, such as “Pilot with a control group” or “Scale to tier-2 markets.” Keep paragraphs to three or four sentences, and write headings the way people search, like “AI Mode search strategy for seasonal demand” or “AI Overviews SEO for regulated industries.” ### Show who wrote it and how they know Google’s Search Quality Rater Guidelines don’t score your site directly, but the qualities they call E-E-A-T (experience, expertise, authoritativeness and trustworthiness) tend to line up with what gets quoted [8]. In practice that means a credible author, a reputable organization and visible effort behind the content. Google also says AI Overviews are built to show only information backed up by top web results [2], so the evidence on your page carries real weight. E-E-A-T is easier to show than to define. Put a named person with relevant expertise on the byline. Near the top, add a short note on what the advice is based on, such as how many projects and over which years. Use specifics from actual projects and link to a case study with outcomes and lessons learned. Material that took effort to make, like a calculator or annotated screenshots, helps too. ## Make the structured data match the page Google’s documentation says structured data helps its systems understand and present your content, and that the markup has to be accurate and follow Google’s policies to qualify for rich results [6][7]. Use JSON-LD for the main entities on the page, such as Organization, Product or Article, plus Person for the author. Don’t count on FAQPage or HowTo markup for visibility: since 2023, Google shows FAQ rich results only for well-known government and health sites, and it no longer shows HowTo rich results at all [10]. Whatever you mark up, the visible copy, the meta tags and the schema should agree on every price, date, author and claim. If your CMS adds the schema with JavaScript after the page loads, or fills it with values that change per visitor, I’d move it into the server-rendered HTML, so any crawler gets the same markup whether or not it runs JavaScript. On a store, Product data also shapes what AI shopping agents can say about you; the post on [AI shopping agents and e-commerce SEO](https://bluenebula.dev/blog/ai-shopping-agents-ecommerce-seo-funnels) goes into that. ## A workflow for each page you want cited Most of this work happens on pages you already have: you add sections that AI Overviews and AI Mode can lift, then deeper content for the follow-up questions. This is the order I’d work in. **Diagram: Making one page citable** 1. Define the intent (The revenue-critical problem the page solves) 2. Map the queries (Long, specific, multi-part phrasings) 3. Draft sections that can be quoted (The answer in the first sentence) 4. Cite sources and methods (Primary data or reputable benchmarks) 5. Show the experience behind it (A named author, case specifics, worked examples) 6. Measure what happens after the click (Calls to action matched to intent, soft and hard conversions) 7. Does it earn citations? 8. Then it splits: - If Yes: 1. Extend to nearby questions (Comparisons, objections, risks) - If No: 1. Revise the structure (Tighter definitions, clearer proof) ### Example: splitting one guide into liftable sections Say you sell workflow automation software and have one long guide on the subject. You could rebuild it around five sections that each stand alone: cost model, implementation timeline, security considerations, ROI validation and a 90-day pilot plan. An AI Overview can then quote the security section by itself, and a buyer who asks AI Mode “What risks should we plan for with role-based access?” has a better chance of landing there. Generic “best tools” pages are losing ground in AI Overviews at the same time [5], so compete section by section: each one should be the best available answer to its own question. ## Treat every statistic like a dependency A wrong number costs more once an AI summary repeats it. Treat each statistic on your site the way you’d treat a package in your codebase: know where it came from and when someone last checked it. If you can’t defend a figure, delete it or label it as an illustration. Where it helps, publish a short note on how you got your own numbers, so the page is safe to quote. Retire pages that exist only to rank for a broad head term. If an article can’t be summarized in a way that helps a buyer decide something, merge it into a stronger page or take it down. ## A 90-day rollout plan Weeks 1–2: pick the 10–15 pages closest to revenue and check how easy each one is to quote. Note the sections and author signals they’re missing. List 20–30 long, specific queries that match real buying questions in your category [4][5]. Weeks 3–6: rewrite those sections so each one opens with its answer and defines its terms in a sentence a reader could copy. Answer the obvious follow-up questions nearby. Make the schema match the visible content and render it on the server [6]. Add bylines and a short note on what the advice is based on. Weeks 7–10: publish and monitor. Track your AI Overview citations, including where they appear and whether they link to you, and check whether your pages come up in AI Mode follow-ups. Judge the work by demo requests and assisted pipeline; sales cycle length is worth watching too. Weeks 11–12: extend the work to the next questions buyers ask, such as comparisons and implementation risks. Merge or retire thin posts. ## What a citable page looks like - Each section opens with a one-sentence answer that stands on its own. - Claims are dated and sourced in the sentence that makes them. - The schema says the same thing as the visible copy. - The byline belongs to someone with relevant expertise, and specifics from their own work show it. - Calls to action offer a sensible next step, such as a pricing calculator or a pilot template. - The page converts after the click, because it was built as the next step in a conversation the AI already started. Search is turning into a guided conversation. The pages that get cited answer first and back up what they say; the ones that keep their traffic also know what the reader will ask next. You’ll likely get fewer clicks than before [5]. Google says the clicks that come through AI Overviews are higher quality [2], and whether that’s true for you depends on what your page does once someone lands on it. ## Sources [1] Google. (2024, May 14). _Generative AI in Search: Let Google do the searching for you._ Retrieved from [2] Google. (2024, May 30). _AI Overviews: About last week._ Retrieved from [3] Google. (2025, May 20). _AI in Search: Going beyond information to intelligence._ Retrieved from [4] BrightEdge. (2025, Jan 30). _Google triggers 100% more AI Overviews for longer queries._ Retrieved from [5] BrightEdge. (2025, May 14). One year into Google AI Overviews: Data reveals how usage is changing. Retrieved from [6] Google Developers. _General Structured Data Guidelines._ Retrieved from [7] Google Developers. _Intro to How Structured Data Markup Works._ Retrieved from [8] Google. (2025, Jan 23). _Search Quality Rater Guidelines._ Retrieved from [9] Google. (2025, July). _Latest AI updates: Bringing AI Mode to Circle to Search and Lens._ Retrieved from [10] Google Search Central Blog. (2023, Aug 8; updated Sep 14). _Changes to HowTo and FAQ rich results._ Retrieved from --- # SEO for lead generation: a practical playbook Source: https://bluenebula.dev/blog/seo-strategies-for-lead-generation By Luna R., Blue Nebula. Published 2025-09-05, updated 2026-10-13. > How to line up search intent, content and page design so organic search brings in steady leads without leaning on paid ads. SEO strategies for lead generation work when you target the searches people make close to a purchase, publish pages that answer those searches well, make the next step (a demo request, a quote) easy to take, and judge each page by the pipeline it brings in. Rankings and traffic only matter as far as they feed that number. Search is worth investing in alongside ads because it compounds. A page that ranks keeps bringing in leads after the work on it is done, while paid traffic stops when the budget does. ## Why organic search still pays off for lead gen Someone searching “best SOC 2 compliance software” or “fractional CFO services pricing” is already shopping, and searchers mostly click the first few organic results: **Chart: Organic CTR by ranking position (2025)** On Google results pages without extra features such as maps or videos, position 1 averages a 39.8% CTR; position 2, 18.7%; position 3, 10.2%; position 4, 7.2%; position 5, 5.1% [1]. | | Organic CTR (%) | | ---------- | --------------- | | Position 1 | 39.8 | | Position 2 | 18.7 | | Position 3 | 10.2 | | Position 4 | 7.2 | | Position 5 | 5.1 | Source: The first result gets more clicks than the next two combined, and moving from fifth to first on the right term multiplies the traffic it sends you. Paid search, meanwhile, charges you for every lead. WordStream’s 2024 benchmarks put the average cost per lead from search ads at $66.69, with a 6.96% conversion rate [2]. Organic positions that bring in leads are a hedge against swings in the ad auction. Ads are still the quickest way to test an offer. SEO is what brings your cost per lead down over time. ## From buyer problems to pages that convert Start with the problems your buyers are trying to solve. Keywords are easier to judge once you know which problem each one belongs to. ### Map searches to the stages of a purchase The same search can come from very different people: “security monitoring” might be early research for a CISO or a pricing check for a procurement manager. Map each query to a stage of the purchase (discovery, evaluation, comparison, decision) and give the searcher what they need at that stage. In practice, that means intent clusters: “what is X” is educational, “best X for Y” is commercial, “X vs Y” is a comparison, and “X pricing” is close to a decision. One page per cluster, each with a clear purpose, keeps the blog from bloating and points every visitor to a useful next step. ### Publish the pages buyers use to decide Buyers get in touch when a page shows them specifically what changes if they buy from you. The unglamorous formats do this best: - Comparison and alternatives pages that help buyers choose (“X vs Y,” “top X solutions for Y”). - Pricing and ROI pages that set expectations and help someone justify the budget. - Implementation guides and calculators that turn curiosity into a commitment. - Case studies with specific numbers in them. If your educational posts rank but rarely turn into demo requests, these are the pages to build first. ### Fix conversion and page speed early Conversion work tends to wait until the rankings arrive. I’d do it first: the conversion layer (offers, forms, calls to action, chat, trust signals) often pays back faster than ranking improvements, because it works on the traffic you already have. Speed is part of conversion too. In a 2020 study for Google, Deloitte found that shaving 0.1 seconds off mobile load times lifted retail conversions by about 8% and travel conversions by about 10% [3]. You don’t need to chase every millisecond, but aim for pages that pass Core Web Vitals and load in under three seconds, with forms that ask only for what your sales team uses. ## Choose keywords by how close they are to a sale The quickest way to waste an SEO budget is to chase broad head terms your CFO can’t connect to revenue. Instead, sort the queries for each ideal customer profile by how close they are to a purchase: | Query type | Example | What it’s good for | | ----------------------- | ------------------------------------------------- | ------------------------------------------ | | Problem discovery | “what is chargeback protection” | List growth and retargeting | | Solution exploration | “chargeback protection software” | Winning on positioning and proof | | Comparison and decision | “Company X vs Company Y,” “pricing,” “case study” | The shortest path to sales-qualified leads | Then score each term on how close the search is to buying and whether you can realistically become the best answer, given the pages that rank for it now. That points the budget at terms that can produce pipeline within a quarter, while the site builds the authority to win bigger terms later. When in doubt, pick the specific term over the high-volume one. Long-tail searches with clear buying intent convert far better than the generic version, and ranking first for “best compliance software for fintech startups” will bring in more leads than sitting on page ten for “compliance software.” ## Give every page a next step A visit only matters if it turns into a conversation, so every page needs an obvious next step. Educational pages can offer something useful in exchange for an email address, like a short checklist or a quick demo video. Mid-funnel pages earn trust with honest pricing guidance and realistic implementation timelines. They should also say plainly who you’re a good fit for, and who you aren’t. Decision pages need proof, like results with numbers and customers you’re allowed to name, plus a direct line to a person. Say you sell a data quality platform and someone searches “data deduplication for Salesforce.” Your page opens with a 90-second explainer and a side-by-side comparison of manual cleanup and your platform, then offers a two-step trial sign-up or a “see your records fixed” concierge demo. Readers can get started without talking to sales, or ask for help straight away. ## Track pipeline by landing page A ranking that never turns into pipeline is a vanity metric. Tying SEO to revenue takes clean attribution and definitions everyone agrees on: - Track primary conversions (demo requests, trial sign-ups, pricing inquiries, contact forms) and assist conversions (content downloads, tool usage). - Record clicks on every internal call to action, so assisted paths show up in your reports. - Mirror your CRM lifecycle (MQL → SQL → Opportunity → Closed-Won), and tag whether each opportunity came from organic search or was only influenced by it. - Review opportunity quality by landing page each month to see which pages attract tire-kickers and which predict pipeline. The number to steer by is pipeline per visit for each group of pages. Once leadership sees which topics and offers bring in revenue, budget decisions get much easier. ## Reviews and local listings for service businesses For a services business, your Google Business Profile and reviews are part of SEO. BrightLocal’s consumer review research finds that Google is still the platform people use most to read reviews of local businesses [4]. Even if you sell nationally, local visibility and how you handle reviews can affect whether you make a prospect’s shortlist. Keep your listings complete, and publish service and location pages that match how people search. Ask for reviews regularly and reply with care, because prospects read how you handle messy, real-world situations. ## What AI Overviews change for lead gen AI Overviews and richer snippets haven’t killed organic clicks: First Page Sage’s 2025 data still has the top organic results taking most of them [1]. Publishers that depend on informational searches are hit harder, which I covered in [AI answers vs referral traffic](https://bluenebula.dev/blog/publisher-squeeze-ai-answers-vs-referral-traffic). For lead-gen pages, the change is in how people judge the answers they find, and two adjustments help. First, be the best quick answer: a short, clear explanation up top that people and machines can both follow, descriptive subheadings, concise definitions and structured data where it applies. My post on [writing for AI Overviews and AI Mode](https://bluenebula.dev/blog/writing-for-googles-ai-overviews-ai-mode) covers page structure in more detail. Second, own the depth behind the answer. Pair the quick answer with what only your team can provide: calculators, benchmarks, implementation detail and proof from real cases. If an AI Overview covers the basics, your page wins by taking the reader from summary to solution in one scroll. ## A 90-day plan for lead-gen SEO One quarter is enough to get the first lead-focused pages live and measured. Here’s how a team could lay out the 12 weeks: **Diagram: Twelve weeks of lead-gen SEO** 1. Revenue discovery (Weeks 1–2: which customers and deals matter most) 2. If Weeks 2–3: Keyword and intent map (Ranked by how much pipeline each search could bring) 3. If Weeks 3–4: Page blueprints (Pillar, comparison, pricing and case-study pages) 4. If Weeks 4–8: Production and UX (Fast pages, clear calls to action, trust signals) 5. If Weeks 6–10: Launch and promotion (Internal links, outreach, syndication) 6. If Weeks 8–12: Measurement and conversion work (Offers, forms, chat, split tests) 7. Quarterly review (Put more into the pages that worked) 8. Then it splits: - If Targets met: 1. Scale (More topics, deeper coverage) - If Not yet: 1. Refine (Reposition, try new offers, speed pages up) The point is to stop publishing at random. Ship the pages closest to a sale first, such as comparisons and pricing, then add educational content that links back to them. ## Mistakes that stall lead-gen SEO - Choosing topics by search volume instead of how close they are to a sale. - Publishing pages that nothing links to, with no clear call to action. - Building slow, dense pages with long forms, so interested visitors give up before they convert. - Leaving pages alone once they rank, when they need updates to keep converting. Treat important pages like products, each with an owner and a goal, and update them as you learn how people use them. A relaunch without a plan for search can undo all of this at once, because rankings are tied to URLs and the content on them. Before any relaunch, list the pages that bring in traffic and leads, and give each one a place and a redirect on the new site. ## Four findings to plan around The top organic results get most of the clicks [1], and paid search costs an average of $66.69 per lead [2]. Faster pages convert better [3]. Google is still where most people read reviews [4], which matters most if you sell services. So if you can only do one thing this quarter, I’d pick the handful of searches closest to a purchase in your market and build one fast, specific page for each. Then count the conversations those pages start. After 90 days, that count will tell you more about whether SEO works for your business than any ranking report. ## Sources [1] First Page Sage. (2025). _Google Click-Through Rates (CTRs) by Ranking Position in 2025_. Retrieved from [2] WordStream. (2024). _Search Advertising Benchmarks 2024_. Retrieved from [3] Think with Google & Deloitte. (2020). _Milliseconds Make Millions_. Retrieved from [4] BrightLocal. (2025). _Local Consumer Review Survey_. Retrieved from