Update meta in migration pages

pcweb/meta/meta.py

@@ -256,6 +256,11 @@ def blog_index_jsonld(posts: list[tuple[str, dict]], url: str) -> rx.Component:
     return rx.el.script(json.dumps(data), type="application/ld+json")
 
 
+def faq_jsonld(faq_schema: dict) -> rx.Component:
+    """Create a FAQPage JSON-LD script tag from a pre-built schema dict."""
+    return rx.el.script(json.dumps(faq_schema), type="application/ld+json")
+
+
 def pricing_jsonld(url: str) -> rx.Component:
     """Create SoftwareApplication JSON-LD for the pricing page."""
     data = {

pcweb/pages/migration/low_code/__init__.py

@@ -1,22 +1,70 @@
 import reflex as rx
 
-from pcweb.meta.meta import create_meta_tags
+from pcweb.meta.meta import create_meta_tags, faq_jsonld
 from pcweb.pages.about.views.divider import divider
 from pcweb.pages.migration.low_code.views import compare, explore, hero, quotes
 from pcweb.templates.marketing_page import marketing_page
 
+LOW_CODE_FAQ_SCHEMA = {
+    "@context": "https://schema.org",
+    "@type": "FAQPage",
+    "mainEntity": [
+        {
+            "@type": "Question",
+            "name": "What are the main limitations of Streamlit that Reflex solves?",
+            "acceptedAnswer": {
+                "@type": "Answer",
+                "text": "Streamlit reruns your entire script every time a user interacts with the app, which leads to memory leaks and slowdowns that make it unreliable for long-term use. It also can't push updates to the user — nothing happens in the browser until the user clicks something. Reflex uses an event-driven model with WebSocket sync, so only affected components update and server changes appear instantly in the browser.",
+            },
+        },
+        {
+            "@type": "Question",
+            "name": "How does Reflex compare to Dash for building Python web apps?",
+            "acceptedAnswer": {
+                "@type": "Answer",
+                "text": "Dash scatters logic across many separate callback functions that become harder to trace as your app grows. It also has no built-in auth, background tasks, or database layer. Reflex uses a Python class-based state model that keeps code organized, and real projects typically use roughly half the code compared to an equivalent Dash app.",
+            },
+        },
+        {
+            "@type": "Question",
+            "name": "Is Gradio a good alternative to Reflex for building apps?",
+            "acceptedAnswer": {
+                "@type": "Answer",
+                "text": "Gradio is purpose-built for ML model demos — it's not a general-purpose app framework. It only handles simple input-in, output-out interactions and can't support complex multi-page app structures, real-time features, or production deployment requirements.",
+            },
+        },
+        {
+            "@type": "Question",
+            "name": "Does Reflex support real-time features without extra setup?",
+            "acceptedAnswer": {
+                "@type": "Answer",
+                "text": "Yes. Reflex uses WebSocket sync, so server changes show up instantly in the browser with no refresh and no extra infrastructure. Live dashboards, real-time data feeds, and collaborative features work out of the box — something Streamlit and Dash can't do natively.",
+            },
+        },
+        {
+            "@type": "Question",
+            "name": "Can I deploy a Reflex app to production without rewriting it?",
+            "acceptedAnswer": {
+                "@type": "Answer",
+                "text": "Yes. Reflex compiles to a FastAPI backend with a React frontend on an async web server — production-ready and container-friendly from day one. It fits into Git, pull requests, automated testing, and CI/CD from the start. Low-code tools like Streamlit and Dash are widely seen as prototyping tools that require a separate production rewrite.",
+            },
+        },
+    ],
+}
+
 
 @marketing_page(
     path="/migration/low-code",
-    title="Switch from Low Code to Reflex",
+    title="Switch from Streamlit, Dash & Gradio to Reflex | Python App Framework",
     meta=create_meta_tags(
-        title="Switch from Low Code to Reflex",
-        description="Switch from Low Code to Reflex - The platform to build and scale enterprise apps in pure Python",
+        title="Switch from Streamlit, Dash & Gradio to Reflex | Python App Framework",
+        description="Outgrown Streamlit's rerun model or Dash's callback spaghetti? Reflex gives you declarative state, real-time updates, and production-ready output — in pure Python, from day one.",
         image="/previews/index_preview.webp",
     ),
 )
 def low_code_migration_page() -> rx.Component:
     return rx.el.div(
+        faq_jsonld(LOW_CODE_FAQ_SCHEMA),
         rx.el.div(
             hero(),
             quotes(),

pcweb/pages/migration/no_code/__init__.py

@@ -1,22 +1,70 @@
 import reflex as rx
 
-from pcweb.meta.meta import create_meta_tags
+from pcweb.meta.meta import create_meta_tags, faq_jsonld
 from pcweb.pages.about.views.divider import divider
 from pcweb.pages.migration.no_code.views import compare, explore, hero, quotes
 from pcweb.templates.marketing_page import marketing_page
 
+NO_CODE_FAQ_SCHEMA = {
+    "@context": "https://schema.org",
+    "@type": "FAQPage",
+    "mainEntity": [
+        {
+            "@type": "Question",
+            "name": "Why should I switch from no-code tools like Power BI or Retool to Reflex?",
+            "acceptedAnswer": {
+                "@type": "Answer",
+                "text": "No-code tools get you to a first version fast, but they hit walls on custom logic, complex data flows, and performance. Reflex is built in pure Python, so there's no ceiling — if Python can do it, Reflex can do it. You own your code, deploy anywhere, and never get held hostage by a platform's pricing changes or shutdown.",
+            },
+        },
+        {
+            "@type": "Question",
+            "name": "Does Reflex support vendor lock-in like Power BI and Tableau?",
+            "acceptedAnswer": {
+                "@type": "Answer",
+                "text": "No. With no-code tools, your app lives on their infrastructure in a proprietary format with no way to export or migrate your work. With Reflex, it's your Python code — deploy it on any infrastructure, use full version control, and maintain complete portability.",
+            },
+        },
+        {
+            "@type": "Question",
+            "name": "Can data scientists and ML engineers use Reflex directly?",
+            "acceptedAnswer": {
+                "@type": "Answer",
+                "text": "Yes. Reflex gives you full access to the Python ecosystem — pandas, scikit-learn, or any pip package. Data scientists and ML engineers can build internal tools or customer-facing apps directly without learning JavaScript or being constrained by a drag-and-drop builder's integrations.",
+            },
+        },
+        {
+            "@type": "Question",
+            "name": "How does Reflex handle real-time data compared to Tableau and Power BI?",
+            "acceptedAnswer": {
+                "@type": "Answer",
+                "text": "Reflex is real-time by default. Unlike Tableau and Power BI, which rely on scheduled refreshes and have dataset size limits, Reflex handles CRUD operations, real-time data feeds, and complex state management natively — because it's just code.",
+            },
+        },
+        {
+            "@type": "Question",
+            "name": "Can I take a Reflex app to production without rebuilding it?",
+            "acceptedAnswer": {
+                "@type": "Answer",
+                "text": "Yes. Reflex fits into Git, pull requests, automated testing, and staging environments from day one. What you demo is what you ship — there's no prototype-to-production rewrite phase, which is a common failure point with no-code tools.",
+            },
+        },
+    ],
+}
+
 
 @marketing_page(
     path="/migration/no-code",
-    title="Switch from No Code to Reflex",
+    title="Switch from No-Code to Reflex | Power BI, Tableau & Retool Alternative",
     meta=create_meta_tags(
-        title="Switch from No Code to Reflex",
-        description="Switch from No Code to Reflex - The platform to build and scale enterprise apps",
+        title="Switch from No-Code to Reflex | Power BI, Tableau & Retool Alternative",
+        description="Hit the ceiling with Power BI, Tableau, or Retool? Reflex gives you full Python control, no vendor lock-in, and production-ready apps from day one. No ceiling, no workarounds.",
         image="/previews/index_preview.webp",
     ),
 )
 def no_code_migration_page() -> rx.Component:
     return rx.el.div(
+        faq_jsonld(NO_CODE_FAQ_SCHEMA),
         rx.el.div(
             hero(),
             quotes(),

pcweb/pages/migration/other_ai_tools/__init__.py

@@ -1,22 +1,70 @@
 import reflex as rx
 
-from pcweb.meta.meta import create_meta_tags
+from pcweb.meta.meta import create_meta_tags, faq_jsonld
 from pcweb.pages.about.views.divider import divider
 from pcweb.pages.migration.other_ai_tools.views import compare, explore, hero, quotes
 from pcweb.templates.marketing_page import marketing_page
 
+OTHER_AI_TOOLS_FAQ_SCHEMA = {
+    "@context": "https://schema.org",
+    "@type": "FAQPage",
+    "mainEntity": [
+        {
+            "@type": "Question",
+            "name": "What are the main limitations of Replit and Lovable for enterprise use?",
+            "acceptedAnswer": {
+                "@type": "Answer",
+                "text": "Replit and Lovable generate code that is often fragile, hard for developers to take over, and not production-ready without significant manual finishing work. They're SaaS-only with no on-prem option, lock you into a specific stack, and have no way to integrate with existing codebases or internal services. They also have no audit logging, centralized access control, or organization-wide governance.",
+            },
+        },
+        {
+            "@type": "Question",
+            "name": "How does Reflex differ from AI coding assistants like Claude Code and Cursor?",
+            "acceptedAnswer": {
+                "@type": "Answer",
+                "text": "Claude Code and Cursor are built exclusively for developers and help you write code faster — but they don't provide a framework, deployment, hosting, or app management. Non-technical team members are completely cut out. Reflex is a complete platform: non-technical users build with natural language, developers refine the same codebase, and the AI builder, open-source framework, and hosting are all unified.",
+            },
+        },
+        {
+            "@type": "Question",
+            "name": "Can non-technical users build apps with Reflex?",
+            "acceptedAnswer": {
+                "@type": "Answer",
+                "text": "Yes. Non-technical users can describe what they need in natural language and get a working app — no coding knowledge, Git, terminal commands, or software architecture required. Developers can then refine the exact same codebase when needed, with no handoff gap between prototype and production.",
+            },
+        },
+        {
+            "@type": "Question",
+            "name": "Does Reflex support on-premises deployment for enterprise security requirements?",
+            "acceptedAnswer": {
+                "@type": "Answer",
+                "text": "Yes. The Reflex AI App Builder deploys on-prem, in your private cloud, or in an air-gapped environment so your apps run wherever your infrastructure already lives and your code and data never leave your environment. Replit and Lovable are SaaS-only with no self-hosted option.",
+            },
+        },
+        {
+            "@type": "Question",
+            "name": "What enterprise security and governance features does Reflex include?",
+            "acceptedAnswer": {
+                "@type": "Answer",
+                "text": "Reflex includes prompt security, sandboxed code generation, SSO enforcement on every application, RBAC controls across integrations and users, and full audit logging to your SIEM. Your data is never used for training. It provides a unified governance layer across every app your organization builds — something neither AI app builders like Lovable nor coding assistants like Cursor offer.",
+            },
+        },
+    ],
+}
+
 
 @marketing_page(
     path="/migration/other-ai-tools",
-    title="Switch from Other AI Tools to Reflex",
+    title="Switch from Replit, Lovable & Cursor to Reflex | Enterprise AI App Builder",
     meta=create_meta_tags(
-        title="Switch from Other AI Tools to Reflex",
-        description="Switch from Other AI Tools to Reflex - The platform to build and scale enterprise apps",
-        image="/previews/low_code_migration_preview.webp",
+        title="Switch from Replit, Lovable & Cursor to Reflex | Enterprise AI App Builder",
+        description="AI tools like Replit, Lovable, and Cursor hit production walls fast. Reflex gives your whole team — technical and non-technical — a governed, on-prem-ready Python platform to build and ship.",
+        image="/previews/index_preview.webp",
     ),
 )
 def other_ai_tools_migration_page() -> rx.Component:
     return rx.el.div(
+        faq_jsonld(OTHER_AI_TOOLS_FAQ_SCHEMA),
         rx.el.div(
             hero(),
             quotes(),

pcweb/pages/migration/other_frameworks/__init__.py

@@ -1,22 +1,70 @@
 import reflex as rx
 
-from pcweb.meta.meta import create_meta_tags
+from pcweb.meta.meta import create_meta_tags, faq_jsonld
 from pcweb.pages.about.views.divider import divider
 from pcweb.pages.migration.other_frameworks.views import compare, explore, hero, quotes
 from pcweb.templates.marketing_page import marketing_page
 
+OTHER_FRAMEWORKS_FAQ_SCHEMA = {
+    "@context": "https://schema.org",
+    "@type": "FAQPage",
+    "mainEntity": [
+        {
+            "@type": "Question",
+            "name": "How does Reflex compare to using React with a Python backend like FastAPI or Django?",
+            "acceptedAnswer": {
+                "@type": "Answer",
+                "text": "Traditional stacks require maintaining two codebases in two languages — Python for the backend and JavaScript or TypeScript for the frontend. Every new feature touches both. Reflex lets you build your entire app in pure Python with one codebase to maintain, version control, test, and deploy — no REST glue code, no CORS configuration, no context switching.",
+            },
+        },
+        {
+            "@type": "Question",
+            "name": "Do I need to know JavaScript to build a modern frontend with Reflex?",
+            "acceptedAnswer": {
+                "@type": "Answer",
+                "text": "No. Reflex compiles your Python code into a React frontend automatically. You get a modern, interactive UI without writing any JavaScript. When you need something custom, you can wrap any existing React component directly from Python.",
+            },
+        },
+        {
+            "@type": "Question",
+            "name": "How much faster is building with Reflex compared to a traditional Python and React stack?",
+            "acceptedAnswer": {
+                "@type": "Answer",
+                "text": "Building with Reflex is roughly 5x faster than assembling the same app from a traditional Python and React stack. There's no time spent wiring API endpoints, configuring CORS, setting up build pipelines, or debugging mismatches between the frontend and backend.",
+            },
+        },
+        {
+            "@type": "Question",
+            "name": "Does Reflex include auth, a database ORM, and other production essentials?",
+            "acceptedAnswer": {
+                "@type": "Answer",
+                "text": "Yes. Authentication, ORM, database migrations, real-time sync, background jobs, and file uploads all come out of the box. FastAPI and Flask give you almost nothing built in, and Django's HTML templating isn't suited for modern interactive interfaces.",
+            },
+        },
+        {
+            "@type": "Question",
+            "name": "How does Reflex handle real-time features compared to Django or Flask?",
+            "acceptedAnswer": {
+                "@type": "Answer",
+                "text": "Reflex runs on an async web server with WebSocket sync, handling real-time updates, live data feeds, and high-concurrency traffic natively. Flask is synchronous by default and Django's monolithic architecture creates scaling challenges — neither framework includes built-in real-time capabilities.",
+            },
+        },
+    ],
+}
+
 
 @marketing_page(
     path="/migration/other-frameworks",
-    title="Switch from Other Frameworks to Reflex",
+    title="Switch from React, Django & FastAPI to Reflex | Full-Stack Python Framework",
     meta=create_meta_tags(
-        title="Switch from Other Frameworks to Reflex",
-        description="Switch from Other Frameworks to Reflex - The platform to build and scale enterprise apps",
-        image="/previews/low_code_migration_preview.webp",
+        title="Switch from React, Django & FastAPI to Reflex | Full-Stack Python Framework",
+        description="Tired of maintaining two codebases in two languages? Reflex replaces React + Django/FastAPI with a single pure Python stack — full-stack, production-ready, ~5x faster to build.",
+        image="/previews/index_preview.webp",
     ),
 )
 def other_frameworks_migration_page() -> rx.Component:
     return rx.el.div(
+        faq_jsonld(OTHER_FRAMEWORKS_FAQ_SCHEMA),
         rx.el.div(
             hero(),
             quotes(),