Transform Python Functions into Production ML Pipelines

Write Python. Add @ops0.step. Forget the infrastructure.

# Your existing ML workflow
import ops0
from sklearn.ensemble import RandomForestClassifier
# Just add decorators - ops0 handles the rest
@ops0.step
def preprocess(data):
    cleaned = data.dropna()
    ops0.storage.save("processed_data", cleaned)
# ops0 detects dependencies automatically
@ops0.step
def train():
    data = ops0.storage.load("processed_data")
    model = RandomForestClassifier().fit(data.X, data.y)
    return model
# Deploy the pipeline
ops0.deploy()
🚀 Pipeline deployed in 4.2s → https://ml-pipeline.ops0.xyz
Build Your First Pipeline → View on GitHub ⭐
5min
from notebook to production pipeline
80%
of data scientist time spent on infrastructure
0
YAML files to write

Everything You Need, Nothing You Don't

@

Pure Python Decorators

Transform any function into a pipeline step with @ops0.step. No YAML, no configs, no new syntax to learn. If you know Python, you know ops0.

🧠

Automatic Dependency Detection

ops0 analyzes your code with AST parsing to detect dependencies automatically. No manual DAG creation, no explicit task ordering required.

📦

Transparent Storage Layer

ops0.storage.save() and ops0.storage.load() handle data passing between steps. Automatic serialization for any Python object, local or distributed.

🐳

Invisible Containerization

Each step becomes an isolated container automatically. ops0 analyzes your imports and builds optimized Docker images with zero configuration.

⚡

Smart Parallel Execution

Automatic parallelization when dependencies allow. Intelligent caching and retry logic. Run locally for development, deploy for production.

📊

Built-in Observability

Real-time pipeline monitoring, step-by-step debugging, and automatic logging. Visual DAG representation generated from your Python code.

Why Data Scientists Love ops0

Finally, an orchestration tool that speaks Python. No YAML, no DAGs, just pure Python magic.

😤

The Painful Status Quo

📋

YAML Hell

Write hundreds of lines of YAML configs. Learn platform-specific syntax. Debug indentation errors that break everything.

🧩

Manual DAG Building

Manually define task dependencies. Draw boxes and arrows. Maintain complex workflow graphs that break easily.

🔧

Infrastructure Babysitting

Configure workers, manage queues, handle scaling. Spend days debugging why your pipeline won't start.

🧠

Context Switching Nightmare

Jump between Python, YAML, UI dashboards, and docs. Lose focus on actual machine learning work.

🎯

The ops0 Experience

🐍

Pure Python

Write normal Python functions. Add @ops0.step. That's it. No YAML, no configs, no new language to learn.

🧠

Automatic Orchestration

ops0 reads your function signatures and builds the optimal execution graph. Dependencies detected automatically.

📦

Invisible Infrastructure

Containers, scaling, monitoring - all handled automatically. Focus on your ML logic, not DevOps complexity.

⚡

Instant Productivity

Transform existing notebooks in minutes. Same Python code works locally and in production. Zero learning curve.

Real Example: ML Training Pipeline

❌ Traditional Approach (Airflow)

# airflow_dag.py (200+ lines)
from airflow import DAG
from airflow.operators.python import PythonOperator

# 50+ lines of DAG configuration...
dag = DAG('ml_pipeline', ...)

# Manual task definitions
extract_task = PythonOperator(
    task_id='extract',
    python_callable=extract_data,
    dag=dag
)

# Manual dependency management
extract_task >> transform_task >> train_task

# Plus YAML configs, Kubernetes manifests...

✅ ops0 Approach (20 lines)

# pipeline.py
import
ops0

@ops0.step
def extract_data():
    data = load_from_db()
    ops0.storage.save("raw_data", data)

@ops0.step
def transform_data():
    data = ops0.storage.load("raw_data")
    clean = preprocess(data)
    ops0.storage.save("clean_data", clean)

@ops0.step
def train_model():
    data = ops0.storage.load("clean_data")
    return train(data)

# ops0 detects dependencies automatically!
Result: 90% less code, automatic dependency detection via AST analysis, transparent data passing with ops0.storage.

Frequently Asked Questions

How does ops0 differ from Airflow, Prefect, or Kubeflow? +
ops0 is purely Python-native with zero configuration. Unlike Airflow (requires YAML DAGs), Prefect (complex setup), or Kubeflow (Kubernetes knowledge), you just add @ops0.step decorators to existing functions. No new syntax, no infrastructure management.
How does ops0.storage work between pipeline steps? +
ops0.storage provides transparent data passing. Use ops0.storage.save("key", data) in one step and ops0.storage.load("key") in another. Works with any Python object - pandas DataFrames, numpy arrays, models, or custom objects. Automatic serialization and namespace isolation per pipeline.
How does automatic dependency detection work? +
ops0 uses AST (Abstract Syntax Tree) analysis to parse your Python code and detect function dependencies automatically. If step B loads data that step A saves, ops0 knows A must run before B. No manual DAG creation required.
Can I develop and test pipelines locally? +
Yes! Use `ops0 run --local` to execute pipelines on your machine with the same code that runs in production. Built-in debugging with `ops0 debug --step stepname` for step-by-step execution. Perfect for development and testing.
How does containerization work automatically? +
ops0 analyzes your imports to generate requirements.txt automatically, then builds optimized Docker containers for each step. Cache layers are reused for faster builds. You never see or write Dockerfiles - it's completely transparent.
What about scaling and parallel execution? +
ops0 automatically identifies steps that can run in parallel based on dependencies. Built-in worker pool and queue system handle scaling. Intelligent retry logic for failures. Each step scales independently based on workload.