Launching Rankly: The Website Visibility Engine for SEO, AEO & GEO
Today, September 7, 2026, we are launching Rankly — Nyxen's website visibility engine for SEO, AEO, and GEO.
We built Rankly around a straightforward premise: websites should be evaluated using signals we can actually verify, not opaque AI-generated guesses.
For more than two decades, search visibility was governed by a single paradigm. You optimized for keywords, search engines crawled HTML tags, and users clicked ten blue links.
Today, user discovery is fractured across three distinct environments:
- Classic Search (SEO): The structural, technical, and performance hygiene required for search bot engines to crawl, parse, and index pages reliably.
- Answer Engines (AEO): Direct answer modules, featured snippets, and conversational assistants that extract immediate solutions from structured page blocks.
- Generative Engines (GEO): LLM synthesis systems (such as ChatGPT, Perplexity, Claude, and Google Gemini) that assemble answers using Retrieval-Augmented Generation (RAG) and cite authority domains.
When auditing digital platforms and modern web applications across our studio work at Nyxen, we ran into an acute bottleneck: existing auditing suites were built for a search web that no longer exists in isolation. They measure keyword counts and basic meta tags, but provide zero visibility into whether machine agents and retrieval pipelines can interpret brand entities, parse structured knowledge graphs, or extract answers.
Rankly was designed and built by our founder, Yash Shinde, as part of Nyxen's focus on practical developer and web infrastructure products. We built Rankly to give engineers, founders, and technical marketers an evidence-based engine for the modern search landscape.
1. The Core Problem: The Shift Beyond Ten Blue Links
When modern teams deploy web applications, their traffic sources are no longer purely organic search queries clicking through to top SERP positions. A growing volume of informational queries and technical evaluations are answered directly:
- AI Overviews and answer engines synthesize direct solutions at the top of results.
- Conversational AI systems recommend developer tools, software platforms, and companies based on machine-extracted entity contexts.
- Traditional search engines continue to demand uncompromising Core Web Vitals, semantic HTML5 structure, and clean crawl topologies.
Existing auditing tools treat these new modalities either as an afterthought or with hand-waving speculation. Teams are told to "optimize for AI" without any verifiable signal rubric.
We wanted to replace that ambiguity with measurable engineering rigor.
2. Our Design Principle: Deterministic Scoring + Contextual AI Remediation
From the first architectural whiteboard at Nyxen, we established a strict boundary in Rankly between two systems:
Deterministic Analysis Evaluates Findings. Artificial Intelligence Explains Remediation.
Many emerging "AI audit" tools pipe a webpage's raw text directly into an LLM and ask it to assign a letter grade. We rejected that design entirely. Generative language models are inherently non-deterministic and susceptible to prompt variance. An auditing engine whose score fluctuates across consecutive runs without any underlying codebase change cannot be trusted by engineering teams.
In Rankly:
- Our Deterministic Engine executes 40 deterministic checks against the page payload. It inspects HTTP status codes, security headers, canonical bindings, Open Graph protocols, schema graph integrity, document structure, and content extractability. It calculates verified metrics and produces the final pillar scores.
- The Google Gemini API is used strictly as an explanation and remediation layer. It receives the verified findings, contextual code snippets, and page domain context to generate concrete code patches, framework-specific blueprints, and implementation guidance.
Gemini explains findings and provides contextual remediation—it does not determine the numerical score.
3. The Three Pillars of Rankly's Scoring Architecture
Rankly evaluates every audited domain across three calibrated dimensions. Our current production scoring rubric balances technical fundamentals with machine extractability:
┌─────────────────────────────────────────────────────────────┐
│ RANKLY SCORING RUBRIC │
├──────────────────────────┬──────────────────────────────────┤
│ Classic SEO (50%) │ Crawlability, Semantics, Speed │
├──────────────────────────┼──────────────────────────────────┤
│ Answer Engines / AEO (25%)│ Q&A Structure, Extractability │
├──────────────────────────┼──────────────────────────────────┤
│ Generative / GEO (25%) │ Entity Density, Graph Validation │
└──────────────────────────┴──────────────────────────────────┘Pillar I: Classical Technical SEO (50% Weight)
SEO remains the foundation of all web discovery. If search engine crawlers encounter invalid status codes, circular canonical tags, or render blocking, generative engines and answer extractors will never reach the content downstream.
Our deterministic SEO engine evaluates:
- Crawlability & Indexability: HTTP response headers, robots directives, canonical consistency, and clean sitemap discovery.
- Semantic Structure: Single logical h1 hierarchies, descriptive h2/h3 sections, and semantic landmark elements (header, main, article, footer).
- Core Technical Hygiene: Character encoding declarations, viewport scalability, secure asset references, and Open Graph metadata integrity.
Pillar II: Answer Engine Optimization / AEO (25% Weight)
Answer engines look for discrete, high-confidence information units they can lift directly into answer boxes. Rankly evaluates answer structure and extractability using multiple signals, including:
- Question-Oriented Headings: Headings structured around explicit searcher intent (what, why, how, comparing alternatives).
- Direct Answer Blocks: High-density summary definitions and answer paragraphs positioned immediately below target question headings.
- Structured Content Patterns: Ordered steps, comparative data tables, and descriptive definition lists.
- Structured Schema Markup: Validated Schema.org graphs, including FAQPage, HowTo, and Article entities.
Pillar III: Generative Engine Optimization / GEO (25% Weight)
Generative Engine Optimization evaluates how readily modern retrieval and RAG systems can interpret, contextualize, and cite a domain's content.
Rather than making unverifiable claims about black-box LLM training sets, Rankly evaluates concrete signals that improve machine interpretability:
- Entity Clarity & Disambiguation: Unambiguous brand, product, and author declarations that assist retrieval systems in constructing clean knowledge nodes.
- Quotable Assertions & Factual Density: Information-rich statements with clear attribution that retrieval algorithms can select as source citations.
- Schema Graph Topology: Nested JSON-LD structures (Organization, SoftwareApplication, Person, sameAs authority mappings) connecting web entities into verifiable linked data.
4. Engineering Architecture & Security Defenses
Building an audit engine that accepts arbitrary public URLs requires defensive backend architecture. When users request an audit, Rankly executes a distributed pipeline:
User Request (URL)
│
▼
SSRF Guard & DNS Validation
│
▼
Headless Fetch & Pipeline Timeout
│
▼
40 Deterministic Checks Engine (SEO 50% · AEO 25% · GEO 25%)
│
├─────────────────────────────────┐
▼ ▼
Verified Score & Evidence Contextual Remediation Prompt
│ │
▼ ▼
Firestore Audit Record Google Gemini API (Remediation)
│ │
└────────────────┬────────────────┘
▼
Real-Time Audit ReportSSRF Protection & Network Isolation
Accepting user-supplied URLs to fetch on server infrastructure introduces severe Server-Side Request Forgery (SSRF) attack vectors. Our ingestion pipeline enforces strict validation before initiating any outbound connection:
- Resolves target hostnames against DNS and verifies against private IP ranges (
10.0.0.0/8,172.16.0.0/12,192.168.0.0/16,127.0.0.0/8, IPv6 local loopbacks, and cloud metadata addresses such as169.254.169.254). - Restricts protocols strictly to
http:andhttps:. - Enforces strict socket timeouts and maximum payload thresholds to defend against slowloris and denial-of-service fetch stalls.
Reproducible Scoring
A recurring question during early development was: *“If I run an audit twice, will I get the exact same score?”*
Our technical answer is precise: For the same captured inputs and scoring rubric version, Rankly produces a reproducible score.
Because runtime-dependent signals (such as fluctuating origin server response times, CDN cache states, or dynamic server responses) can naturally vary across fetches, Rankly versions both its scoring formula and snapshot metadata. This guarantees that audit histories reflect genuine technical progressions over time.
5. What Rankly Taught Us
Building Rankly reinforced several engineering principles that now guide Nyxen's broader studio roadmap:
- Separating Deterministic Code from AI Reasoners Creates Trust: When software produces a number, developers want to see the arithmetic. By keeping our 40 checks strictly deterministic and using Google Gemini purely for remediation advice, our outputs remain auditable, defensible, and free of grading hallucinations.
- Real-World Web Payloads Are Incredibly Messy: Real websites have broken nested HTML, malformed JSON-LD scripts, unescaped characters, and contradictory meta tags. Building parsers that fail gracefully without breaking the pipeline required extensive unit testing across diverse production web payloads.
- Actionability Beats Data Vomit: Most auditing tools provide hundreds of warnings without context. Prioritizing remediation by weight—giving engineers the exact code snippets they can drop into Next.js or Astro templates—converts an audit from a vanity report into an immediate sprint item.
6. Rankly Is Now Live
Rankly officially launched publicly on September 7, 2026.
Starting today, anyone can run a comprehensive visibility audit on any public website:
- Run Public Audits: Inspect your website across the complete SEO, AEO, and GEO triad.
- Inspect Evidence-Backed Findings: Review pass, warning, and failure states across all 40 deterministic checks.
- Receive Contextual Remediation: Get AI-assisted code blueprints and architectural fixes tailored to your framework.
- Track Progress Over Time: Measure how structural changes improve your domain's machine readability.
Explore the live platform: 👉 [Launch Rankly at rankly.nyxen.in](https://rankly.nyxen.in)
Rankly on Product Hunt
As part of today's launch, we've also introduced Rankly to the builder community on Product Hunt. If you are interested in exploring the platform, testing your web application, and sharing your direct feedback with our team:
👉 [View Rankly on Product Hunt](https://www.producthunt.com/products/rankly)
7. What Lies Ahead
Rankly represents the kind of software we want to build at Nyxen: practical, measurable, and grounded in verifiable evidence.
Over the coming months, our team will be introducing: - Continuous Monitoring & Regression Alerts: Scheduled automated audits with webhook notifications for score drops or broken schema tags. - Synthetic Citation Testing: Automated testing of brand extraction and entity retrieval across target search prompts. - Developer CI/CD Integration: Lightweight GitHub Actions and CLI tools to enforce visibility score thresholds before pull requests merge to production.
Building Rankly reinforced something we care deeply about at Nyxen: software becomes vastly more useful when its results are understandable, measurable, and grounded in evidence.
Test your application today on [rankly.nyxen.in](https://rankly.nyxen.in), check us out on [Product Hunt](https://www.producthunt.com/products/rankly), and let us know what you think.
Nyxen Studio Team
Engineering & Product Publication
Nyxen is an independent product studio founded by Yash Shinde, building practical developer and web infrastructure platforms including Rankly, NyChat, and Venz AI.