This is Part 4 of a 15-part Apache Iceberg Masterclass. Part 3 covered metadata-driven performance. This article explains how Iceberg handles the problem that has plagued data lakes for over a decade: what happens when your partition strategy needs to change.

Partitioning determines how data is physically organized in storage, and it is the single most impactful factor for query performance on large tables. Get it right and queries skip 95% of the data. Get it wrong and every query scans everything. The problem is that requirements change, data volumes grow, and the partition strategy that worked last year becomes a bottleneck this year.

Table of Contents

1. What Are Table Formats and Why Were They Needed?
2. The Metadata Structure of Current Table Formats
3. Performance and Apache Iceberg’s Metadata
4. Technical Deep Dive on Partition Evolution
5. Technical Deep Dive on Hidden Partitioning
6. Writing to an Apache Iceberg Table
7. What Are Lakehouse Catalogs?
8. Embedded Catalogs: S3 Tables and MinIO AI Stor
9. How Iceberg Table Storage Degrades Over Time
10. Maintaining Apache Iceberg Tables
11. Apache Iceberg Metadata Tables
12. Using Iceberg with Python and MPP Engines
13. Streaming Data into Apache Iceberg Tables
14. Hands-On with Iceberg Using Dremio Cloud
15. Migrating to Apache Iceberg

The Hive Problem: Partitioning Is Permanent

In Hive and other traditional data lake systems, partitions are physical directories. A table partitioned by year and month has a directory structure like:

s3://warehouse/orders/year=2023/month=01/part-0000.parquet
s3://warehouse/orders/year=2023/month=02/part-0000.parquet
...

This design has three fundamental problems:

Changing partitions requires rewriting all data. If a table is partitioned by month and you need daily partitions (because data volume grew and monthly partitions are now too large for efficient queries), you must read every file, re-partition it, and write it back. For a petabyte table, this means a petabyte of compute and I/O, hours of processing, and downtime for consumers.

Users must know the physical layout. Queries must explicitly reference partition columns using the exact partition column names: WHERE year = 2024 AND month = 3. If a user writes WHERE order_date = '2024-03-15', Hive does not recognize that order_date maps to year = 2024, month = 3, and it scans the entire table. This creates a constant burden on users to understand and correctly use the physical layout.

Wrong filters produce silent full scans. There is no error, no warning. The query runs, it just reads every partition. Teams discover the problem only when they notice query times are 50x slower than expected.

How Iceberg Solves This

Iceberg separates the logical partition specification from the physical data layout through two mechanisms: hidden partitioning (covered in Part 5) and partition evolution.

The Partition Spec

Every Iceberg table has a partition spec that defines how source columns map to partition values. The spec does not create directories. Instead, it records partition values as metadata in manifest entries alongside each data file.

-- Create a table partitioned by month
CREATE TABLE orders (
  order_id BIGINT,
  order_date DATE,
  amount DECIMAL(10,2),
  status STRING
) PARTITIONED BY (month(order_date))

When data is written, the engine computes the partition value (month('2024-03-15') = 2024-03) and stores it in the manifest entry for that file. The file itself can live at any path; there is no requirement for a month=2024-03/ directory.

Evolving the Spec

When data volume grows and monthly partitions become too coarse, you change the spec:

ALTER TABLE orders SET PARTITION SPEC (day(order_date))

This is a metadata-only operation. It takes milliseconds. No data is read or rewritten. What happens internally:

1. The current partition spec (Spec 0: month(order_date)) is preserved in the table’s metadata history.
2. A new partition spec (Spec 1: day(order_date)) is set as the active spec.
3. All existing data files retain their Spec 0 partition values in their manifest entries.
4. All new data written to the table uses Spec 1.

The table now contains files with two different partition specs. This is not a broken state. It is the designed behavior.

How Query Planning Handles Multiple Specs

When a query filters on order_date, the engine must correctly prune files regardless of which spec they were written under. Here is the process:

SELECT * FROM orders
WHERE order_date BETWEEN '2023-12-01' AND '2024-01-31'

For Spec 0 files (monthly): The engine translates the date range into month values: 2023-12 and 2024-01. It checks manifest entries with Spec 0 partition values and keeps files where the month partition is either 2023-12 or 2024-01. All other months are skipped.

For Spec 1 files (daily): The engine translates the date range into day values: 2024-01-01 through 2024-01-31. It checks manifest entries with Spec 1 partition values and keeps files where the day partition falls within that range. All other days are skipped.

Result: Both old and new files are correctly pruned using their respective specs. The query returns accurate results from files written under different partition strategies, without the user knowing or caring about the spec history.

Real-World Scenarios

Growing From Monthly to Daily

The most common evolution. A startup begins with monthly partitions when data volume is 10 GB/month. Two years later, data volume is 500 GB/month and monthly partitions produce files too large for efficient processing. Evolving to daily partitions makes new data more granular while old data remains accessible.

Adding a Partition Column

A table partitioned only by date starts receiving queries that heavily filter by region. Adding a partition on region (using bucket(16, region)) improves pruning for those queries:

ALTER TABLE orders SET PARTITION SPEC (day(order_date), bucket(16, region))

Old files remain partitioned by date only. New files are partitioned by both date and region. Queries that filter on date work correctly for both old and new files. Queries that filter on region get pruning benefits only for new files.

Removing a Partition Column

If a partition column becomes irrelevant (e.g., a geographic region is no longer used for filtering), you can evolve the spec to remove it. Old files keep their partition values, but new files are no longer organized by that column. Dremio and other engines handle this transparently during query planning.

What About the Old Data?

After a partition evolution, old data continues to work correctly but may have suboptimal organization. The old monthly files are coarser than the new daily files, meaning queries against historical data scan larger files than necessary.

Two options:

1. Leave it alone. If historical data is queried infrequently, the cost of less-optimal pruning is minimal. This is the zero-effort approach.

2. Compact old data. Run a compaction job that rewrites old files under the new spec. This produces daily-partitioned files for the historical data too, but requires compute resources. Dremio’s automatic table optimization can handle this for tables managed by Open Catalog.

How Other Formats Handle This

Delta Lake’s Liquid Clustering is a different solution to the same problem. Instead of static partitions, it uses adaptive clustering that reorganizes data in the background. The tradeoff: Liquid Clustering requires ongoing background compute, while Iceberg’s partition evolution is a one-time metadata operation with optional follow-up compaction.

Partition evolution is one of the features that makes Iceberg a safe long-term choice. It means the partitioning decision you make today is not permanent. Part 5 covers hidden partitioning, the other half of Iceberg’s partitioning story.

Books to Go Deeper

• Architecting the Apache Iceberg Lakehouse by Alex Merced (Manning)
• Lakehouses with Apache Iceberg: Agentic Hands-on by Alex Merced
• Constructing Context: Semantics, Agents, and Embeddings by Alex Merced
• Apache Iceberg & Agentic AI: Connecting Structured Data by Alex Merced
• Open Source Lakehouse: Architecting Analytical Systems by Alex Merced

Free Resources

• FREE – Apache Iceberg: The Definitive Guide
• FREE – Apache Polaris: The Definitive Guide
• FREE – Agentic AI for Dummies
• FREE – Leverage Federation, The Semantic Layer and the Lakehouse for Agentic AI
• FREE with Survey – Understanding and Getting Hands-on with Apache Iceberg in 100 Pages

This is a submission for the Google I/O Writing Challenge.

I chose the Google Play announcements from Google I/O 2026 because they are not abstract for me.

My name is Alla Kuznetsova. I am an indie developer and the person building Marble Sudoku, a mobile puzzle game where classic Sudoku logic is played with colorful marbles instead of numbers. I publish the game under Luma Play. Luma Play is not a large studio and there is no separate product group behind me; it is my small indie label.

So my main problem right now is not only how to make the game better.
But also how to help the right players find it, and then also analyze their behavior on the application page. This article is my experience working with Google AI and updating the Google Play console from Google.

That is why the Google Play updates felt important. Play Shorts, Ask Play, Gemini-assisted store listings, keyword recommendations, and AI-powered insights inside Play Console all point in the same direction: Google Play is becoming less like a static shelf and more like an active discovery system.

And for a solo indie developer, discovery is everything.

The Part That Immediately Made Sense: Custom Listings by Gemini For Real Search Intent

After reading the announcement, I opened Play Console to see whether these updates were already visible in my real workflow.

They were.

In Grow overview, Play Console showed a very specific recommendation for Marble Sudoku: create a custom store listing for users searching for ‘sudoku.’

Play Console recommends a custom store listing for the ‘sudoku’ search intent.

That was interesting because it was not generic advice like ‘improve your store page.’ It was tied to a concrete search intent.

The console said my app receives significant traffic from searches for ‘sudoku,’ but the conversion rate for that term is lower than the average conversion rate. The suggested action was to create a custom store listing for that term, with a potential conversion-rate impact of +2 percentage points.

This is exactly the kind of recommendation a solo developer can use.

For a big studio, +2pp might be one line in a growth report. For me, it is a test plan.

Marble Sudoku can be understood in several different ways:

• classic Sudoku, but visual
• Sudoku without numbers
• a relaxing logic puzzle
• a color puzzle with rules
• a marble puzzle with a calm feel

Those are different entry points. A Sudoku fan wants to know the logic is real. A casual puzzle player may care more about the look and the feeling. Someone who avoids numbers needs to understand that this is visual, not math-heavy.

A single default store page cannot speak perfectly to all of them.

That is why custom store listings are useful. They let me match the store page to the intent behind the search.

Gemini Makes The Idea Faster, But Not Automatic

From that recommendation, I opened the custom store listing flow. Play Console had already set the target keyword to ‘sudoku.’ The page also showed a Gemini note saying that store listing descriptions had been generated based on that search keyword.

The custom store listing flow is already targeted to the ‘sudoku’ keyword and references Gemini.

That is where the I/O announcement started to feel real.

The flow connected three things that are usually separate:

1. Google Play sees a search opportunity.
2. It suggests a custom listing.
3. Gemini helps draft listing content.

For one developer, this is powerful. I do not have an ASO department. I do not have a dedicated person writing twenty store-page variants. Usually, every experiment costs time and focus.

If Gemini can turn a keyword opportunity into a first draft, that lowers the cost of testing.

And in my session, the generation flow also showed the rough edge: the description could not be generated and Play Console asked me to try again later.

That did not make the feature useless. It made it feel real.

The announcement says AI can help with store listing creation. The developer experience says: yes, but I still need to review, retry, edit, and understand what I am publishing.

That is probably the right relationship with AI in ASO. Not ‘AI replaces positioning,’ but ‘AI helps create more testable versions of positioning.’

Play Shorts Sounds Perfect For My Game, But The Upload Path Confused Me

The I/O update I was most excited about was Play Shorts.

For Marble Sudoku, short vertical video makes immediate sense. The game is easier to understand in motion than in a screenshot.
But when I checked the YouTube videos section in Play Console, the workflow became confusing.

The YouTube videos section says YouTube Shorts and live videos will not be displayed.

The requirements are clear, but the workflow is not. Play Shorts sounds like a portrait short-form video format, while the current YouTube video section says that YouTube Shorts will not be displayed. I understand the idea, but I still could not figure out how to upload the right kind of video.

The connected playlist shows zero videos available for Play.

That is useful feedback, but it still leaves me guessing. Video could be one of the best discovery surfaces for Marble Sudoku, because the game is easier to understand in motion. But for Play Shorts to be useful to indie developers, the upload path needs to be clearer.

Ask Play Changes What Search Means

Another update that stood out to me was Ask Play, Google’s AI-powered discovery experience.

Players usually do not search for games they do not know exist. Almost nobody wakes up and searches for “Marble Sudoku.” They search for intent: a relaxing puzzle, Sudoku without numbers, a beautiful logic game, something calm but still challenging.

That is why Ask Play matters. If Google Play starts understanding what players mean, not only what they type, niche games have a better chance to be discovered.

But it also raises the quality bar. My store listing needs to explain the game very clearly: this is Sudoku logic, with colors and marbles instead of numbers. It is calm, but still a real puzzle. That is not just marketing copy anymore. It is discovery input.

What I Wish Play Console Did Next

Because I already use Gemini API outside Play Console, I can imagine a more complete workflow inside the console itself.

For events, I would love an AI assistant that helps create the full package: cover image, tagline, description, translations, policy checks, and tone variants.

For new builds, I would love AI-assisted release notes. Play Console could ask what changed, or read a structured changelog, and suggest short user-facing update text.

For video, I would love a clearer eligibility explainer. If a playlist has 0 videos available for Play, tell me exactly why: Short, monetized, private, copyrighted, wrong format, or still processing.

These may sound like small workflow improvements, but for a solo developer they matter. AI does not replace strategy for me. It removes repetitive friction around strategy.

My Practical Plan After I/O

After checking the announcements and Play Console, I see these updates as one workflow.

First, I would create a custom store listing for “sudoku” that speaks directly to Sudoku players.

Second, I would create another listing for the “relaxing puzzle” angle.

Third, I would prepare short vertical gameplay videos, even if the Play Shorts path is not fully clear yet.

Fourth, I would keep using Gemini API for event and social creative, but connect those experiments back to Play Console data.

The goal is not to create more content. The goal is to better match player intent with the first thing they see.

My Main Takeaway

My impression after Google I/O 2026 is optimistic, but not blindly optimistic.

Google Play is moving toward active discovery: search intent, AI recommendations, short videos, custom listings, and reporting working together.

For large studios, that gives scale. For solo developers, it gives a chance.

and for solo developers, that chance often looks like automation: one person being able to create the kind of consistent, colorful, multi-channel presence that normally requires a marketing department.

The tools still need clarity. Gemini-assisted listings are promising, but generation can fail. Play Shorts sounds perfect for mobile games, but the relationship between Play Shorts, YouTube videos, preview videos, and unsupported YouTube Shorts is still confusing.

So my takeaway is this:

Google Play’s new discovery tools do not remove the need for ASO thinking. They make ASO more testable.

and for Marble Sudoku, that is enough to be exciting.

I Already Use Gemini, Just Outside Play Console

One reason these announcements caught my attention is that I already use the Gemini API in my own workflow.

I use it to generate visual ideas and covers for Google Play events, social posts, and community updates. I also run a DEV blog for Luma Play, where I share Marble Sudoku updates, screenshots, leaderboard posts, and cozy puzzle moments with my game character: dev.to/lumaplay.

Thanks to Gemini, I can fill my public channels with colorful content instead of leaving them empty between releases. I use it as part of a publishing loop across my site, DEV, X, Micro.blog, Tumblr, Bluesky, Reddit, LinkedIn and other places where players or developers may discover the game.

Micro.blog visual by Gemini:

Reddit visual by Gemini:

This is not AI for novelty. It is AI because a solo developer has repeating creative work every week: event images, post copy, update notes, short captions, store experiments, and localization drafts.

For an indie developer, this kind of automation is not a luxury. It is one of the only realistic ways to compete with media giants that have teams for trailers, social posts, store copy, localization, community updates, and paid creative testing.

So when I see Gemini appear inside Play Console, I do not see it as just a nice demo. I see something that could save hours of repetitive work.

For me, the next natural step would be an AI event workflow inside Play Console: choose the event type, describe what changed, and get a draft package with a cover image, tagline, event description, translations, and a policy checklist.

The same could happen when uploading a new build. Play Console could suggest user-facing release notes from the developer’s changelog.

That would be useful because, to compete with media giants, I need to spend less time rebuilding the same marketing workflow manually and more time improving the game.

Disclosure

I used AI assistance to organize and edit this post. The product experience, critique, screenshots, examples, and final opinions come from my real work on Marble Sudoku and my own review of Play Console.

2027’nin başında pazara sunulacak Samsung Galaxy S27 serisinde “Galaxy S27, Galaxy S27+, Galaxy S27 Pro ve Galaxy S27 Ultra” modellerinin yer alacağı aktarılıyor. Dün 6,47 inç boyutunda 120 Hz OLED ekranla donatılacağı ve entegre S Pen ile gelmeyeceği söylenen Galaxy S27 Pro, Çinli kaynak Ice Universe’e göre Galaxy S27 Ultra ile aynı geniş açı ve ultra geniş açı kameraları (her iki kamerada da yeni sensörler kullanılacağı belirtiliyor) taşıyacak. İki telefon arasında görüntüleme açısından fark yaratan noktanın ise “telefoto” kamera olacağı söyleniyor. Henüz net bir açıklama yok ancak Galaxy S27 Pro’da Galaxy S27 Ultra’ya kıyasla daha az optik yakınlaştırma/zoom sunulabilir.

Samsung Galaxy S27 Pro için yeni kamera detayları paylaşıldı yazısı ilk olarak Teknoloji haberleri – LOG üzerinde yayınlandı.

Introduction

It’s the favorite time of the year, Christmas. It’s Christmas eve night and you remember that you haven’t gotten your special person a gift yet. What do you do? hurriedly you get you phone and go straight to your favorite online shopping platform. You search for the product you want and you find it, only one is remaining in stock ‘I am lucky’ you sigh in relief and click on the buy now button. Immediately you click on the button, a popup appears saying ‘Out of Stock’, I guess you were not so lucky after all. But how did this happen? That is where Online Transactional Processing (OLTP) comes into play. Behind the scenes there was a system that made sure that you were able to see that your product has only one item left in stock and milliseconds later tell you that it is out of stock and at the same time sell the product to the other person who beat you to it. Next time buy your gifts early.
January is hear and the festivities are over. As data analyst working for an online shopping platform, your organization wants to go back in time ( 5 years), know what products sell best during the Christmas season, what regions have the highest sales, total revenues generated and customer trends over the period. How will these be possible? That is where Online Analytical Processing (OLAP) comes into play. With OLAP, you will have a system optimized to enalble you as an analyst perform complex queries and data analysis on these vast amount of data recorded over the past five years.

What is OLTP?

Online Transaction Processing (OLTP) is a type of database system that is designed to manage and process large numbers of short, fast and real-time transaction such as banking operations, online shopping, ATM withdrawals and point-of-sale purchases.

For example: When using an online shopping platform, you select the item you want to buy, add it to a shopping cart, enter your payment details and then click on the ‘buy now’ button. But what exactly happens? behind the system lies an online transactional processing system that verifies your customer account, checks the product inventory to make sure that the product you intend to buy is in stock, records the order, process the payment, updates the stock levels, generates an invoice and sends an order confirmation. Each of these actions must happen quickly and accurately within seconds and milliseconds while thousands if not millions of other users are also shopping at the same time. The OLTP database ensures that the transactions are completed reliably and preventing a situation where a product is sold twice while only one time was in stock.

What is OLAP?

Online Analytical Processing (OLAP) is a type of database system designed for analyzing large amounts of historical and business data to support decision-making, reporting, forecasting and business intelligence. They are optimized to handle complex queries and data analysis across multiple dimensions such as time, region, product or customers.

For example: A a supermarket chain with multiple stores across the country collects all its transactions data including what was sold, when, where and at what price and stores it a data warehouse. Managers and analysts can perform analysis on these data and gather insights such as; comparing total sales across different regions, finding out which products sell the most during weekends vs weekdays and perhaps identifying the best and least performing stores.

So what is the difference between OLTP and OLAP?
OLTP is optimized for executing online database transactions helping you to reliably and efficiently collect and store high volumes of transactional data while OLAP on the other hand is optimized for complex data analysis aiding you in analyzing the stored data and get insights that lead to business decisions and strategies.

Key differences between OLTP and OLAP

The primary purpose of Online Transactional Processing is to process (OLTP) is to process database transactions while Online Analytical Processing (OLAP) is to analyze aggregated data.

1. Data formatting

• OLPT systems are unidimensional and focus on one data aspect. They use relational databases to organize data into tables with each raw representing an entity instance and each column representing an entity attribute.
• OLAP systems store data in multidimensional data models so you can view data from different angles. OLAP databases store data in a cube format where each dimension represents a different data attribute and each of the cell in the cube represents a value or measure for the intersection of the dimensions.

2. Data architecture

• OLTP database architecture prioritizes data write operations. It is optimized for write-heavy workloads and can update high-frequency, high-volume transactional data without compromising data integrity.
• OLAP database architecture prioritizes data read over data write operations allowing analysts to perform complex queries on large volumes of data. Also, availability is low concern as the primary use case is analytics.

3. Performance

• OLTP processing times are in milliseconds or less. OLPT databases manage databases updates in realtime. Updates are fast, short and triggered by you or your users. Stream processing is often used over batch processing.
• With OLAP, processing times can vary from minutes to hours depending on the type and volume of data being analyzed. To update OLAP databases, you periodically process data in large batches then upload the batch to the system all at once. Data update frequency also varies between systems from daily, weekly or even monthly.

4. Requirements

• OLTP requires high amounts of compute power and storage space. This is because of their nature of performing high amounts of transactions and at high speeds. They also store high volumes of data thus requiring a good amount of storage space ranging to gigabytes(GB). OLPT database can be cleared once the data has been moved to a data warehouse.
• OLAP systems act like centralized data storage pulling data from data warehouses, relational databases and other systems. Storage requirements measure from terabytes(TB) to petabytes(PB). Data reads can also be compute intensive thus requiring high performing servers.

When to use OLPT vs OLAP

pick OLTP when your application processes individual transactions that need immediate consistency and fast response times. For example an e-commerce application or banking application that performs high volumes of transactions, has strict requirements where it cannot tolerate temporary inconsistencies and has low-latency point lookups such as user authentications and balance checks.

Choose OLAP when you need to analyze historical data through complex queries that aggregate millions of rows. For example huge multinational organizations that need to perform complex aggregations at scale, analyze historical trend analysis and has dashboard need for visualization and reporting needs for management.

Can OLPT and OLAP be used together?

The answer is yes. OLTP and OLAP systems are often used together in modern data systems where OLTP handles day-to-day business operations while OLAP supports analysis and decision making. For example, a business using OLTP to record customer transactional data in real time an using technologies such as change data capture (CDC) and tools such as Apache Kafka and Debezium they can stream database changes to OLAP systems.

Conclusion

OLTP and OLAP serve complementary but distinct roles in modern data-driven systems. OLTP is optimized for speed,accuracy and reliability while handling real-time transactional operations while OLAP is optimized for complex analysis enabling organizations to explore historical data and gather insights.

“Online Transactional Processing (OLTP) enables you to purchase products online and bank reliably while Online Analytical Processing (OLAP) enables the online shopping platform and banking institutions to perform analysis of you other millions of customers data and provide better services.”

I’ve spent the past few weeks writing about LLMO: how to get cited by AI search engines, which content structures work, what Princeton’s GEO study says about visibility. All useful stuff. One problem: I had no idea whether any of it was actually working.

I was like a chef who obsesses over recipes but never tastes the food. My Google Search Console was immaculate. My LLMO measurement setup? I was literally typing “does ChatGPT know about my site” into ChatGPT and refreshing the page like a teenager checking if their crush liked their post.

Measuring LLMO is a genuinely hard problem, and most people aren’t doing it at all. Here’s what I’ve built: three measurement layers, from “costs nothing” to “costs you a Saturday afternoon of Python.”

The Measurement Gap

In SEO, measurement is a solved problem. Google Search Console shows rankings, impressions, clicks, and CTR for free, updated daily. Ahrefs adds backlink data. SEMrush gives you keyword tracking. Everything is visible.

In LLMO, almost nothing is visible out of the box.

There’s no “AI Search Console.” ChatGPT doesn’t send a weekly email saying “You were cited 47 times!” Perplexity has no creator dashboard. The shift: SEO had rankings (1st through 100th position). LLMO has a binary outcome. You’re either cited or you’re not. And nobody is telling you which.

This gap isn’t just an inconvenience. You can’t improve what you can’t measure, and right now, most content creators are optimizing for AI visibility while flying blind.

Layer 1: GA4 AI Referral Traffic (Free, 5 Minutes)

The easiest measurement you can set up today is tracking AI referral traffic in Google Analytics 4. When an AI search engine cites your site with a clickable link and someone clicks it, GA4 records the source.

Here is the regex pattern I use in a custom channel group:

chatgpt.com|perplexity.ai|claude.ai|gemini.google.com|copilot.microsoft.com|deepseek.com|you.com|meta.ai|poe.com

Go to Admin → Channel Groups → Create, add a new channel with this regex as the session source filter, and name it “AI Search.” You’ll immediately see aggregated traffic from all AI platforms in one view.

A few things to know:

ChatGPT plays nicely. Since late 2025, ChatGPT appends utm_source=chatgpt.com to outbound links. ChatGPT traffic shows up cleanly as chatgpt.com / referral in GA4.

Perplexity is decent. Traffic appears as perplexity.ai / referral, though without UTM tags. Still trackable.

Free-tier ChatGPT is a black hole. Free users often don’t send referrer data due to privacy settings. Their clicks show up as “Direct,” indistinguishable from someone typing your URL manually. Your GA4 numbers are a floor, not a ceiling.

The conversion story is where this gets interesting. Industry data from 2026 shows AI referral traffic converts at 8-12%, compared to 2-3% for traditional Google organic. People who arrive via AI search have already done their research. The AI did it for them. They are further along in the decision process.

I started tracking three weeks ago. My AI referral traffic is still small (single digits daily), but the conversion rate is 3x my organic average. Small sample, but a signal worth watching.

Layer 2: The “Ask Five AIs” Protocol (Free, 30 Min/Month)

GA4 tells you who clicked through. It does not tell you whether AI is mentioning you without linking, or whether it is mentioning you at all.

For that, you need to ask directly. I run this on the first Monday of every month:

Step 1. Write 10-15 prompts related to your niche. Mine include “What are the best resources for AI search optimization?”, “How do I get my site cited by ChatGPT?”, and “LLMO vs SEO differences.”

Step 2. Run each prompt on five platforms: ChatGPT, Perplexity, Gemini, Claude, and Copilot.

Step 3. Record four things per prompt per platform:

• Mentioned? (Yes / No)
• Context (recommendation / comparison / neutral / negative)
• Accuracy of information
• URL provided?

Step 4. Calculate your citation rate. 15 prompts x 5 platforms = 75 checks. Mentioned 20 times? That’s 26.7%.

This takes about 30 minutes with a spreadsheet. It’s manual and tedious, and also the most reliable method that exists today. Automated tools can approximate this, but they can’t replicate the nuance of “was that mention positive or just a passing reference?”

One caveat: LLM responses are non-deterministic. The same prompt can produce different answers on different days. A single check isn’t statistically significant. That is why I track the monthly trend, not individual data points. Three months of data starts showing real patterns.

Layer 3: Automate It With Python (One Saturday)

If you’re an engineer, you can automate the manual protocol with API calls. Hit the OpenAI and Anthropic APIs with your query set, check whether your brand appears in the response, and log results as a time series.

The core logic is simple:

BRAND_VARIANTS = ["your-site.com", "Your Brand", "yourbrand"]
CHECK_QUERIES = [
    "Best tools for [your category]",
    "How to solve [problem you address]",
    "[Your brand] vs [competitor]",
]

def check_openai(query: str) -> dict:
    client = OpenAI()
    response = client.chat.completions.create(
        model="gpt-4o",
        messages=[{"role": "user", "content": query}],
        temperature=0.0,
    )
    answer = response.choices[0].message.content
    mentioned = any(v.lower() in answer.lower() for v in BRAND_VARIANTS)
    return {"platform": "ChatGPT", "query": query, "mentioned": mentioned}

Extend this for Claude and Perplexity, run weekly via cron, dump to CSV. You get a time series of your AI visibility score for about $0.50/week.

The payoff: instead of “I think LLMO is working,” you can say “my visibility went from 12% to 28% after I added structured data.” Numbers beat feelings.

What’s Available in May 2026

If building your own tools isn’t your thing, several commercial platforms now track AI citations:

Otterly.ai is the fastest-growing option, with 10,000+ users since launching in October 2024. It monitors your brand across ChatGPT, Perplexity, Google AI Overviews, and Copilot. Keyword-level citation tracking, competitor benchmarking, and clean dashboards.

Profound sits at the enterprise end. Their published case study with Ramp, where they went from 3.2% to 22.2% AI visibility in one month, is the kind of result that gets budget approved. If you’re a larger organization, this is where you’ll probably land.

Peec AI focuses on brand mention analysis across LLM outputs. Beyond whether you’re cited, it tracks how: what sentiment surrounds your mentions, which prompt patterns trigger citations.

My honest take: for individual creators and small teams, the manual protocol plus a basic Python script gives you 80% of the insight at 0% of the cost. Commercial tools become worthwhile when you’re tracking dozens of keywords across multiple brands and need team dashboards.

The Crawler Signal You’re Probably Ignoring

Here’s a measurement angle most people miss: AI crawler logs.

Your server access logs already record which AI systems are visiting your content. GPTBot (OpenAI), ClaudeBot (Anthropic), PerplexityBot, Google-Extended. They all identify themselves in the User-Agent string.

grep -E "GPTBot|ClaudeBot|PerplexityBot|Google-Extended" 
  /var/log/nginx/access.log | awk '{print $7}' | sort | uniq -c | sort -rn

Pages that get crawled frequently are more likely to appear in AI responses. Pages that never get crawled are invisible. It is an indirect signal, but useful for finding content that AI systems are skipping entirely.

I checked my own logs and found that /blog/ pages get crawled 15x more than my /about/ page. Not shocking, but the gap was wider than I expected.

Building a Measurement Habit

Measurement without action is just data hoarding. Here is the cycle I run:

Weekly (10 min): Check GA4 AI referral dashboard. Note spikes or drops. Compare week-over-week.

Monthly (30 min): Run the five-platform manual protocol. Calculate citation rate. Scan crawler logs for new patterns.

Quarterly (1 hour): Full review. Update query set. Compare citation rate trends. Check whether content changes produced measurable results.

The LLMO Framework provides a structured approach to KPI design if you want a more formal methodology. I reference it when deciding which metrics matter most at different growth stages.

The Punchline

I started measuring my LLMO visibility three weeks ago. My citation rate across five platforms is 14%. Not great. Not terrible. But the important part is that I know the number, and three months from now I’ll know whether it went up or down.

The SEO world figured out measurement twenty years ago. The LLMO world is still in its “checking rankings by Googling yourself” era. The people who build measurement infrastructure now will have a compounding advantage over those who keep guessing.

If you’re still typing your brand name into ChatGPT and squinting at the output, I get it. I was doing the same thing last month. But now I have a spreadsheet, a cron job, and a regex filter in GA4. Less romantic, more informative. I’ll take that trade.

References

• How to Track AI Traffic in GA4
• Best LLMO Tools in 2026
• GEO: Generative Engine Optimization by Aggarwal et al., Princeton / ACM SIGKDD 2024
• LLMO Framework: KPI design and implementation guide

The full playbook (llms.txt patterns, JSON-LD examples, citation-rate KPIs, and ChatGPT/Perplexity/Brave comparison) is in LLMO Practical Guide: Why ChatGPT Ignores Your Website.