update pages

Author: carlosabadia

assets/migration/dark/gradio.svg

@@ -21,6 +21,7 @@
     page_meeting_successfully_booked as page_meeting_successfully_booked,
 )
 from .migration.low_code import low_code_migration_page as low_code_migration_page
+from .migration.no_code import no_code_migration_page as no_code_migration_page
 from .migration.other_ai_tools import (
     other_ai_tools_migration_page as other_ai_tools_migration_page,
 )

assets/migration/dark/tableau.svg

@@ -1,4 +1,4 @@
-from typing import TypedDict
+from typing import NotRequired, TypedDict
 
 import reflex as rx
 import reflex_ui as ui
@@ -9,6 +9,14 @@ class ComparisonItem(TypedDict):
     icon: str
     pros: list[str]
     cons: list[str]
+    description: NotRequired[str]
+
+
+def comparison_description(description: str) -> rx.Component:
+    return rx.el.p(
+        description,
+        class_name="text-m-slate-11 dark:text-m-slate-4 lg:text-sm text-xs font-[475] leading-relaxed lg:px-12 lg:py-6 px-6 py-4 border-r border-m-slate-4 dark:border-m-slate-10 bg-m-slate-1 dark:bg-m-slate-10 border-b",
+    )
 
 
 def comparison_title(title: str, icon: str) -> rx.Component:
@@ -74,7 +82,7 @@ def pros_cons_cards(pros: list[str], cons: list[str]) -> rx.Component:
 def top_title(title: str) -> rx.Component:
     return rx.el.span(
         title,
-        class_name="text-m-slate-12 dark:text-m-slate-3 text-xs leading-[1.5rem] font-medium font-mono border-r border-m-slate-4 dark:border-m-slate-10 lg:px-8 lg:py-3 p-6 bg-secondary-1 dark:bg-m-slate-10 border-t",
+        class_name="text-m-slate-12 dark:text-m-slate-3 text-xs leading-[1.5rem] font-medium font-mono border-r border-m-slate-4 dark:border-m-slate-10 lg:px-12 lg:py-3 p-6 bg-secondary-1 dark:bg-m-slate-10 border-t uppercase",
     )
 
 
@@ -101,6 +109,9 @@ def comparison_cards(
         *[
             rx.fragment(
                 comparison_title(item["title"], item["icon"]),
+                comparison_description(item["description"])
+                if item.get("description")
+                else rx.fragment(),
                 pros_cons_cards(item["pros"], item["cons"]),
             )
             for item in comparison_items

assets/migration/light/gradio.svg

@@ -14,8 +14,8 @@
     title="Switch from Low Code to Reflex",
     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",
-        image="/previews/low_code_migration_preview.webp",
+        description="Switch from Low Code to Reflex - The platform to build and scale enterprise apps in pure Python",
+        image="/previews/index_preview.webp",
     ),
 )
 def low_code_migration_page() -> rx.Component:

assets/migration/light/tableau.svg

@@ -3,73 +3,91 @@
 
 COMPARISON_ITEMS: list[ComparisonItem] = [
     {
-        "title": "Full Control Without the Ceiling",
-        "icon": "CodesandboxIcon",
+        "title": "Architecture and state management.",
+        "icon": "SquareArrowExpand02Icon",
+        "description": 'Streamlit uses a "script rerun" model where every widget change re-executes the entire Python script from top to bottom. Dash uses a callback-based architecture that becomes "callback spaghetti" as apps grow. Gradio is designed specifically for ML model demos. Reflex takes a declarative, state-driven approach where you define state classes and UI components in Python, and changes propagate reactively via WebSockets. Only affected components re-render.',
         "pros": [
-            "Write real Python — no ceiling on what you can build",
-            "Handle custom logic, complex data flows, and performance optimization natively",
-            "Build anything a full-stack app can do",
+            "Your app only updates the parts that changed — no unnecessary reruns, so it stays fast even with large data",
+            "User sessions remember where they are — multi-step workflows, background tasks, and real-time updates all work without extra effort",
+            "The event-driven model keeps your code clean and organized, even as your app gets more complex",
         ],
         "cons": [
-            "Get you to v1 fast, then you hit walls",
-            "Custom logic and complex data flows require ugly workarounds",
-            "Platform limitations dictate what's possible, not your requirements",
+            "Streamlit reruns your entire script every time a user clicks anything, leading to memory leaks and slowdowns that make it unreliable for long-term use",
+            "Dash works fine for small apps, but as they grow the logic gets spread across many separate callback functions with no native support for object-oriented state, making it hard to follow and maintain",
+            "Gradio is built for ML model demos — it's not a general-purpose app framework",
         ],
     },
     {
-        "title": "You Own Your Code",
+        "title": "Real-time and interactivity.",
+        "icon": "ZapIcon",
+        "description": "Streamlit has no server push — real-time or background updates need client polling or workarounds. Dash has no native server-push feature. Gradio's interactivity is limited to input-output pairs for ML model inference. Reflex uses automatic WebSocket sync where state changes on the server instantly propagate to the browser.",
+        "pros": [
+            "Changes on the server show up instantly in the browser — no refresh needed, no extra setup",
+            "Live dashboards, real-time data feeds, and collaborative features just work out of the box",
+            "Fully event-based — your app can react to specific user actions like edits, clicks, and selections as they happen",
+        ],
+        "cons": [
+            "Streamlit can't push updates to the user — nothing happens in the browser until the user clicks something to trigger a full script rerun",
+            "Dash has no built-in way to push live updates — getting real-time data requires workarounds like constant polling or adding custom extensions",
+            "Gradio only handles simple input-in, output-out interactions for ML models — it's not built for apps that need to respond to complex user actions",
+        ],
+    },
+    {
+        "title": "Code structure and maintainability.",
         "icon": "SourceCodeSquareIcon",
+        "description": "Real Reflex projects cut approximately 50% of the code compared to equivalent Dash apps. Reflex's Python class-based state model keeps code organized. In Dash, the callback model fragments logic across scattered decorator functions. In Streamlit, the linear script model breaks down when you need complex page flows or shared state across views.",
         "pros": [
-            "It's your Python code — deploy it anywhere",
-            "Full version control with Git",
-            "Never hostage to a platform's pricing or shutdown",
+            "Clean Python class structure keeps your code organized and easy to follow, even as apps grow to multiple pages and features",
+            "Real projects with complexity use roughly half the code compared to the same app built in Dash",
+            "Teams that tried other Python frameworks found Reflex significantly cleaner to maintain and extend",
         ],
         "cons": [
-            "Your app lives on their infrastructure in their proprietary format",
-            "Vendor lock-in makes migration painful or impossible",
-            "Pricing changes or platform shutdowns put your app at risk",
+            "Dash scatters your logic across many separate callback functions that become harder to trace as the app grows",
+            "Streamlit's simple script approach works at first but falls apart when you need complex page flows or shared state across views",
+            "Gradio's simple interface definitions can't support complex multi-page app structures",
         ],
     },
     {
-        "title": "Python Ecosystem Access",
-        "icon": "PythonIcon",
+        "title": "Customization and UI components.",
+        "icon": "WebDesign01Icon",
+        "description": "Streamlit has a customization ceiling — deep CSS or HTML tweaks are difficult, and building truly bespoke widgets requires writing a Streamlit Component in React and TypeScript. Dash has a robust set of components but custom ones still require React. Gradio's customization is similarly limited. Reflex lets you wrap any React component directly from Python with fine-grained CSS control.",
         "pros": [
-            "Use libraries you already know — pandas, scikit-learn, whatever",
-            "Build internal tools or customer-facing apps in one language",
-            "Leverage the entire Python ecosystem with no restrictions",
+            "No limits on what you can build — use any React component in pure Python with full control over styling and layout",
+            "Complete design flexibility without ever leaving the Python ecosystem",
         ],
         "cons": [
-            "Limited to the platform's pre-built integrations",
-            "Can't tap into Python's ML, data science, or backend libraries",
-            "Forces non-JS developers to learn new tools or work around limitations",
+            "Most low-code Python frameworks offer very basic layout and styling options with little flexibility",
+            "Lack of customization is one of the most commonly cited frustrations across low-code Python tools — building anything beyond the default look typically requires dropping into React, TypeScript, or JavaScript",
         ],
     },
     {
-        "title": "Scales With Complexity",
-        "icon": "SquareArrowExpand02Icon",
+        "title": "Built-in functionality.",
+        "icon": "Settings01Icon",
+        "description": "Streamlit and Dash both lack built-in essentials for production apps — no auth, background tasks, or ORM. Gradio is focused narrowly on ML model demos. Reflex ships with ORM, database migrations, background jobs, file uploads, and role-based auth out of the box.",
         "pros": [
-            "Auth flows, real-time features, complex state management — all native",
-            "Handles growing complexity because it's just code",
-            "No artificial boundaries on what you can build",
+            "Authentication, database management, background jobs, file uploads, and role-based access all come built in",
+            "Everything you need to go from prototype to production without stitching together a patchwork of separate tools",
+            "SSO and user management are included — no third-party libraries or workarounds needed",
         ],
         "cons": [
-            "Great for simple CRUD apps and dashboards, then it breaks down",
-            "Once you need real complexity, you're fighting the tool instead of building",
-            "Workarounds pile up and become unmaintainable",
+            "Streamlit has no built-in auth, database access, or background processing — even simple things like a loading button require workarounds",
+            "The Dash open-source package has no auth, no background tasks, and no database layer — each one needs a separate library",
+            "Gradio is focused narrowly on ML demos and lacks general-purpose app features entirely",
         ],
     },
     {
-        "title": "Team Collaboration & Engineering Practices",
+        "title": "Deployment and the prototype-to-production gap.",
         "icon": "UserSwitchIcon",
+        "description": "Low-code Python frameworks are good for getting a first version up quickly, but not designed to take apps to production. Streamlit apps hit out-of-memory errors under load. Open-source Dash runs on Flask and requires manual infrastructure setup. Gradio struggles to scale for production. Reflex compiles to a FastAPI backend with a React frontend — production-ready and container-friendly from day one.",
         "pros": [
-            "Fits into normal engineering workflows — Git, PRs, CI/CD",
-            "Code review and automated testing work out of the box",
-            "Your whole team can collaborate using standard dev practices",
+            "Compiles to a FastAPI backend with a React frontend on an async web server — production-ready and container-friendly from the start",
+            "Fits into Git, pull requests, automated testing, and CI/CD from day one — no separate production rewrite needed",
+            "What you build is what you ship — you're in production without having to rebuild",
         ],
         "cons": [
-            "Version control is difficult or impossible",
-            "Code review and testing are afterthoughts at best",
-            "Engineering best practices don't apply to proprietary drag-and-drop formats",
+            "All low-code tools are seen as prototyping tools — teams build a first version, then have to rebuild the real thing from scratch when it's time to ship to production",
+            "Streamlit apps hit out-of-memory errors under load with even moderately large datasets, and its rerun model fundamentally limits production scalability",
+            "Open-source Dash runs on Flask and requires manual infrastructure setup to scale",
         ],
     },
 ]
@@ -78,10 +96,14 @@
 def compare():
     return common_compare(
         kicker="Compare",
-        heading_lines=["How You Benefit ", "With Reflex vs. ", "Other Approaches"],
-        description="No-code tools get you started fast, but Reflex lets you finish. Here's how Reflex compares to platforms like Retool, Streamlit, Plotly Dash, and Power BI.",
+        heading_lines=[
+            "How You Benefit ",
+            "With Reflex vs. ",
+            "Streamlit, Dash, Gradio",
+        ],
+        description="Streamlit, Dash, and Gradio get you prototyping fast. Reflex lets you finish. Here's how Reflex compares to the leading low-code Python frameworks.",
         top_left_title="Reflex",
-        top_right_title="Retool, Streamlit, Plotly Dash, Power BI",
+        top_right_title="Streamlit, Dash, Gradio",
         comparison_items=COMPARISON_ITEMS,
     )