final blog updates

Author: Tom Gotsman

blog/build-dashboard-python-without-javascript.md

@@ -4,7 +4,7 @@ date: 2026-04-02
 title: "How to Build a Dashboard in Python Without Writing Any JavaScript (April 2026)"
 title_tag: "Build Python Dashboards Without JavaScript (2026)"
 description: "Learn how to build production dashboards in pure Python without JavaScript using Reflex. Real-time updates, 60+ components, one-command deploy. April 2026."
-image: https://d4bkhhmrfehmf.cloudfront.net/media/329d6193-80f9-494b-92c2-dafa55322572/hfUb_Spo99XIzJpdXweVx.jpg
+image: /blog/build-dashboard-python_thumbnail.webp
 tag: Builder
 meta: [
   {"name": "keywords", "content": "make a dashboard in python, how to make a dashboard in python"}
@@ -46,7 +46,7 @@ You compose dashboards from 60+ built-in components: charts, tables, forms, butt
 ## The JavaScript Problem With Traditional Dashboard Development
 
 ```python eval
-rx.el.div(image_zoom(rx.image(src="https://d4bkhhmrfehmf.cloudfront.net/media/329d6193-80f9-494b-92c2-dafa55322572/8DrusKNmSipkY4yFDvjwT.png", border_radius="10px", alt="A split-screen visualization showing two contrasting developer workspaces. On the left side, a clean organized Python development environment with pandas dataframes, numpy arrays, and Python code on monitors, using cool blue and green tones. On the right side, a chaotic jumbled workspace with tangled connections between React components, JavaScript files, npm packages, and DOM elements, using warm orange and red tones. The contrast emphasizes the jarring context switch from Python simplicity to JavaScript complexity. Modern, minimalist illustration style with a professional tech aesthetic.", width="100%")), class_name="mb-4")
+rx.el.div(image_zoom(rx.image(src=f"{REFLEX_ASSETS_CDN}blog/build-dashboard-python_python-vs-javascript.webp", border_radius="10px", alt="Python vs JavaScript developer workspace comparison", width="100%")), class_name="mb-4")
 ```
 
 Dashboard frameworks like [Plotly Dash](https://reflex.dev/blog/reflex-dash/), [Streamlit](https://reflex.dev/blog/reflex-streamlit/), and Flask require JavaScript the moment you need custom interactions. A dropdown filter that updates multiple charts? You're writing JavaScript callbacks. Custom styling beyond basic themes? CSS and potentially React components. Real-time data updates with WebSockets? Back to JavaScript event listeners.
@@ -67,7 +67,7 @@ This creates a difficult context switch. Python developers spend their time writ
 Build a dashboard with Python couldn't be easier with Reflex.
 
 ```python eval
-rx.el.div(image_zoom(rx.image(src="https://d4bkhhmrfehmf.cloudfront.net/media/329d6193-80f9-494b-92c2-dafa55322572/2huyBKMBIR6ip5nipeT_i.png", border_radius="10px", alt="A clean, modern illustration showing a Python dashboard architecture concept. Display a visual flow diagram with three connected layers: at the top, Python class objects representing state (showing data structures like dictionaries and lists), in the middle, Python functions that process and transform data, and at the bottom, dashboard UI components like charts, graphs, and data tables. Use a professional blue and green color scheme. Show data flowing downward through the layers with smooth connecting lines. Include visual representations of bar charts, line graphs, and metric cards. Modern, minimalist style with a technical but approachable aesthetic. No text or letters.", width="100%")), class_name="mb-4")
+rx.el.div(image_zoom(rx.image(src=f"{REFLEX_ASSETS_CDN}blog/build-dashboard-python_dashboard-architecture.webp", border_radius="10px", alt="Python dashboard architecture diagram", width="100%")), class_name="mb-4")
 ```
 
 Create a new file called `dashboard.py` and start with state. Your dashboard needs data and variables that track user interactions, so define them as a Python class.
@@ -201,7 +201,7 @@ Pure Python dashboards work best when domain expertise matters more than fronten
 ## Building Production-Grade Dashboards in Pure Python With Reflex
 
 ```python eval
-rx.el.div(image_zoom(rx.image(src="https://d4bkhhmrfehmf.cloudfront.net/media/329d6193-80f9-494b-92c2-dafa55322572/EA8gwtgJI1-26kHBQCo_Y.png", border_radius="10px", alt="reflex.png", width="100%")), class_name="mb-4")
+rx.el.div(image_zoom(rx.image(src=f"{REFLEX_ASSETS_CDN}blog/build-dashboard-python_reflex.webp", border_radius="10px", alt="reflex.png", width="100%")), class_name="mb-4")
 ```
 
 Reflex turns Python dashboards into production applications without requiring JavaScript expertise. The framework provides 60+ built-in components for charts, tables, forms, and layouts that you compose using Python functions. Authentication integrates with providers like Okta, Google, and Clerk through simple configuration. Database connections use the Python libraries you already know: SQLAlchemy, psycopg2, or MongoDB drivers. Deploy with `reflex deploy` to get multi-region infrastructure, monitoring, and team collaboration features. Organizations requiring on-premises deployment run the same Python codebase in their own environments.

blog/django-vs-flask-vs-reflex-comparison.md

@@ -4,7 +4,7 @@ date: 2026-04-02
 title: "Django vs. Flask vs. Reflex: Full-Stack Python Framework Comparison (April 2026)"
 title_tag: "Django vs Flask vs Reflex (April 2026)"
 description: "Compare Django, Flask, and Reflex for full-stack Python development. See performance, features, and use cases for each framework in April 2026."
-image: https://d4bkhhmrfehmf.cloudfront.net/media/329d6193-80f9-494b-92c2-dafa55322572/FfQFxOPzRRwas2J8A1ijv.jpg
+image: /blog/django-vs-flask-vs-reflex_thumbnail.webp
 tag: Builder
 meta: [
   {"name": "keywords", "content": "top full stack python frameworks comparison"}
@@ -41,7 +41,7 @@ Python has become a leading language for full stack development because teams al
 ## Django Overview and Core Features
 
 ```python eval
-rx.el.div(image_zoom(rx.image(src="https://d4bkhhmrfehmf.cloudfront.net/media/329d6193-80f9-494b-92c2-dafa55322572/_X1sUZxBt8QDLdH_qrR45.png", border_radius="10px", alt="django.png", width="100%")), class_name="mb-4")
+rx.el.div(image_zoom(rx.image(src=f"{REFLEX_ASSETS_CDN}blog/django-vs-flask-vs-reflex_django.webp", border_radius="10px", alt="django.png", width="100%")), class_name="mb-4")
 ```
 
 Django launched in 2005 and has spent two decades refining the batteries-included approach to web development. The framework ships with an ORM that abstracts database operations, an automatic admin interface for content management, and built-in user authentication. Django remains one of the most widely adopted options for teams building data-intensive applications. Security comes configured by default. Django protects against SQL injection, cross-site scripting, cross-site request forgery, and clickjacking without requiring additional configuration.
@@ -55,7 +55,7 @@ Enterprise teams building user-facing applications benefit from Django's authent
 ## Flask Overview and Core Features
 
 ```python eval
-rx.el.div(image_zoom(rx.image(src="https://d4bkhhmrfehmf.cloudfront.net/media/329d6193-80f9-494b-92c2-dafa55322572/JN-j1VKxsi2Vr5ueUNxea.png", border_radius="10px", alt="flask.png", width="100%")), class_name="mb-4")
+rx.el.div(image_zoom(rx.image(src=f"{REFLEX_ASSETS_CDN}blog/django-vs-flask-vs-reflex_flask.webp", border_radius="10px", alt="flask.png", width="100%")), class_name="mb-4")
 ```
 
 Flask takes the opposite approach. Released in 2010, it provides routing and templating but leaves database management, authentication, and form validation to the developer. This microframework philosophy means you choose your own ORM, select your preferred authentication system, and assemble exactly the components you need. The core library weighs in at roughly 30KB. Flask gives you Werkzeug for WSGI utilities and Jinja2 for templating, then steps back. Want SQLAlchemy for your database? Install it. Need user sessions? Add Flask-Login. This design makes Flask popular for building APIs and microservices where teams want control over every dependency.
@@ -69,7 +69,7 @@ Choose Flask when your team values component selection over convention. Teams wi
 ## Reflex Overview and Core Features
 
 ```python eval
-rx.el.div(image_zoom(rx.image(src="https://d4bkhhmrfehmf.cloudfront.net/media/329d6193-80f9-494b-92c2-dafa55322572/58I3Ex0z0QJ6Z651yH90-.png", border_radius="10px", alt="reflex.png", width="100%")), class_name="mb-4")
+rx.el.div(image_zoom(rx.image(src=f"{REFLEX_ASSETS_CDN}blog/django-vs-flask-vs-reflex_reflex.webp", border_radius="10px", alt="reflex.png", width="100%")), class_name="mb-4")
 ```
 
 Reflex takes a different approach. Django and Flask handle backend logic but require JavaScript frameworks like React or Vue for the frontend. [Reflex](https://reflex.dev) lets you write both sides in Python, compiling Python code into a React frontend automatically. Released in 2023, Reflex has powered over 1 million applications and earned [28,000+ GitHub stars](https://github.com/reflex-dev/reflex). The framework ships with 60+ built-in components, state management through Python classes, and event handlers that modify application state through Python functions. Beyond the built-in library, Reflex lets you wrap and use any React component directly in Python, giving your team access to the entire React ecosystem without writing a single line of JavaScript.
@@ -98,15 +98,15 @@ To compare these three Python frameworks, we looked at a number of key compariso
 ### Performance and Speed Comparison
 
 ```python eval
-rx.el.div(image_zoom(rx.image(src="https://d4bkhhmrfehmf.cloudfront.net/media/329d6193-80f9-494b-92c2-dafa55322572/55tgEddmRPX1zFwz26X5O.png", border_radius="10px", alt="A clean, modern illustration showing three server stacks side by side representing different web frameworks. Left stack shows a robust, full-featured server with multiple layers and components stacked vertically in organized blocks. Middle stack shows a minimal, lightweight server with fewer components and more space between elements. Right stack shows a hybrid architecture with a Python backend connected to a modern frontend layer through flowing data streams. Use a professional tech color palette with blues, purples, and greens. Include visual indicators of speed and performance like glowing connections, data flow arrows, and activity indicators. Minimalist, geometric style without any text or labels.", width="100%")), class_name="mb-4")
+rx.el.div(image_zoom(rx.image(src=f"{REFLEX_ASSETS_CDN}blog/django-vs-flask-vs-reflex_server-stacks.webp", border_radius="10px", alt="Server stacks comparison across Django, Flask, and Reflex frameworks", width="100%")), class_name="mb-4")
 ```
 
 Django with ASGI can handle 3,000 requests per second in production. Flask's lightweight architecture delivers faster response times for simple JSON API responses, where minimal overhead benefits basic request-response cycles. But, raw benchmarks don't tell the full story. Django's ORM adds query overhead versus raw SQL, while Flask's performance varies based on your library choices. Reflex, on the other hand, compiles Python into React, introducing a compilation step during development but delivering standard React performance in production.
 
 ## Architecture and Design Philosophy Comparison
 
 ```python eval
-rx.el.div(image_zoom(rx.image(src="https://d4bkhhmrfehmf.cloudfront.net/media/329d6193-80f9-494b-92c2-dafa55322572/sE9N17m3QoFqwCdlMS3yL.png", border_radius="10px", alt="A clean, modern illustration showing three distinct architectural patterns side by side. Left side shows a structured layered architecture with organized boxes representing models, views, and templates in a vertical stack. Middle shows a flexible, modular design with loosely connected components and building blocks that can be arranged freely. Right side shows a state-driven architecture with a central state container connected to UI components through event flows and automatic updates, depicted with flowing arrows and reactive connections. Use a professional tech color palette with blues, purples, and whites. Minimalist, geometric style without any text or labels.", width="100%")), class_name="mb-4")
+rx.el.div(image_zoom(rx.image(src=f"{REFLEX_ASSETS_CDN}blog/django-vs-flask-vs-reflex_architecture-patterns.webp", border_radius="10px", alt="Architecture patterns comparison across Django, Flask, and Reflex", width="100%")), class_name="mb-4")
 ```
 
 Django enforces an MVT (Model-View-Template) pattern where models define data structures, views contain business logic, and templates render HTML. This opinionated structure means projects follow predictable patterns with consistent locations for authentication logic, database queries, and template inheritance. Flask, though, imposes no architectural pattern, letting you build REST APIs with functional views or structure monoliths around blueprints. This flexibility creates maintenance challenges when developers make inconsistent choices. Only Reflex uses [state-driven architecture](https://reflex.dev/blog/reflex-architecture/) where Python classes define application state, functions modify state through event handlers, and the UI updates automatically when state changes.

blog/streamlit-vs-dash-python-dashboards.md

@@ -3,8 +3,8 @@ author: Tom Gotsman
 date: 2026-04-02
 title: "Streamlit vs. Dash for Python Dashboards: Which One Should You Actually Use? (April 2026)"
 title_tag: "Streamlit vs Dash Python Dashboards April 2026"
-description: "Streamlit vs. Dash for Python dashboards: Compare script reruns vs. callbacks, performance, and production features. Updated April 2026 comparison guide."
-image: https://d4bkhhmrfehmf.cloudfront.net/media/329d6193-80f9-494b-92c2-dafa55322572/ysXRW_wbgIwWTpVNBg32z.jpg
+description: "Streamlit vs. Dash for Python dashboards: Compare script reruns vs. callbacks, performance, and production features."
+image: /blog/streamlit-vs-dash_thumbnail.webp
 tag: Builder
 meta: [
   {"name": "keywords", "content": "streamlit vs dash for python dashboards, streamlit vs dash comparison, streamlit or dash"}
@@ -46,7 +46,7 @@ You've narrowed your Streamlit vs Dash decision down to architecture differences
 ## What Streamlit Does and How It Works
 
 ```python eval
-rx.el.div(image_zoom(rx.image(src="https://d4bkhhmrfehmf.cloudfront.net/media/329d6193-80f9-494b-92c2-dafa55322572/NB6mENf7ZVUXdDTjkmcnd.png", border_radius="10px", alt="streamlit.png", width="100%")), class_name="mb-4")
+rx.el.div(image_zoom(rx.image(src=f"{REFLEX_ASSETS_CDN}blog/streamlit-vs-dash_streamlit.webp", border_radius="10px", alt="streamlit.png", width="100%")), class_name="mb-4")
 ```
 
 Streamlit is an open-source Python framework built for data scientists and analysts who want to turn scripts into interactive web applications without learning frontend development. You write Python, add a few Streamlit commands, and get a working web interface. The framework operates on a script rerun model. Every time a user interacts with a widget (clicking a button, adjusting a slider, typing in a text box), [Streamlit reruns](https://docs.streamlit.io/develop/concepts/architecture/run-your-app) your entire Python script from top to bottom. This approach makes the mental model simple: your script executes linearly, and the UI reflects the current state of that execution.
@@ -60,7 +60,7 @@ The framework integrates naturally with [Python data libraries](https://www.data
 ## What Dash Does and How It Works
 
 ```python eval
-rx.el.div(image_zoom(rx.image(src="https://d4bkhhmrfehmf.cloudfront.net/media/329d6193-80f9-494b-92c2-dafa55322572/4Z8-zlP1HUxCVJsuObQK_.png", border_radius="10px", alt="dash.png", width="100%")), class_name="mb-4")
+rx.el.div(image_zoom(rx.image(src=f"{REFLEX_ASSETS_CDN}blog/streamlit-vs-dash_dash.webp", border_radius="10px", alt="dash.png", width="100%")), class_name="mb-4")
 ```
 
 Dash takes a different architectural approach. Built on Flask, React, and Plotly.js, Dash connects UI components to Python functions through an explicit callback system. You define which component properties trigger updates and which components receive the results. The callback model is stateless. When a user adjusts a dropdown or slider, only the callback functions tied to that specific input execute. The rest of your application stays idle. This contrasts with Streamlit's full script rerun and can be more performant when you have expensive operations that don't need to re-execute on every interaction. Each callback decorates a Python function with `@app.callback`, specifying Input components that trigger the function, Output components that receive return values, and optional State components that pass current values without triggering execution. A dropdown selection might trigger a callback that filters data and returns an updated graph.
@@ -72,7 +72,7 @@ Dash integrates tightly with Plotly's charting library, making it a natural choi
 ## Streamlit's Script Rerun Model Creates Performance Issues
 
 ```python eval
-rx.el.div(image_zoom(rx.image(src="https://d4bkhhmrfehmf.cloudfront.net/media/329d6193-80f9-494b-92c2-dafa55322572/J3zqzVbZbRsnrMjt1Y9ad.png", border_radius="10px", alt="A technical diagram showing a performance bottleneck visualization. On the left side, show multiple stacked server icons or process blocks representing heavy database queries, API calls, and data transformations. In the center, show a narrow bottleneck or hourglass shape representing a constraint. On the right side, show waiting user icons or browser windows. Use a professional color scheme with blues, purples, and reds to indicate stress points. The style should be clean, modern, and minimalist with a focus on conveying system architecture and performance concepts.", width="100%")), class_name="mb-4")
+rx.el.div(image_zoom(rx.image(src=f"{REFLEX_ASSETS_CDN}blog/streamlit-vs-dash_performance-bottleneck.webp", border_radius="10px", alt="Performance bottleneck visualization for dashboard frameworks", width="100%")), class_name="mb-4")
 ```
 
 The rerun model works fine for small scripts that load a CSV and display a few charts. But when you start building real applications with database queries, API calls, or model inference, the architecture becomes a bottleneck.