DEV Community: Amar

How to Make Your Website Visible in AI Search: A Practical GEO Guide

Amar — Sun, 06 Sep 2026 12:50:53 +0000

Getting your website indexed by Google is no longer the whole job.

People now ask ChatGPT, Google AI Overviews, Gemini, Perplexity, and other AI tools questions they previously typed into a traditional search engine. These systems may answer the question directly and cite only a handful of websites.

That creates a second visibility problem for website owners:

Can AI search engines find, understand, and cite your website?

This is where AI search visibility and Generative Engine Optimization (GEO) come in.

If you want a more detailed breakdown of the process, I've also put together a complete AI Search Visibility and Generative Engine Optimization guide covering crawler access, content structure, citations, ChatGPT, Google AI search, and Perplexity.

What Is AI Search Visibility?

AI search visibility is your website's ability to appear as a source, citation, recommendation, mention, or link inside an AI-generated answer.

This is different from simply ranking in traditional search results.

A website could perform well for a query in standard search but still fail to appear when someone asks an AI system a similar question.

For example, imagine you have an article answering:

How do I improve API testing?

A normal search engine may show your article as one of several links.

An AI search experience may instead generate an answer using information retrieved from several sources and cite only a few of them.

Your goal therefore isn't only:

Can my page rank?

You also need to ask:

Can an AI system retrieve and confidently use my page as a source?

What Is Generative Engine Optimization?

Generative Engine Optimization (GEO) is the process of improving content and technical accessibility so generative search systems can discover, understand, retrieve, and potentially cite it.

GEO doesn't mean abandoning SEO.

Traditional SEO still matters because crawlability, indexing, authority, internal linking, useful content, page quality, and technical performance remain important.

The difference is the output you're optimizing for.

Traditional SEO often focuses on:

Query → Search Results → Click → Website

AI search can look more like:

Question → Retrieval → AI-generated answer → Citation → Website

That changes how content should be written and measured.

The Three Layers of AI Search Visibility

I find it easier to think about GEO as three layers:

1. Access

Can the relevant crawler reach the page?

If your robots.txt, firewall, CDN, authentication system, or server configuration blocks retrieval, improving the article itself won't solve the problem.

2. Extractability

Can the system quickly identify a clear answer?

Long paragraphs full of vague references make extraction harder.

Compare this:

It depends on several things, and there are different ways this can work depending on the situation.

with:

Generative Engine Optimization improves how easily AI search systems can discover, understand, and cite website content.

The second sentence works independently. It names the subject and gives a direct answer.

3. Trust

Why should the system prefer your information over another page covering the same topic?

Clear authorship, original experience, supporting evidence, accurate structured data, independent mentions, useful examples, and current information can all help establish context and credibility.

You need all three layers.

Great content that can't be crawled is invisible. Crawlable content with weak answers may be ignored. Clear answers without enough trust may lose to better-supported sources.

Step 1: Check AI Crawler Access

Before rewriting hundreds of articles for GEO, check your technical setup.

Look at your robots.txt, CDN rules, security tools, server configuration, and logs.

Depending on the platform you're targeting, relevant crawlers and search systems can differ.

The important principle is simple:

Don't accidentally block the search or retrieval crawler you expect to discover your content.

This becomes especially important when using broad bot-blocking rules.

A rule designed to reduce unwanted AI crawling can have unintended consequences if you don't distinguish between different crawler purposes.

Also check your actual server logs. A robots.txt file tells you what should be allowed. Logs tell you what is actually reaching the server.

Step 2: Don't Depend Only on Google Indexing

One of the easiest mistakes is assuming:

"I'm indexed in Google, so every AI search engine can find me."

AI search platforms don't all use the same retrieval pipeline.

If AI visibility matters to your website, check your presence across the search ecosystems relevant to the AI products you're targeting.

That can include Google Search Console and Bing Webmaster Tools.

Keep your XML sitemap accurate and make sure important pages aren't accidentally:

noindex
blocked by robots.txt
hidden behind authentication
returning incorrect status codes
buried behind poor internal linking

Technical SEO becomes the foundation for GEO.

Step 3: Write the Answer Immediately

This is one of the easiest improvements you can make.

When a heading asks a question, answer it directly underneath.

For example:

What Is AI Search Optimization?

AI search optimization is the process of making website content easier for AI-powered search systems to discover, understand, retrieve, and cite.

Then expand on the answer.

Don't force the reader or retrieval system through 300 words of introduction before explaining what the section means.

This also improves the article for humans.

Step 4: Make Important Passages Stand on Their Own

AI systems may retrieve a passage rather than interpret your entire article as one block.

That means important passages should make sense without depending heavily on the paragraph before them.

Instead of:

This is why it matters.

write:

Bing indexing matters for AI search visibility when an AI search product relies on Bing's search ecosystem for retrieval.

Instead of:

They can then understand it better.

write:

Clear headings and self-contained answers make the relationship between the question and answer easier to identify.

You don't need to write like a robot.

You simply need to remove unnecessary ambiguity.

Step 5: Match the Format to the Question

Different questions deserve different formats.

For a definition, give a concise definition first.

For a process, use numbered steps.

For a comparison, use a table when it genuinely makes the differences easier to understand.

For a list of options, use bullets.

For technical implementation, include code or configuration examples where they help.

For example, an article targeting:

SEO vs GEO

should probably contain a direct comparison instead of hiding every difference inside long paragraphs.

Area Traditional SEO GEO
Main goal Search visibility and organic clicks Visibility and citations in generated answers
User experience Search results lead to pages AI may answer before a click
Content focus Relevance, quality and ranking Relevance, extractability and citation value
Measurement Rankings, impressions, CTR, traffic Mentions, citations, AI visibility and referral traffic

SEO and GEO overlap heavily. The distinction is useful because the search experience and measurement model are changing.

Step 6: Make Your Entity Clear

An AI system should be able to understand who published the content.

Don't make basic identity information difficult to find.

A serious content site should clearly communicate:

website or company name
author name
what the business or author does
About page
contact information
relevant author experience
publication and update dates

Use consistent naming.

If your homepage calls the business one thing, your schema uses another name, and external profiles use a third variation, you're creating unnecessary ambiguity.

Step 7: Use Structured Data Correctly

Schema markup can help machines understand the page, but adding every possible schema type isn't a GEO strategy.

Use structured data that matches visible content.

Depending on the page, that might include:

Article
Organization
Person
BreadcrumbList
Product
FAQPage where applicable and supported

Don't add claims to structured data that aren't actually visible or true on the page.

Schema should clarify the content, not create a second fictional version of it.

Step 8: Add Evidence Instead of More Keywords

Repeating AI search visibility, GEO SEO, or Generative Engine Optimization twenty extra times won't automatically make an article more citable.

Evidence is more useful.

When appropriate, add:

original examples
test results
screenshots
data
dates
methodology
primary sources
official documentation
relevant research
first-hand experience

Suppose you're writing:

Updating old content improves AI visibility.

That's broad.

A better article explains what was updated, when it was updated, which queries were tested, what changed afterward, and what didn't change.

Specific information gives readers something they can verify.

Step 9: Build Topic Coverage, Not Keyword Variations

Don't create ten weak pages targeting slightly different versions of the same question.

For example:

how to rank in AI search

how to rank website in AI search

how to improve AI search ranking

how to get visibility in AI search

These can easily represent the same underlying intent.

A strong guide can answer the main question and its natural follow-ups:

What is AI search visibility?
What is GEO?
How is GEO different from SEO?
How can AI crawlers access a website?
How should content be structured?
How do you get cited by AI?
How do you measure AI visibility?
Why is a site indexed but not cited?
How do ChatGPT, Google AI search, and Perplexity differ?

That's topical coverage.

Keyword stuffing isn't.

Step 10: Optimize for ChatGPT, Google AI Search, and Perplexity Separately

Don't treat "AI search" as one engine.

The platforms can retrieve, rank, and cite sources differently.

Your common foundation should still be:

crawlability + indexability + useful content + clear answers + trust

Then check platform-specific discovery requirements.

This is also why testing only one prompt in one AI tool doesn't tell you whether your entire GEO strategy works.

For a deeper platform-by-platform explanation, see my complete GEO and AI search visibility guide.

How to Write Content That AI Can Cite

You don't need a special "AI writing style."

Write for people, but make factual sections easy to extract.

A useful pattern is:

Question-based heading

Give the direct answer immediately.

Then explain why.

Add an example.

Support factual claims where evidence is needed.

Link to the next relevant topic.

This gives readers the quick answer while still providing enough depth for someone who wants to understand the subject.

Avoid generic openings such as:

In today's rapidly evolving digital landscape...

They waste space and delay the actual answer.

Start with the information the reader came for.

How to Measure AI Search Visibility

Traditional rank tracking isn't enough because an AI-generated response doesn't behave like a normal SERP.

Create a fixed set of questions that matter to your business.

For example, a software testing company might track:

What are the best API testing tools?

How should a startup automate software testing?

What is the best testing strategy for SaaS?

Then test those questions periodically across the AI search products that matter to you.

Record:

Was your brand mentioned?
Was your page cited?
Which URL was cited?
Which competitors appeared?
What type of page was selected?
Did the answer accurately describe your business?
Did the citation change after a content update?

Don't randomly change the prompts every time. A stable query set makes changes easier to compare.

Common GEO Mistakes

Blocking Crawlers

Excellent content can't be retrieved if access is blocked.

Publishing AI-Generated Filler

Producing hundreds of shallow pages isn't the same as building topical authority.

Keyword Stuffing

A page doesn't become a better source because the target phrase appears in every paragraph.

Copying Competitors

If ten websites contain essentially the same explanation, there's little reason for a retrieval system to prefer the eleventh copy.

Add something useful that isn't already everywhere else.

Ignoring Bing

If you're focused entirely on Google, you may miss another discovery path relevant to AI search.

Treating llms.txt as a Magic Ranking File

Machine-readable files can have specific uses, but don't expect one new file to replace crawlability, indexing, content quality, evidence, and authority.

Changing the Date Without Updating the Article

Freshness should mean the information actually changed.

Update statistics, screenshots, examples, instructions, links, product information, and outdated claims when needed.

A Simple GEO Checklist

Before publishing an important page, check:

Is the URL crawlable?
Is the page indexable?
Can search engines discover it through internal links and the sitemap?
Does the article answer its main question early?
Are important answers self-contained?
Are claims specific and supported?
Is the author clearly identified?
Is structured data accurate?
Does the page add something beyond competitor summaries?
Is the content current?
Have you tested the target questions in relevant AI search products?
Are you measuring citations and mentions as well as Google rankings?

You don't need to rebuild your entire SEO strategy for GEO.

Start with your pages that already receive impressions or target valuable questions. Fix technical access first, improve answer structure second, then strengthen evidence and trust.

If you want the full technical process for AI SEO, ChatGPT SEO, Gemini SEO, Perplexity SEO, crawler access, AI citations, and Generative Engine Optimization, read:

AI Search Visibility: Complete GEO Guide for Websites

The important shift is simple: don't optimize only for whether a page can rank. Make sure the page can also be found, understood, extracted, and trusted when an AI system is deciding which sources to use.

How to Use Gmail With a Custom Domain in 2026

Amar — Sun, 06 Sep 2026 12:35:35 +0000

Yes, you can use Gmail with a custom domain such as you@yourdomain.com. You can either use Google Workspace for a complete business email setup or connect your domain to an existing Gmail account using forwarding and supported sending options.

If you want the complete setup with DNS, MX records, forwarding, and current Gmail limitations, see this guide to using Gmail with a custom domain.

Can I Use a Custom Domain With Gmail?

Yes. If you own a domain and can manage its DNS records, you can create professional addresses such as:

hello@yourdomain.com

support@yourdomain.com

name@yourdomain.com

There are two main approaches: Google Workspace and external email hosting or forwarding.

Google Workspace for Custom Domain Email

Google Workspace is the most direct way to get a full Gmail custom domain account.

Instead of signing in with:

yourname@gmail.com

you can use:

yourname@yourcompany.com

The basic setup involves creating a Google Workspace account, verifying your domain, adding Google's required MX records, and configuring email authentication records such as SPF, DKIM, and DMARC.

This option makes the most sense for businesses that need multiple users, centralized administration, Gmail for business, Calendar, Drive, and other Workspace services.

Can I Use a Custom Domain With a Free Gmail Account in 2026?

You can still combine a free Gmail account with custom-domain email, but you should understand the limitations.

The older POP3-based method described in many tutorials is no longer the right approach for a new 2026 setup. Incoming mail can instead be handled through email forwarding, while outgoing mail requires a compatible sending configuration.

This is an important difference between a true Google Workspace mailbox and simply routing a custom domain email to Gmail.

I explain the current free and paid methods, including what changed with Gmail's POP support, in How to Use Gmail With a Custom Domain.

How Email Forwarding Works

Email forwarding lets messages sent to your professional address arrive in another inbox.

For example:

contact@yourdomain.com → yourname@gmail.com

This is useful for freelancers, developers, portfolio owners, and small websites that don't need a complete business email platform.

Remember that receiving and sending are separate parts of the setup. Forwarding an email to Gmail doesn't automatically mean replies will come from your custom address.

Sending Custom Domain Email From Gmail

Gmail's Send mail as feature can be used with compatible configurations to send messages using another address.

You'll typically need information from your email provider, such as:

SMTP server
SMTP port
username
password
encryption settings

This is your SMTP configuration.

After verification, you can select the custom address from Gmail's From field when composing an email, as long as your configuration and Gmail's current support allow it.

DNS Verification and MX Records

DNS is one of the most important parts of a business email setup.

Domain verification proves that you control the domain.

MX records tell other mail servers where email for your domain should be delivered.

You may also need:

SPF to specify authorized sending servers.

DKIM to cryptographically sign outgoing messages.

DMARC to define how receiving servers should handle authentication failures.

Always use the DNS values provided by your actual email provider. Don't copy MX, SPF, or DKIM records from another domain or an outdated tutorial.

Can I Use Any Custom Domain With Gmail?

Generally, yes, as long as you own or control the domain and have access to its DNS settings.

The domain doesn't necessarily have to be purchased from Google. Domains registered through other registrars can also be connected to Google Workspace or configured with other email services.

Can I Use the Gmail App With a Custom Domain?

Yes.

Google Workspace accounts work directly with the Gmail app using your custom-domain credentials.

Other custom-domain email accounts may also work with Gmail depending on how the underlying email provider and account are configured.

So using Gmail with a custom domain doesn't always mean Gmail itself is hosting your email.

Google Workspace or Email Forwarding?

Choose Google Workspace if you're running a business, need several mailboxes, or want your custom-domain email fully managed through Google's ecosystem.

Email forwarding can work well for a personal website, developer portfolio, side project, or small operation that only needs addresses such as hello@domain.com or contact@domain.com.

Whichever method you choose, test both incoming and outgoing email before using the address publicly.

Also verify your SPF, DKIM, DMARC, MX records, and From address. A message reaching Gmail doesn't necessarily mean the entire email configuration is correct.

For the full step-by-step setup, current 2026 Gmail changes, Google Workspace method, free forwarding option, SMTP details, and troubleshooting, read the complete Gmail custom domain setup guide.

Software Testing Strategies: 8 Practical Ways to Improve Software Quality

Amar — Mon, 31 Aug 2026 16:15:05 +0000

Software teams often test applications without deciding which risks matter most, what should be automated or when testing should begin. This creates unnecessary delays and allows important defects to reach production.

Effective software testing strategies provide a structured plan for testing features, managing risks and maintaining product quality throughout development. A strategy defines what must be tested, which methods should be used, who is responsible and how results will influence release decisions.

The following software testing strategies can help development and QA teams achieve improved software quality without turning testing into a release bottleneck.

1. Begin Testing Early in the SDLC

Software testing should begin while requirements are being discussed, not after development is complete.

The Software Development Lifecycle (SDLC) covers planning, requirements, design, development, testing, deployment and maintenance. Proper SDLC testing integration connects quality checks with every stage of this lifecycle.

During requirement planning, testers can identify:

Missing acceptance criteria
Conflicting business requirements
Invalid input scenarios
Security and permission concerns
Features that may be difficult to test
Dependencies that could affect reliability

Early SDLC testing integration reduces the risk of discovering fundamental problems shortly before release.

2. Use Risk-Based Software Testing Strategies

Not every feature requires the same testing effort. Risk-based software testing strategies prioritize features according to the likelihood and potential impact of failure.

Authentication, payments, personal data, permissions and third-party integrations usually deserve more attention than minor visual preferences.

Teams can evaluate risk by asking:

How likely is this feature to fail?
How many users would be affected?
Could the failure cause data loss or security problems?
Would recovery be difficult or expensive?
Is the feature essential to the main user journey?

This approach helps teams use limited testing time where it provides the greatest value.

3. Combine Manual Testing With Automated Testing Solutions

Manual and automated testing serve different purposes. A reliable strategy uses both instead of treating one as a complete replacement for the other.

Automated testing solutions work well for:

Unit tests
API validation
Regression testing
Repetitive browser checks
Build verification
Stable user workflows

Manual software testing remains valuable for:

Exploratory testing
Usability evaluation
New or rapidly changing features
Unexpected user behaviour
Visual and accessibility reviews

Important Test Automation Benefits include faster feedback, repeatable execution and broader regression coverage. However, automated tests still require maintenance and can produce misleading results when they are poorly designed.

4. Build a Balanced Test Automation Pyramid

One of the most useful software testing strategies is to organise automated tests as a pyramid.

The base contains a large number of fast unit tests. The middle contains fewer integration and service-level tests. The top contains a smaller number of end-to-end tests that validate complete workflows.

A balanced test suite normally includes:

Unit tests for individual functions and components
Integration tests for connected services and databases
API tests for requests, responses and error handling
End-to-end tests for critical user journeys

Depending too heavily on end-to-end testing can make the test suite slow, fragile and expensive to maintain. More unit and integration coverage usually provides faster feedback.

5. Apply Agile Testing Approaches

In an agile software development methodology, development happens through short and repeated cycles. Testing must therefore remain continuous instead of becoming a separate final phase.

Useful agile testing approaches include:

Reviewing acceptance criteria before development starts
Adding testers to sprint-planning discussions
Testing small changes as soon as they become available
Automating stable regression scenarios
Discussing defects during sprint retrospectives
Sharing quality responsibility across the team

These agile testing approaches help teams identify problems while the relevant code and requirements are still fresh.

6. Establish Continuous Quality Assurance

Continuous quality assurance means evaluating product quality throughout planning, development, integration and deployment.

It may include:

Code reviews
Automated test execution
Static code analysis
Security scanning
Performance checks
Deployment monitoring
Production error tracking

This approach turns software testing into an ongoing engineering activity. Developers, testers, product owners and operations teams share responsibility for quality rather than assigning it only to the QA team.

Continuous quality assurance also supports faster releases because smaller problems can be identified before they grow into complex production failures.

7. Include Performance Testing Strategies

An application may pass every functional test and still provide a poor experience when demand increases.

Performance testing strategies evaluate application speed, stability, scalability and resource usage under different conditions.

Common performance tests include:

Load testing to examine expected traffic
Stress testing to identify system limits
Spike testing to measure sudden traffic increases
Endurance testing to detect problems during prolonged use
Scalability testing to assess growth capacity

Effective performance testing strategies should focus on realistic user behaviour and measurable requirements. A vague requirement such as “the page should load quickly” is difficult to test. A defined response-time target under an expected level of traffic is more useful.

8. Learn From Production Failures

Software testing strategies should continue evolving after deployment.

Monitoring data, error logs, analytics and customer-support requests can reveal scenarios that were not covered before release. When a production issue occurs, the team should identify its root cause and add an appropriate regression test.

The feedback cycle should look like this:

Production issue → root-cause analysis → corrective action → regression test → safer future release

This process helps the test suite reflect real user behaviour rather than relying only on assumptions made during development.

Common Mistakes to Avoid

Even well-equipped teams can struggle with software testing when their strategy is unclear. Common problems include:

Testing only after development is complete
Automating unstable or frequently changing features
Measuring success only by the number of test cases
Ignoring security and performance testing
Relying entirely on end-to-end tests
Failing to update regression tests after production incidents
Treating quality as the tester’s responsibility alone

Avoiding these mistakes makes software testing more focused, maintainable and useful.

Final Thoughts

Successful software testing strategies connect risk assessment, early testing, automation, human exploration and production feedback.

Teams should introduce testing throughout the Software Development Lifecycle (SDLC), use automated testing solutions for repeatable checks and apply agile testing approaches during short development cycles. Continuous quality assurance and realistic performance testing strategies further strengthen the release process.

There is no single strategy that works for every product. The right approach depends on application risk, team size, architecture, user expectations and release frequency. Start with the most critical workflows, measure the results and improve the strategy as the product evolves.

For a detailed explanation of software testing strategies, approaches and best practices, read the complete guide:

https://webtrixy.com/software-testing-strategies