DEV Community: Rafał Fuchs

How to check your brand's visibility in ChatGPT, step by step

Rafał Fuchs — Tue, 11 Aug 2026 18:53:51 +0000

When a prospective buyer asks ChatGPT about suppliers in your category, the model names specific companies - usually three to six of them. You are either on that list or you are not. This guide shows how to check that yourself in about 30 minutes: which questions to ask, how to avoid distorting the results, and how to record them so they can be compared over time. If the result disappoints, see how to build visibility in ChatGPT systematically.

Before you start: ChatGPT is two different mechanisms

The classic ChatGPT answers from training data, so its knowledge of brands can be many months old. ChatGPT Search - triggered automatically or via the globe icon - searches the live web and cites pages. Your brand can be visible in one mechanism and absent from the other, so check both.

Step 1: turn off personalisation and work in a clean context

ChatGPT remembers earlier conversations and adapts its answers. If you have previously asked about your own company, the model will name it more often and your results will be distorted. Use Temporary Chat, or sign out and ask in a private window. Ask every question in a new thread.

Caution:

The most common mistake is asking "do you know company X?" in a normal chat. The model will almost always answer yes, politely - that is not a visibility test. A visibility test asks for recommendations in a category without naming the company.

Step 2: ask buying questions, not reputation questions

Which companies do you recommend for [your service category]?
I am choosing a supplier of [service] for a B2B company in [industry]. Who should we consider?
Build a shortlist of five companies offering [category], with a short rationale for each.
Which [category] company would suit [company size / budget / specific constraint]?
How do the leading suppliers of [category] differ from one another?

Ask every question twice: once in the classic chat and once with search enabled. Note the differences - this is often the moment teams discover that the model "knows" the brand from training, but cites only competitors when searching live.

Step 3: assess the quality of the description, not just presence

If the brand does appear, look at how it is described. Possible problems include the wrong category, an outdated offer, or a mention with no supporting rationale. Each case should be documented against the complete answer and assessed in the context of the question.

Step 4: record the results and calculate Share of Model

Question	ChatGPT (training)	ChatGPT Search	Competitor A	How the brand is described
Recommended [category] companies	no	no	yes (2x)	-
Shortlist of five [category] companies	yes	no	yes	wrong service category
Supplier for [industry]	no	yes	yes	no rationale given

Share of Model is the percentage of answers containing your brand. Measure across a fixed set of at least ten questions and repeat monthly - a single measurement is a snapshot, and only a series shows the trend and the effect of the changes you made.

What to do when ChatGPT does not recommend you

Sharpen the category, target audience and service scope on your home page - models do not recommend companies they cannot classify.
Publish citable content: comparisons, FAQs and case studies with numbers - this is what ChatGPT Search builds answers from.
Work on presence in industry rankings and round-ups, which are common sources for recommendations.
Implement schema.org structured data so the model understands unambiguously what your company is.

ChatGPT is only one AI answer surface. The equivalent instructions for Perplexity are in the guide to checking brand visibility in Perplexity, and the full measurement rules are in the methodology. The scope of a paid Snapshot or audit is matched to the category and the hypothesis.

FAQ

Can I check visibility in ChatGPT for free?

Yes. The free version of ChatGPT is enough - it has access both to answers from training data and to web search. The key is the method: a clean context, buying questions and a fixed set of prompts.

Why does ChatGPT name my company sometimes and not others?

Model answers are non-deterministic - the same question can produce different results. That is why a single test settles nothing. Measure across a set of at least ten questions and look at the percentage of appearances (Share of Model), not at individual answers.

How long does it take to improve visibility in ChatGPT?

In ChatGPT Search, the effects of site changes can appear within weeks, because the mechanism reads the live web. In the classic ChatGPT, changes happen more slowly, alongside model data updates. A typical horizon for measurable improvement is two to four months of systematic work.

Is ChatGPT visibility the same as SEO?

No, although the two overlap. SEO optimises positions in Google results, whereas ChatGPT visibility depends on whether the model can classify the brand, cite it and justify a recommendation. Good SEO helps, but it is not sufficient on its own.

Originally published at AiVisible. AiVisible measures how often companies and products appear in ChatGPT, Gemini, Claude and Perplexity answers.

AI visibility monitoring tools: a 2026 review and comparison

Rafał Fuchs — Tue, 11 Aug 2026 18:53:41 +0000

2025 was the year the AI visibility tooling market exploded. In 2023 there was no dedicated tool for tracking share of voice in ChatGPT or Perplexity; today more than 30 products compete in the category. The problem is no longer a lack of choice - it is finding your way through the thicket to a tool that matches your needs and budget.

This guide compares tools by model coverage, data quality, language support, price and fit. If you want to establish the scope first, use our benchmark qualification. Full measurement is part of a Snapshot or an audit.

Before paying for a tool, assess your category fit free of charge. A paid Snapshot or audit documents the starting point and the gaps. For continuous measurement, compare Continuous AI Visibility in the pricing.

What should an AI visibility tool monitor?

Before the tools themselves, it is worth setting the assessment criteria. A good AI visibility tool should monitor at least:

Share of Voice - what percentage of AI answers to your keywords name your brand. This is the core AI visibility metric.
Citation frequency rate - how often your site is cited as a source, particularly in Perplexity and ChatGPT Search where links are visible.
Sentiment analysis - whether mentions are favourable, neutral or unfavourable. You can be cited often but in a negative context.
Competitor comparison - your share of voice alone says little. What counts is relative: if you are at 30% and the market leader at 70%, there is room to improve.
Model coverage - the tool should monitor at least ChatGPT, Perplexity, Google AI Overviews and Gemini. Monitoring one model gives an incomplete picture.
Alerts and trends - notifications when share of voice falls significantly or a new competitor appears in AI answers.

A comparison table

Tool	AI models	Price from	Best for
Profound	ChatGPT, Perplexity, Gemini, Claude, Bing AI	USD 49/month	Agencies, enterprise B2B
Otterly.AI	ChatGPT, Perplexity, Gemini	USD 29/month	Small companies, PR teams
AthenaHQ	ChatGPT, Perplexity, Google AI	USD 199/month	Enterprise, larger budgets
ZipTie.dev	ChatGPT, Google AI Overviews	USD 49/month	SEO teams focused on Google AIO
Peec AI	ChatGPT, Perplexity, Gemini	USD 39/month	Mid-market B2B
Brandlight	ChatGPT, Perplexity, Bing	USD 79/month	Brand management teams
Ahrefs Brand Radar	AI answers and LLM mentions	Free plan available	First check, small teams

Profound - the most mature enterprise option

Profound is currently the most comprehensive tool on the market. It monitors five AI systems at once - ChatGPT, Perplexity, Gemini, Claude and Bing AI - and offers detailed share-of-voice reports broken down by query category, with competitor comparison. Its prompt-testing module stands out: you can add your own questions that the model asks regularly, and measure the answers.

Strengths: the widest monitoring coverage, a good API, exportable reports and support for European languages. Weaknesses: price - the enterprise plan starts at USD 199 a month, which can be a barrier for smaller companies. The interface is extensive and takes learning. For agencies managing several clients, the agency plan is justified.

Otterly.AI - the most accessible for small companies

Otterly.AI focuses on simplicity and affordability. The entry plan at USD 29 a month covers brand monitoring in ChatGPT, Perplexity and Gemini, email alerts on significant changes and a basic dashboard with trends. The interface is intuitive and can be running in 15 minutes.

Limitations: no advanced competitor analysis - it tracks your own brand only. For companies just starting to measure AI visibility, it is a good starting point.

AthenaHQ - for enterprise with demanding requirements

AthenaHQ is designed for large organisations with dedicated marketing teams. What distinguishes it is deep analysis of the reasons for citation - the tool tries to explain why AI names particular brands, analysing credibility and topical-fit factors.

The USD 199 monthly entry price is a barrier. AthenaHQ suits environments where AI visibility is already an established board-level metric and detailed reports for stakeholders are needed.

ZipTie.dev - the Google AI Overviews specialist

ZipTie occupies a distinctive niche: it specialises in monitoring Google AI Overviews. If your priority is visibility in Google results with an AI summary, ZipTie is the dedicated tool. It tracks whether your page is cited in an AI Overview for given keywords, and shows which passage is cited.

The limitation: ZipTie monitors only ChatGPT and Google AIO - not Perplexity, Gemini or Claude. For companies focused mainly on Google presence, where AI Overviews are increasingly common, it is a good complement to standard SEO tooling.

Language coverage matters more than the feature list

Most tools were built for English-language queries first. If your buyers search in another language, check three things before subscribing: whether the tool handles queries in that language accurately, whether its source coverage includes local publications, and whether the reporting distinguishes results by language. A tool with excellent English coverage can produce misleading numbers for a market it barely indexes.

Note:

A recommendation for B2B teams: start with a low-cost tool such as Otterly.AI or the free Ahrefs Brand Radar plan. After three months, when you have a data baseline and know which metrics matter to you, assess an upgrade to Profound or AthenaHQ. Do not start with an enterprise tool - before you know what you are measuring, expensive tooling wastes budget.

How to choose - a decision framework

The choice should follow from a few specific questions:

Do you need monitoring in a language other than English? Check source coverage for that market before committing.
What is your budget? Under USD 50 a month: Otterly.AI, Peec AI or ZipTie. Above that: Profound or AthenaHQ.
Is Google AIO your priority? ZipTie, or Profound with the Google module.
Do you run an agency managing several clients? Profound's agency plan or an Otterly.AI team plan.
Do you need an API to integrate with your own dashboard? Profound or AthenaHQ.
Are you just starting and want to understand what AI visibility is? Otterly.AI's entry plan has the gentlest learning curve.

The alternative: manual monitoring with no tooling

If budget is tight, you can build a simple monitoring system by hand. It will not replace dedicated tooling, but it gives a baseline at no cost:

Create a spreadsheet listing 20 to 30 category questions related to your offer
Once a month, ask each question in ChatGPT (without browsing), Perplexity and Gemini
Record whether your brand appears, whether competitor X appears, and the context of the mention
Calculate a simple share of voice: answers containing your brand divided by all queries, times 100
After three months you have a trend - rising, falling or flat

The drawbacks of the manual approach: it is labour-intensive at around three to four hours a month, it does not provide real-time alerts, and it has no competitor comparison. But before you invest in a tool, it is a good way to verify whether AI visibility is a problem for your company at all.

Newer entrants: Nightwatch, Keyword.com and Scrunch

The AI visibility tooling market changes quickly. Several new products have gained traction among SEO teams:

Tool	Specialisation	AI models	Price from
Nightwatch	Conventional SEO plus AI visibility in one	ChatGPT, Claude	USD 39/month
Keyword.com	SEO rank tracking with an AI extension	ChatGPT, Google AIO	USD 69/month
Scrunch AI	Citation and brand mention monitoring in AI	ChatGPT, Perplexity, Gemini	USD 49/month
Rankscale	AI search visibility monitoring	ChatGPT Search, Perplexity	USD 59/month

Nightwatch is particularly interesting for SEO managers who want to track conventional Google positions and AI visibility in one dashboard. Combining both metrics in one place shows the correlation: whether a rise in SEO position translates into improved AI share of voice. Keyword.com is a good choice for teams already using it for rank tracking who want to add AI tracking without changing workflow.

Note:

The market has grown past 40 products in this category. Choose tools with at least six months of market history - many start-ups here have closed or been acquired. Also check whether the tool monitors ChatGPT Search, not only the classic ChatGPT; that has been a key feature since 2025.

FAQ

What data does an AI visibility monitoring tool collect?

Primarily: model answers to a defined set of control prompts, the presence and position of the brand in those answers (Share of Model), the sources and links cited, mention sentiment, and comparison with competitors over time. Better tools also track which of your pages are cited, which indicates what content AI treats as credible.

How is brand visibility in prompts measured?

Through two metrics: Share of Model (what percentage of answers to a prompt set name your brand) and shortlist position (whether AI names you as the first, third or last recommendation). Measurement requires a fixed set of 20 to 120 control prompts asked regularly of the same models - a single test proves nothing, because AI answers are non-deterministic.

Do any tools monitor visibility in languages other than English?

Coverage varies considerably. Profound supports European languages, with accuracy strongest in English. Otterly.AI and AthenaHQ work mainly in English - you can set prompts in another language, but the interface and analysis are English. Check source coverage for your market before subscribing.

How often do tools check AI answers?

It depends on the tool and plan. Otterly.AI checks daily on the base plan. Profound can check several times a day on higher plans. AthenaHQ offers near-real-time monitoring at enterprise level. More frequent checks cost more, because models charge per API query.

Do AI visibility tools replace SEO tools such as Semrush or Ahrefs?

No - they are complementary, not substitutes. Semrush and Ahrefs measure Google positions and analyse backlinks. AI visibility tools measure share of voice in ChatGPT, Perplexity and similar. Different metrics, different channels. Companies serious about online visibility need both categories.

Are free plans enough to start with?

Most tools offer a trial of 7 to 14 days rather than a permanent free plan. Ahrefs Brand Radar is an exception with a free tier. A two-week trial is enough to judge whether a tool meets your needs. Continuous monitoring requires a paid plan.

Originally published at AiVisible. AiVisible measures how often companies and products appear in ChatGPT, Gemini, Claude and Perplexity answers.

llms.txt: what it is, why it matters and how to implement it

Rafał Fuchs — Sat, 08 Aug 2026 07:33:12 +0000

In December 2024, Jeremy Howard, the creator of fast.ai, proposed a simple standard: an llms.txt file placed in a domain's root directory, telling AI systems about the structure and content of the site. The standard is supported by Anthropic (Claude), Perplexity and a dozen or so other AI tools. Implementation cost: a few minutes. Potential effect: better understanding of your site by AI systems.

What is llms.txt?

llms.txt is a Markdown-format text file placed at yourdomain.com/llms.txt. Its job is to convey key information about the site to AI systems in a structured, easily processed form. The analogy: robots.txt tells search engines what they may index; llms.txt tells AI systems what is worth knowing about your site.

The standard is backed by platforms including Reddit, Medium, Cloudflare, Akamai and Creative Commons. It is not mandatory - AI systems manage without it. But its presence signals that your company understands AI mechanisms and wants to shape actively what AI knows about it.

Note:

llms.txt does not replace good content on the site. An AI system will still index your domain and draw on the content of your pages. llms.txt is a pointer, not a substitute for valuable content.

What does an llms.txt file contain?

The file format is simple and human-readable. It consists of a few elements:

A title and company description - one sentence explaining what the company does and for whom
Links to key sections with descriptions - service pages, blog, about, case studies
Optional key facts - the data you want AI to know about your company
Optional guidance on content use - if you have preferences about citation

An example llms.txt for a B2B company

In short: An example llms.txt for a B2B service company:

# AiVisible

> AiVisible helps B2B companies measure and improve their visibility in AI answers.

## Services
- [AI Visibility Snapshot](https://www.aivisible.pl/en/ai-visibility-snapshot): a focused measurement of one category and market
- [Strategic AI Visibility Audit](https://www.aivisible.pl/en/ai-visibility-audit): complete answers, benchmark, sources and a roadmap
- [AI Recommendation Sprint](https://www.aivisible.pl/en/ai-visibility-implementation-sprint): a backlog of recommendations and experiments
- [Continuous AI Visibility](https://www.aivisible.pl/en/continuous-ai-visibility): ongoing measurement and further experiments

## Knowledge
- [Blog](https://www.aivisible.pl/en/blog): articles on AI Visibility and GEO
- [Methodology](https://www.aivisible.pl/en/methodology): the measurement protocol and its limits

## Key facts
- We work with B2B companies
- The free stage qualifies the category and is not an audit

How to implement llms.txt, step by step

Create the llms.txt file - open a text editor and write the content in Markdown, as in the example above. Save it as llms.txt.
Place the file in the domain root - it has to be reachable at yourdomain.com/llms.txt. In Next.js put it in the /public folder. In WordPress, in the server root directory.
Check availability - open yourdomain.com/llms.txt in a browser. You should see the text file with its content.
Optionally add llms-full.txt - the standard also allows an extended version containing the full content of key pages, for models that want to fetch everything at once.

How to implement llms.txt in Next.js

In Next.js the simplest approach is to place the file in the /public folder, where it is served automatically as a static asset. Alternatively you can generate llms.txt dynamically through a route handler at app/llms.txt/route.ts, which lets you update the content without rebuilding the project.

Which AI systems read llms.txt?

Model or tool	llms.txt support	Notes
Claude (Anthropic)	Yes	Direct support for the standard
Perplexity	Yes	Used when indexing sites
ChatGPT (browsing)	Partial	Not officially, but indexes the file
Google Gemini	Not officially	The standard is not confirmed
Bing Copilot	No	No official support

Does llms.txt actually work?

The standard is too new for hard data on its effect on AI visibility. Early experiments suggest that AI systems officially supporting it - Claude and Perplexity - do use llms.txt to build context about a site. For models that do not support it formally, the file is simply ignored and does no harm.

Our conclusion: llms.txt is worth implementing on a cost-to-potential-benefit basis. Implementation takes 15 to 20 minutes. The risk is zero. The potential gain is better understanding of your site by the AI systems that support the standard. As the standard matures and adoption grows, companies that implemented it early will have nothing to catch up on.

FAQ

Is llms.txt mandatory?

No, but it is an emerging standard that helps AI systems understand the structure and offer of your site correctly.

Where should the llms.txt file go?

The file should sit in the domain root, for example aivisible.pl/llms.txt, in the same way as robots.txt.

Originally published at AiVisible. AiVisible measures how often companies and products appear in ChatGPT, Gemini, Claude and Perplexity answers.

How to check whether AI recommends your company, step by step

Rafał Fuchs — Sat, 08 Aug 2026 07:33:04 +0000

The owner of a consultancy checked one morning what ChatGPT says about their category. They typed in a question a client might ask. The answer named four specific companies. Theirs was not among them. Two of the four were firms they had never heard of in ten years of work. That same day they commissioned an audit of their presence in AI.

Checking individual answers needs no specialist tooling. A comparable audit, however, needs a protocol, complete records and coding rules. You can start with a free category-fit assessment.

Step 1: identify the questions your buyers ask

Before opening any AI system, you have to know what to look for. Your buyer does not ask "do you recommend company XYZ?" They ask about the problem they need to solve. So ask yourself: what does my ideal customer type into ChatGPT when looking for the solution I offer?

Example buyer questions by category:

SEO agency: "Which SEO agency is good for an online shop?", "How do I find a good SEO specialist?"
IT company: "Which development firms do you recommend for building mobile apps?", "Which IT company specialises in e-commerce?"
Accountancy practice: "How do I choose an accountant for a start-up?", "Who handles bookkeeping for technology companies?"
Law firm: "Who is good on employment law for employers?", "Which firm is recommended for corporate work?"
Training provider: "Where can I learn project management?", "Best Excel training for companies"

In short:

A useful technique: ask three current clients what they typed into Google or an AI system before they found you. Those are real phrases, not guesses.

Step 2: test in ChatGPT

ChatGPT is the starting point because it has the widest reach. A free account is enough, and the current default model has web access.

Start a new conversation - do not continue an old one, so earlier context cannot influence the result. Enter your test questions and observe:

Does your company appear by name?
If so, in which position and how is it described?
Who else appears? That is your competition in AI.
Which attributes does AI ascribe to the recommended companies?
Does AI give any sources or links?

Test the same question three times - ChatGPT gives different answers on each run. If your company appears in one of three attempts, that signals weak presence. If it appears every time, that is a good sign.

Step 3: check Perplexity

Perplexity deserves separate measurement because it shows sources alongside the answer. Do not assume, though, that its user profile matches your B2B audience. Confirm that in conversations with clients and in your buying-journey data.

In Perplexity, pay attention to one extra element: the sources. Click through the cited pages - those are the pages Perplexity treats as authoritative in your category. If your site is not among them, that is a concrete thing to fix.

Note:

Reddit accounts for a substantial share of citations in Perplexity. If your company is active in relevant subreddits or comparable communities, Perplexity is more likely to notice you.

Step 4: Google AI Overviews and Gemini

Google AI Overviews - the AI answer box at the top of results - appears on a large share of queries. Go to Google and enter your test phrases. If an AI Overview appears, check whether your company is mentioned and whether your page is among the sources.

An important difference: 92% of Google AI Overviews citations come from pages in the organic top ten. Conventional SEO therefore matters more here than in ChatGPT. If you do not rank, you will not be cited by Google AI. But 47% of citations come from outside the top five, so content quality - not only position - counts.

Step 5: compare yourself with competitors

Establishing that you are absent is only half the information. The more important question is who appears instead of you. Note the companies AI names in answer to your questions. That is your real competition in the AI channel, even if you outrank them in Google.

For each competitor, ask what they have that you do not. Typical answers: a stronger LinkedIn presence, an active blog with specific articles, mentions in industry publications, a Wikipedia entry, or activity on forums and Reddit.

How to interpret the results

Once the tests are done, assess where you stand:

Test result	Assessment	Priority
Appear in over 70% of answers, in positions 1-3	Good visibility	Maintain and monitor
Appear in 30-70% of answers	Average visibility	Optimise content and mentions
Appear in under 30% of answers	Weak visibility	A full AI Visibility strategy
Do not appear at all	No visibility	Diagnosis and urgent action
AI describes you unfavourably or inaccurately	Reputation problem	Immediate intervention

The limits of manual testing

Manual tests are a good starting point, but they have limits worth knowing. First, AI generates different answers each time - what you see is a sample, not a stable result. Second, different locations and accounts can produce different results. Third, you cannot see how you compare against all competitors - only against whatever AI happened to generate.

A systematic diagnosis covers hundreds of test queries, a comparison with three to five direct competitors, analysis across several models at once, and an assessment of the site content itself for citability. A manual test tells you whether you have a problem. A full diagnosis tells you why, and what specifically to change.

What to do after the diagnosis

If the tests revealed a problem, do not be too alarmed. Most companies have no AI Visibility strategy at all, which means competition is still low. Companies that start now have a genuine chance of dominating AI answers in their niche within three to six months.

Three immediate steps after the diagnosis: (1) improve site content for citability - specific definitions, data and a question-and-answer structure; (2) start building brand mentions on external platforms such as industry publications, LinkedIn and forums; (3) monitor regularly, because AI changes and results from a month ago may already be out of date.

FAQ

How do I check my company's visibility in ChatGPT?

Open ChatGPT and ask the questions a prospective buyer might type, such as "Which [your category] companies do you recommend?" or "Which [service] provider should we choose?" Check whether your company appears. Repeat five to ten times - AI gives different results on each query.

How do I check brand visibility in Perplexity?

Open Perplexity and search category phrases. Perplexity shows its sources, so you can check whether your page is cited. Ask comparison questions such as "What are the best X companies?" and observe which brands appear in the answer.

How many questions do I need to measure AI visibility?

The minimum is 20 to 30 questions per model, because results vary and a single test is too small a sample. A systematic diagnosis covers at least 50 queries per model, across several question variants, with a benchmark of three to five direct competitors.

Can I improve my company's AI visibility myself?

Yes, but it requires systematic work. The basic steps are tidying up your content, your credible sources and your measurement. A free AiVisible category-fit assessment will help you choose the right paid scope.

What does it mean if AI does not recommend me?

It means the model lacks sufficient knowledge about your company, or does not associate you with that service category. The most common causes are an absence of mentions in external sources, site content that does not answer buyer questions directly, or a company too new to appear in the model's training data.

Originally published at AiVisible. AiVisible measures how often companies and products appear in ChatGPT, Gemini, Claude and Perplexity answers.

Transaction boundaries in Django: where consistency really ends

Rafał Fuchs — Fri, 17 Apr 2026 14:50:24 +0000

TL;DR: transaction.atomic() protects SQL work on one connection to one database. It does not protect queues, emails, webhooks, other databases, or third-party APIs. If you design a business process as if one atomic block covered the whole thing, sooner or later you will ship a half-commit to production: DB state changed, side effects missing (or the other way around). This post walks through where the real consistency boundary is, and what to reach for when you need more.

I'm a senior backend engineer working in Python/Django. More long-form writing at rafalfuchs.dev.

The illusion `atomic()` creates

Most Django developers learn transactions through a comforting pattern:

with transaction.atomic():
    order = Order.objects.create(...)
    Payment.objects.create(order=order, ...)
    send_confirmation_email(order)
    publish_to_kafka("order.created", order.id)

It reads like one unit of work. It feels atomic. It is not.

Only the first two lines are actually protected by the database transaction. The email and the Kafka publish happen inside the with block, but they are side effects that do not roll back if the transaction aborts. Worse: if they fire before the commit and the commit then fails, you just notified the world about an order that does not exist.

This is the core misconception I want to unpack: SQL commit is not business-process commit.

1. What `atomic()` actually guarantees

Think of atomic as a local database safety boundary. Scoped to one connection, one database, one transaction.

It does:

commit or roll back SQL changes together,
support nesting via savepoints,
preserve invariants inside that specific DB transaction.

It does not:

include external side effects (HTTP calls, emails, message brokers, cache writes),
guarantee delivery of any asynchronous message,
solve multi-database atomicity,
protect you from a successful commit followed by a crash before your handler returns.

That last point trips up a lot of people. The moment __exit__ on the context manager finishes, your transaction is committed. Anything afterwards is a new world, and the database has no idea whether your Celery task made it into Redis or not.

2. `ATOMIC_REQUESTS`: a sharp tool, not a default

ATOMIC_REQUESTS = True wraps every request in a transaction. It feels like a sane default, and for small apps it genuinely reduces accidental partial writes.

At higher traffic it starts to bite:

transactions live longer (the full request lifecycle, not just the write),
lock contention climbs on hot rows,
throughput on mixed read/write endpoints drops,
a slow external call inside a view now holds a DB transaction open for its entire duration.

The better architectural question is rarely "can we wrap the whole request?". It is "which specific write-critical section genuinely needs a transaction?". Reach for explicit with transaction.atomic(): around that section, and let the rest of the request run without holding row locks.

3. The minimum viable guardrail: `transaction.on_commit`

If you only take one pattern away from this post, take this one. Never fire a side effect from inside an atomic block directly. Register it with on_commit:

from django.db import transaction


def create_invoice_and_enqueue(invoice_data):
    with transaction.atomic():
        invoice = Invoice.objects.create(**invoice_data)

        transaction.on_commit(
            lambda: publish_invoice_created(invoice_id=invoice.id)
        )

    return invoice

on_commit holds the callback until the outermost transaction successfully commits. If the transaction rolls back, the callback never runs. No phantom notifications about invoices that no longer exist.

But note what this still does not give you:

if the process crashes between commit and on_commit execution, the callback is lost,
if the broker is down when the callback fires, the message is gone,
if the consumer processes the message twice, you get double side effects.

on_commit is a necessary guardrail, not a delivery guarantee. Pair it with retries on the producer side and idempotent consumers on the receiver side, or move to something stronger (see section 6).

4. Isolation levels and the race conditions you are not seeing

Django on PostgreSQL defaults to READ COMMITTED. That means: you see rows that were committed before your statement started. It does not mean: nobody can change a row between your SELECT and your UPDATE.

Classic broken pattern:

# BROKEN under concurrency
def reserve_stock(product_id, qty):
    with transaction.atomic():
        product = Product.objects.get(id=product_id)

        if product.available_qty < qty:
            raise ValueError("Insufficient stock")

        product.available_qty -= qty
        product.save(update_fields=["available_qty"])

Two concurrent requests both read available_qty = 5, both see enough stock for qty = 3, both subtract, and you have just oversold by 1 unit. The transaction committed successfully. The business invariant is broken.

Three tools to pick from, in rough order of cost:

4a. Pessimistic locking with `select_for_update`

from django.db import transaction


def reserve_stock(product_id, qty):
    with transaction.atomic():
        product = (
            Product.objects
            .select_for_update()
            .get(id=product_id)
        )

        if product.available_qty < qty:
            raise ValueError("Insufficient stock")

        product.available_qty -= qty
        product.save(update_fields=["available_qty"])

Simple, correct, and it serializes everyone hitting the same row. Use it for short critical sections on high-value state (stock, balance, seat booking). Keep the locked section small - do not put HTTP calls inside.

4b. Optimistic locking with a version column

updated = (
    Product.objects
    .filter(id=product_id, version=expected_version)
    .update(
        available_qty=F("available_qty") - qty,
        version=F("version") + 1,
    )
)

if updated == 0:
    raise ConcurrentUpdateError("retry")

Lets readers through without blocking. The loser of a race has to retry. Good fit for read-heavy paths where contention is rare but must be detected.

4c. Database constraints as the last line of defence

UNIQUE, CHECK, FK, partial indexes. Your application logic will have bugs. The database is the one layer that will reliably catch a duplicate order number or a negative balance. Treat constraints as non-negotiable, not as "optimization for later".

5. The moment you cross a process boundary, there is no global transaction

The moment your use case touches Celery, a webhook, an email provider, a second database, or any external API, you are out of the ACID world. There is no protocol that wraps "insert row in Postgres" and "send message to SQS" into one atomic action. Two-phase commit exists on paper. Almost nobody runs it in production for good reasons.

What you actually have is a distributed system with partial failures. Your options:

Scenario	Acceptable approach
Side effect is nice-to-have (analytics event)	`on_commit` + fire-and-forget, accept occasional loss
Side effect must eventually happen	`on_commit` + retries + idempotent consumer
Side effect must happen exactly-once-ish, and loss is unacceptable	Outbox pattern

The outbox pattern is the one I reach for in anything touching billing, inventory, compliance, or audit.

6. The outbox pattern, concretely

The idea: instead of publishing to a broker from application code, write the message to a regular table in the same transaction as your domain change. A separate worker reads the outbox and publishes. Because the write and the message land in one DB commit, they succeed or fail together.

Schema

class OutboxEvent(models.Model):
    id = models.BigAutoField(primary_key=True)
    aggregate_type = models.CharField(max_length=64)
    aggregate_id = models.CharField(max_length=64)
    event_type = models.CharField(max_length=128)
    payload = models.JSONField()
    created_at = models.DateTimeField(auto_now_add=True)
    published_at = models.DateTimeField(null=True, db_index=True)

    class Meta:
        indexes = [
            models.Index(
                fields=["published_at", "id"],
                name="outbox_unpublished_idx",
                condition=models.Q(published_at__isnull=True),
            ),
        ]

Writing the event

from django.db import transaction


def create_invoice(invoice_data):
    with transaction.atomic():
        invoice = Invoice.objects.create(**invoice_data)

        OutboxEvent.objects.create(
            aggregate_type="invoice",
            aggregate_id=str(invoice.id),
            event_type="invoice.created",
            payload={"id": invoice.id, "total": str(invoice.total)},
        )

    return invoice

No on_commit, no direct broker call. The invoice row and the outbox row commit together, or neither exists.

Relaying

A separate process (Celery beat, a small dedicated worker, or a CDC tool like Debezium reading the WAL) pulls unpublished rows and publishes them:

from django.db import transaction
from django.utils import timezone


def relay_outbox(batch_size=100):
    with transaction.atomic():
        events = (
            OutboxEvent.objects
            .select_for_update(skip_locked=True)
            .filter(published_at__isnull=True)
            .order_by("id")[:batch_size]
        )

        for event in events:
            publish_to_broker(
                topic=event.event_type,
                key=event.aggregate_id,
                payload=event.payload,
                message_id=str(event.id),   # for consumer dedup
            )
            event.published_at = timezone.now()
            event.save(update_fields=["published_at"])

skip_locked lets you run multiple relay workers without them fighting over the same rows.

What you gain

no lost events on broker outage (they sit in the outbox),
no phantom events on rollback (they never hit the outbox),
an auditable history of what was published and when,
a lag metric (unpublished outbox rows and oldest unpublished row age) you can alert on.

What you still owe the consumer side

Consumers must be idempotent. Design every handler so that receiving the same message twice is a no-op. The outbox gives you at-least-once delivery, not exactly-once. The message ID (outbox row PK) is your dedup key.

7. Multiple databases: there is no `atomic` across them

Django supports multiple databases. It does not give you a cross-database transaction. This code is a lie:

# Does NOT make the two writes atomic
with transaction.atomic(using="default"):
    with transaction.atomic(using="analytics"):
        Order.objects.using("default").create(...)
        AnalyticsEvent.objects.using("analytics").create(...)

If the default commit succeeds and the analytics commit fails (or the process dies in between), you have inconsistent state across databases with no automatic recovery.

Practical rules:

keep each business invariant anchored in one database,
if a flow genuinely spans databases, design it as eventual consistency: commit to the source of truth, then propagate via outbox or CDC,
accept that "propagate" means "retry forever until it sticks, with alerts if lag grows".

8. Decision matrix

Pattern	Use when	Avoid when
Plain `atomic`	Single DB write, no external side effects, low business risk	Any side effect leaves the DB
`atomic` + `on_commit`	Side effects must run after commit, brief loss is acceptable, basic retry in place	Loss is genuinely unacceptable
Outbox + idempotent consumers	Billing, inventory, compliance, audit, anything where partial failure is a incident	You have no consumers and never will
Saga / compensation	Long-running workflows across multiple services	Simple CRUD

Do not jump to the bottom of the table by default. Outbox has operational cost: another table, another worker, another dashboard, another runbook. Use it where the business cost of a lost event exceeds that.

9. Production checklist

Before you ship any write path that has side effects, walk through this:

Is every critical write anchored in a single database?
Are all external side effects deferred until after commit (either via on_commit or outbox)?
Are all message consumers idempotent? Do you have a dedup strategy with a concrete key?
Do you track outbox lag (oldest unpublished row age) and retry rate, with alerts?
Do your integration tests include concurrent writers hitting the same row?
Is there a runbook for recovery from a half-commit? Who runs it at 03:00?
Do you have constraints in the DB that catch the failure modes your application logic might miss?
Are long-running operations (HTTP, file I/O) kept out of atomic blocks?

If any answer is "we will add it later", that is the thing that will page you.

Final verdict

transaction.atomic() gives you local transactional correctness inside one database. It does not give you global process consistency. Those are different layers, solved by different tools.

Most "committed but broken" production incidents come from conflating them - trusting one with transaction.atomic(): block to cover a process that actually spans three systems. Treat the database transaction as one small, strict boundary, move every side effect to on_commit at minimum, and reach for the outbox pattern when losing an event is unacceptable.

Get that separation right and a whole class of weird half-state bugs disappears from your backlog.

If this was useful, I write more about Django architecture, backend design, and production consistency at rafalfuchs.dev/en/blog. The original version of this post lives here.

SEO Is Not Enough. What AIO (Generative Engine Optimization) Is and Why Your Company Needs It in 2026

Rafał Fuchs — Thu, 09 Apr 2026 18:59:28 +0000

SEO Is Not Enough. What AIO (Generative Engine Optimization) Is and Why Your Company Needs It in 2026

Google CTR is falling as more users consume answers without clicking. This guide explains AIO/GEO vs SEO and how to prepare your company for visibility in ChatGPT and AI assistants.

The Decision Problem: Is SEO Alone Still Enough in 2026?

If your growth strategy still assumes that winning means getting the click from Google, you are operating on a distribution model built for the previous decade.

In 2026, a growing share of user intent gets consumed inside answer interfaces:

Google AI Overviews
ChatGPT Search
Perplexity
Claude
Gemini

Users get a synthesis and recommendations before they even decide whether to open a link.

SEO is not dead. But SEO alone is no longer a complete solution.

What Changed in Practice (and Why CTR Is Falling)

This is not just a UI refresh. The information consumption model is changing.

In July 2025, Pew Research Center reported that when users see an AI summary in Google, they are less likely to click traditional results and more likely to end the session without visiting a website.

At the same time, OpenAI expanded ChatGPT Search as a full search interface, making it broadly available on February 5, 2025.

Operational Conclusion

A portion of traffic and purchase decision-making is shifting from:

“click a result” →
“ask an assistant and choose a recommendation”

SEO vs AIO/GEO: The Architectural Difference

SEO optimizes for indexing, ranking, and clicks.

AIO/GEO optimizes for how models understand and use your data in answers.

Key Difference

SEO → How do we rank higher in SERP?
AIO/GEO → How do we ensure AI reconstructs our offer correctly and recommends us?

In the AI layer, the winner is not always the highest-ranking website—but the one with the clearest semantic structure.

Why Classic SEO Underperforms in Generative Search

Modern websites are optimized for humans and front-end frameworks—not for machine understanding.

For AI models:

Heavy HTML = harder parsing
Dynamic rendering = inconsistent context
Weak relationships = ambiguity

What AI Actually Needs to Answer

What exactly do you sell?
Who is it for?
What are your packages or pricing?
What proves your credibility?
When should someone choose you (and when not)?

SEO answers this indirectly.

AIO/GEO answers this directly.

What AIO/GEO Looks Like in Practice

AIO/GEO is best understood as a data and knowledge distribution layer.

It’s not about more content—it’s about better structured information.

Core Layers

Semantic layer (JSON-LD, Schema.org)
LLM reference layer (llms.txt, extended files)
AI crawler accessibility layer
Observability layer

This makes AIO/GEO an architectural decision, not a content task.

How It Works Under the Hood

1. JSON-LD + Schema.org: Stop Forcing AI to Guess

Without structured data, AI guesses meaning.

With structured data, AI understands relationships:

who
what
for whom
where
under what conditions

This is why AIO starts with a semantic audit, not more blog posts.

2. llms.txt and llms-full.txt: Reference Layer

llms.txt acts as a knowledge capsule for AI systems.

Important:

It’s an emerging convention—not a strict standard like robots.txt.

Extended approach:

llms.txt → summary
llms-full.txt → full structured context

Best used when:

your frontend is heavy
business context is hard to extract

3. AI Crawler Accessibility

AIO fails if bots cannot read your content.

Must Be Verified

robots.txt for:
- OAI-SearchBot
- GPTBot
- ClaudeBot
- PerplexityBot
rendering consistency
metadata (Open Graph, titles, descriptions)
response times

This is baseline infrastructure, not optional.

4. Observability: Does AI Understand You?

Core problem:

You don’t know how AI sees your company.

Solution:

simulate buying-intent prompts
analyze answers
measure visibility

This turns assumptions into measurable data.

Where AIO/GEO Delivers the Highest ROI

Best results appear in decision-stage queries.

High-Impact Segments

B2B SaaS
Expert services / clinics
Local high-ticket services
Niche solutions
Companies with rising CAC from ads

If users ask AI “what should I choose?” → AIO becomes critical.

Trade-Offs: What AIO/GEO Won’t Fix

AIO/GEO will NOT fix:

weak offer
lack of proof
unclear positioning
inconsistent messaging

It improves representation, not business fundamentals.

Second limitation:

no monitoring = lost visibility over time

How to Roll It Out (Without Rebuilding Everything)

You don’t need a full rebuild.

Practical Plan

Run an AI visibility audit
Fix semantic structure
Add reference layer
Verify crawler access
Monitor and iterate (2–4 weeks cycles)

👉 Start here: AiVisible Audit

Where AiVisible Fits

AiVisible focuses on visibility in AI-generated answers, not just rankings.

What It Includes

AI interpretation audit
semantic mapping of your offer
plug-and-play implementation
missed-query analysis
iteration plan based on real prompts

👉 Try: AiVisible Audit

The value is not just traffic—it’s being recommended at decision moment.

How to Measure AIO/GEO Impact

SEO metrics are not enough.

Better Metrics

brand share in AI answers
correctness of descriptions
missed queries vs competitors
time to first recommendation
lead quality from AI channels

Conclusion

SEO is not gone—but it’s no longer the only growth system.

Winners Optimize Both

SEO → indexing & ranking
AIO/GEO → understanding & recommendation

This is a shift in how the web delivers answers.

Final Challenge

Your old SEO will not win here.

Find out how ChatGPT perceives your company today:

👉 AiVisible Audit

A Complete Guide to Django Performance Optimization

Rafał Fuchs — Thu, 09 Apr 2026 18:56:07 +0000

A Senior-Level Guide to Optimizing Django Applications

A practical, production-focused guide covering ORM pitfalls, SQL performance, caching, API design, architecture, and real-world scaling decisions.

Introduction

Optimizing a Django application is something every production system eventually faces. Early on, everything feels fast. As users grow, data expands, and business logic becomes more complex, bottlenecks inevitably appear.

This guide is based on real production issues, code audits, and hands-on experience with systems handling hundreds of thousands of requests per day.

How to Think About Django Optimization

The most common mistake: optimizing blindly.

Django is a high-level framework. Most performance issues don’t come from Django itself, but from architectural decisions.

Before touching the code, answer:

Where exactly is time being lost?
Is the problem:
- CPU-bound
- Database-bound
- I/O-bound
Is the issue constant or dependent on data size?

Rule of thumb: Never optimize anything you haven’t measured.

Application Profiling

Without profiling, optimization is guesswork.

Common Tools

Django Debug Toolbar (local)
django-silk / debug toolbar on staging
SQL query logging
APM tools:
- New Relic
- Datadog
- Sentry Performance

What to Measure

Number of SQL queries per request
Execution time of queries
Serialization time
View rendering time

ORM and SQL Query Optimization

Django ORM is powerful—but easy to misuse.

Eliminating the N+1 Problem

Classic issue in Django apps.

Symptoms

Looping over objects
Each related object access triggers a query

Solutions

select_related() → ForeignKey / OneToOne
prefetch_related() → ManyToMany / reverse FK
Prefetch() with custom querysets

Rule: Any query inside a loop = performance bug.

Limiting Retrieved Data

Model.objects.all() is often excessive.

Techniques

only() / defer() for wide models
Explicit fields in serializers
Separate lightweight read models

Benefits

Faster serialization
Lower memory usage
Reduced latency

Database Indexes

Missing indexes = silent performance killers.

Focus On

Fields in filter()
Fields in order_by()
Fields used in joins

Decision Rules

Query runs multiple times per second → add index
Table > 100k rows → regular index audits

Cache as an Architectural Component

Cache is not an add-on. It’s part of system design.

View-Level Cache

Best for:

Public endpoints
Rarely changing data
Dashboards / reports

Tools

cache_page
Reverse proxies (Varnish, CDN)

Data-Level Cache

Most flexible approach.

Examples

Query results
Aggregations
Expensive computations

Good Practices

Keys based on business parameters
Short TTL + manual invalidation
Redis as production standard

API and Serialization Optimization

APIs often become bottlenecks faster than the database.

Common Problems

Deep serialization trees
“Universal” serializers
No pagination

Solutions

Separate serializers (list vs detail)
Use SerializerMethodField sparingly
Always paginate collections

Rule: Unpaginated endpoints = bug.

Asynchronous Processing and Background Tasks

Not everything belongs in request–response.

Good Async Candidates

Emails
Report generation
External API integrations
Heavy validation

Typical Stack

Celery + Redis / RabbitMQ
Django Q

Requirements

Idempotency
Retry-safe logic

Application Architecture and Performance

Performance often loses to “clean-looking code”.

Common Issues

Fat models
Business logic in serializers
No read/write separation

Better Patterns

Service layer
CQRS (for larger systems)
Read models optimized for use cases

Scaling Django

Django scales well—if designed properly.

Key Elements

Stateless backend
Shared cache (Redis)
Shared storage (S3, GCS)
Load balancers

Decision Rules

More users → horizontal scaling
Slower queries → optimize data, not hardware

When Django Is No Longer Enough

Rare—but possible.

Warning Signs

Ultra-low latency (<50 ms)
Heavy real-time workloads
CPU-heavy request processing

Strategy

Extract critical components
Use microservices only where justified
Keep Django as business core

Summary

Django optimization is a process, not a one-time task.

Core Principles

Measure before optimizing
Treat ORM as a tool—not magic
Cache is foundational
Architecture > micro-optimizations

A well-designed Django application can handle large-scale systems without changing the technology stack.

If you found this useful, you can read the full canonical version here:

django performace optimization

DEV Community: Rafał Fuchs

How to check your brand's visibility in ChatGPT, step by step

Before you start: ChatGPT is two different mechanisms

Step 1: turn off personalisation and work in a clean context

Step 2: ask buying questions, not reputation questions

Step 3: assess the quality of the description, not just presence

Step 4: record the results and calculate Share of Model

What to do when ChatGPT does not recommend you

FAQ

Can I check visibility in ChatGPT for free?

Why does ChatGPT name my company sometimes and not others?

How long does it take to improve visibility in ChatGPT?

Is ChatGPT visibility the same as SEO?

AI visibility monitoring tools: a 2026 review and comparison

What should an AI visibility tool monitor?

A comparison table

Profound - the most mature enterprise option

Otterly.AI - the most accessible for small companies

AthenaHQ - for enterprise with demanding requirements

ZipTie.dev - the Google AI Overviews specialist

Language coverage matters more than the feature list

How to choose - a decision framework

The alternative: manual monitoring with no tooling

Newer entrants: Nightwatch, Keyword.com and Scrunch

FAQ

What data does an AI visibility monitoring tool collect?

How is brand visibility in prompts measured?

Do any tools monitor visibility in languages other than English?

How often do tools check AI answers?

Do AI visibility tools replace SEO tools such as Semrush or Ahrefs?

Are free plans enough to start with?

llms.txt: what it is, why it matters and how to implement it

What is llms.txt?

What does an llms.txt file contain?

An example llms.txt for a B2B company

How to implement llms.txt, step by step

How to implement llms.txt in Next.js

Which AI systems read llms.txt?

Does llms.txt actually work?

FAQ

Is llms.txt mandatory?

Where should the llms.txt file go?

How to check whether AI recommends your company, step by step

Step 1: identify the questions your buyers ask

Step 2: test in ChatGPT

Step 3: check Perplexity

Step 4: Google AI Overviews and Gemini

Step 5: compare yourself with competitors

How to interpret the results

The limits of manual testing

What to do after the diagnosis

FAQ

How do I check my company's visibility in ChatGPT?

How do I check brand visibility in Perplexity?

How many questions do I need to measure AI visibility?

Can I improve my company's AI visibility myself?

What does it mean if AI does not recommend me?

Transaction boundaries in Django: where consistency really ends

The illusion atomic() creates

1. What atomic() actually guarantees

2. ATOMIC_REQUESTS: a sharp tool, not a default

3. The minimum viable guardrail: transaction.on_commit

4. Isolation levels and the race conditions you are not seeing

4a. Pessimistic locking with select_for_update

4b. Optimistic locking with a version column

4c. Database constraints as the last line of defence

5. The moment you cross a process boundary, there is no global transaction

6. The outbox pattern, concretely

Schema

Writing the event

Relaying

What you gain

What you still owe the consumer side

7. Multiple databases: there is no atomic across them

8. Decision matrix

9. Production checklist

Final verdict

SEO Is Not Enough. What AIO (Generative Engine Optimization) Is and Why Your Company Needs It in 2026

SEO Is Not Enough. What AIO (Generative Engine Optimization) Is and Why Your Company Needs It in 2026

The Decision Problem: Is SEO Alone Still Enough in 2026?

The illusion `atomic()` creates

1. What `atomic()` actually guarantees

2. `ATOMIC_REQUESTS`: a sharp tool, not a default

3. The minimum viable guardrail: `transaction.on_commit`

4a. Pessimistic locking with `select_for_update`

7. Multiple databases: there is no `atomic` across them