Hey Streamlit community! 
I want to share something I’ve been building since January 13, 2026: a full AutoML/MLOps platform built with Streamlit as the main application layer.
After 141 days of development, the project has reached:
-
305 files
-
150,774 total lines in the repository
-
89,464 lines of Python
-
a complete Bronze → Silver → Gold → Model → Prediction → Audit Contract flow
-
scientific integrity checks
-
meta-learning
-
performance benchmarking
-
interactive maps
-
an AI assistant
-
exportable audit artifacts
The project is called OpenCanvas Pro — a Cognitive AutoMLOps Trust Platform.
It started as a question:
How far can Streamlit go if we treat it not as a demo framework, but as the interface layer for a serious ML product?
The answer so far: much further than I expected.
What the platform does
OpenCanvas Pro runs a full machine learning pipeline across multiple training services:
-
Classification
-
Regression
-
Clustering
-
Anomaly Detection
-
Time Series Forecasting
The architecture follows a medallion-style flow:
Bronze → Silver → Gold → Model → Prediction → Audit Contract
Each layer has a clear responsibility:
Bronze preserves the raw dataset as ingested, including CSV/Parquet handling, parsing evidence and initial data health checks.
Silver applies cleaning, missing value handling, optional row/column removal, duplicate detection, outlier treatment, class balancing when applicable and residual data quality checks.
Gold prepares the training matrix with target protection, encoding, scaling, feature engineering, correlation handling and a final ML readiness gate.
Model runs an AutoML tournament using PyCaret, scikit-learn and service-specific logic for classification, regression, clustering and anomaly detection.
Prediction applies the trained model to batch data, performs schema alignment, validates inference risks and exports predictions.
Audit Contract generates a full JSON artifact for every run, making the entire execution traceable: dataset fingerprints, preprocessing decisions, model selection, metrics, checks, predictions, artifacts and runtime evidence.
How Streamlit is used
Streamlit is not just the landing page or a thin frontend here. It is the application shell for the whole workflow.
Some of the Streamlit patterns that became central to the platform:
Multi-tab pipeline architecture
The platform is organized around tabs such as:
-
Data
-
Model
-
Predictions
Each tab represents a stage of the pipeline, and st.session_state carries the active dataset, configuration, contracts, trained model, metrics and artifacts across the full flow.
One of the hardest parts was preventing accidental recomputation. For that, we use fingerprints, hashes and configuration signatures to decide when a layer must be rebuilt and when it can be safely reused.
Guided state management
Streamlit reruns the script on interaction, which is powerful but dangerous in long-running ML workflows.
The solution was to separate:
-
processing state
-
rendering state
-
dataset fingerprints
-
training signatures
-
cached contracts
-
active artifacts
This lets the UI rerender without restarting expensive steps unless the dataset or configuration actually changed.
Real-time training progress
During model training, Streamlit containers show live progress, logs, elapsed time and algorithm-by-algorithm updates.
The user can see the AutoML tournament unfold instead of staring at a frozen screen.
Performance profiling inside the app
We built a custom profiler that records:
-
runtime by pipeline layer
-
memory before/after
-
memory delta
-
rows in/out
-
metadata per transformation
-
training time
-
model tab rendering time
-
cache hits/misses
The profiling results are rendered directly in Streamlit and also stored as benchmark artifacts.
This recently helped us discover that one regression algorithm was consuming most of a 42-minute Standard Build run on a wide one-hot encoded dataset. That led to a new guardrail that skips heavy or numerically unstable algorithms unless expert mode explicitly enables them.
Audit Contract viewer
Each run produces a detailed JSON contract. Some contracts reach thousands of lines.
Streamlit renders these through expandable sections, summaries and download buttons, while keeping the full artifact exportable as JSON.
Scientific Integrity Shield
The platform includes a scientific validation layer that checks for issues such as:
-
data leakage
-
missing values
-
duplicate rows
-
class imbalance
-
outlier risk
-
multicollinearity
-
overfitting
-
underfitting
-
model stability
-
threshold quality
-
calibration quality
-
drift signals
-
metric consistency
-
prediction degeneration
-
anomaly-specific risks
-
clustering-specific risks
-
regression residual risks
The current internal integrity suite already includes 45+ checks, and the roadmap is pushing it beyond 60 with the Time Series Forecasting module.
The results are rendered as cards, radar charts, bar charts, heatmaps and detailed diagnostic sections using Streamlit + Plotly.
AI assistant sidebar
The platform includes an assistant called E.M.I.L.I.A. — short for Engineering and Machine Learning Intelligence Artificial.
She reads the dataset context, quality scores, model metrics, integrity checks and meta-learning history, then provides guidance in plain language.
The goal is to help a non-specialist user understand:
-
what the dataset looks like
-
whether it is ready for ML
-
what risks exist
-
what model strategy makes sense
-
whether the final model can be trusted
This is especially important because the product is aimed at what we call a Citizen Data Manager: someone who understands the business problem, but may not know Python, scikit-learn, PyCaret, SHAP, leakage prevention or model validation theory.
Two Streamlit apps — two different roles
The project currently runs as two separate Streamlit deployments, each with a different purpose.
1. The public landing page
The landing page is a public-facing Streamlit app built with custom HTML/CSS injected through st.html.
It includes:
-
product sections
-
pipeline explanation
-
pricing tiers
-
FAQ
-
technology stack marquee
-
lead capture
-
public demo content
One highlight is an interactive Leaflet.js map of 5,521 Brazilian municipalities, classified by sanitation profile using our clustering pipeline.
The map is embedded directly into the Streamlit landing page through st.html, with a dedicated ?view=snis-map mode that renders the map fullscreen as a standalone page.
The landing page also supports multiple languages: Portuguese, English, Spanish, French, German and Hindi.
2. The local-first platform
The actual AutoML platform runs as a separate local-first Streamlit application.
This is where the full pipeline lives:
Data → Model → Prediction → Audit Contract
The local-first design is intentional. A core principle of the project is data sovereignty: users should be able to run sensitive datasets on their own infrastructure instead of uploading everything to a third-party service by default.
Public demo: SNIS Brazil clustering map
As a public demonstration, we applied the clustering pipeline to public sanitation data from Brazil.
The pipeline generated a classification of all 5,521 Brazilian municipalities into sanitation profiles, then rendered the result as an interactive map.
The goal was to show that Streamlit can support not only model training interfaces, but also public-facing analytical products.
Live demo:
https://opencanvaspro.streamlit.app
Technical challenges we had to solve
1. Streamlit reruns and long ML workflows
The rerun model is elegant, but a full ML pipeline cannot recompute everything on every interaction.
We solved this using:
-
dataset fingerprints
-
preprocessing signatures
-
training signatures
-
cached audit contracts
-
cached Silver/Gold snapshots
-
controlled session state
-
disk-backed cache for expensive artifacts
The user never has to think about cache. The platform decides automatically when reuse is safe and when a fresh computation is required.
2. Cache without compromising auditability
A key design decision: cache should never hide scientific evidence.
If the same dataset and configuration are used again, the platform can safely reuse the contract and record the cache hit.
If the dataset or configuration changes, the cache is not applied.
This gives us faster reruns without compromising the Audit Contract.
3. Performance benchmarking
We added a benchmark layer to measure Data Tab and Model Tab performance.
This helped separate different bottlenecks:
-
data preparation
-
contract generation
-
Silver snapshot
-
model tournament
-
model tab rendering
-
prediction batch validation
One recent finding: in some datasets, the main bottleneck was not Pandas or Streamlit rendering, but the model tournament itself. In a House Prices regression run, one heavy algorithm consumed most of the runtime and produced poor metrics. That led to a regression guardrail for wide one-hot encoded datasets.
4. Parallel training
We also added automatic n_jobs handling.
Quick Build remains conservative for reproducibility.
Standard Build uses automatic parallelism, reserving one CPU and capping workers for safety.
The result is recorded in the Audit Contract:
-
requested workers
-
effective workers
-
detected CPU count
-
parallel execution mode
-
parallel policy
5. File watcher noise
Large artifacts, contracts, model files and reports can create unnecessary reruns.
We reduced this by excluding internal cache and artifact folders from Streamlit’s watcher configuration.
6. Embedding external JavaScript
The Leaflet.js map is not a simple image. It is an interactive HTML/JS artifact embedded directly into Streamlit.
This required careful handling of layout, standalone rendering, fullscreen map mode and landing page integration.
What makes this unusual for a Streamlit project
This is not a notebook demo.
It is becoming a complete AutoML/MLOps product built around:
-
UI orchestration
-
data quality gates
-
model tournaments
-
prediction workflows
-
scientific validation
-
audit contracts
-
explainability
-
meta-learning
-
performance benchmarking
-
public analytical demos
-
AI-assisted guidance
And it is all being built with Streamlit at the center of the experience.
Availability
The platform is currently in final testing and will be available publicly soon as Community Studio: free, no credit card required.
The goal is to provide access to the full auditable pipeline and scientific integrity layer for users who want to experiment, learn and validate machine learning workflows without writing code.
Two professional tiers will follow:
Journey — for users who need continuity, persistence, local/on-premise execution and greater operational capacity.
Enterprise — for organizations requiring governance, SLA contracts, corporate integrations, advanced auditability controls and support.
What’s next
The current roadmap includes:
-
selective Polars migration for heavier Silver/Gold operations
-
Time Series Forecasting integrity checks
-
deeper E.M.I.L.I.A. integration with GraphRAG and Neo4j
-
stronger meta-learning recommendations before training
-
PDF executive reports
-
more performance guardrails for heavy algorithms
-
expanded audit contract summaries
-
improved prediction monitoring
I’m sharing this here because Streamlit made it possible to move very fast without giving up the ambition of building something serious.
There were many hard parts: state management, reruns, long training jobs, cache invalidation, embedded JavaScript, heavy JSON artifacts, model explainability and performance profiling.
But the result has convinced me that Streamlit can be much more than a prototyping tool.
It can be the interface layer for serious data products.
Happy to answer questions about the architecture, state management, st.html, cache design, profiling, or how we structured the AutoML workflow.
Live demo:
https://opencanvaspro.streamlit.app
LinkedIn:
