A Scalable ML Framework with Monadic Design

Originally published on wisl.dev.

In the world of machine learning, going from research to production is often a painful, time-consuming process. As a developer and ML practitioner, I’ve personally felt this friction: juggling multiple libraries, inconsistent data formats, fragile pipelines, and the perpetual anxiety of things breaking in production.

To solve this, I built a highly scalable, Python-based machine learning framework that streamlines the entire ML lifecycle, from exploration to deployment, using monadic design principles to bring structure, composability, and reliability to the process.

Here’s how it worked and what I learned.

The Problem: ML Pipelines Are a Jungle

A typical ML project might involve:

• Scikit-learn for preprocessing and models
• TensorFlow or PyTorch for deep learning
• Optuna for hyperparameter tuning
• Imbalanced-learn for dealing with skewed data
• XGBoost for gradient boosting
• Seaborn / Matplotlib for visualization

Each tool is great on its own, but stitching them together into a consistent, maintainable workflow? Not so much.

Worse, when it’s time to deploy, you often end up rewriting large chunks of code, manually fixing bugs due to unexpected inputs, or patching over pipeline inconsistencies with brittle logic.

The Vision: Composability + Reproducibility + Resilience

I set out to build a research-to-production machine learning framework with three goals in mind:

1. Composable Components: Each ML step should be a plug-and-play module.
2. Reproducible Pipelines: From notebooks to deployed APIs with zero drift.
3. Production-Grade Safety: No critical crashes from schema mismatches or malformed data.

To achieve this, I drew inspiration from functional programming: specifically, monads.

Monads in ML: Chaining State with Context

In functional programming, a monad is a design pattern that wraps values with context (like logging, errors, or side effects) and allows transformations to be chained without losing that context.

In this ML framework, I designed a custom monadic pattern that revolves around two key entities:

1. DataPod: The State Carrier

The DataPod object acts as the context holder: it contains:

• All relevant datasets (e.g., main, support_df, etc.)
• Intermediate results and derived features
• Any research-time variables (e.g., train/test splits, configuration flags)
• Metadata used across the ML lifecycle

As the pipeline evolves, the DataPod flows from one transformer to the next, getting updated with new data or attributes while keeping the full research state intact.

2. Transformer: The Behavior Capsule

Each Transformer is a composable, stateful function that:

• Transforms the DataPod (e.g., scaling, encoding, feature engineering)
• Stores any trained variables inside itself (e.g., mean, std for scalers; trained models)
• Can later be serialized and used for production inference or pipeline reproduction

This separation of data (in DataPod) and behavior (in Transformer) allows clean chaining of transformations, while also making the pipeline reproducible and deployable.

The flow looks like this: a DataPod (data + state) passes through a series of transformers, each of which learns something during fit and leaves its footprint behind. After the chain completes, the accumulated footprints list is what gets replayed in production.

How It Looks in Code: A Step-by-Step Breakdown

Let’s walk through how the monadic pattern works in this ML framework using simplified Python code.

Step 1: Define your data container

This is the core monadic context. DataPod holds all the data and shared state passed from one transformer to the next.

class DataPod:
    def __init__(self, dfs):
        self.dfs = dfs  # Dictionary of dataframes (main, support, etc.)
        self.metadata = {}  # Optional: Store any global metadata or pipeline state
        self.footprints = []  # Track the sequence of transformers used

    def fit_transform(self, transformer):
        # Call transformer's fit_transform method and pass self (the DataPod)
        transformer = transformer.fit_transform(self)
        self.footprints.append(transformer)  # Record the transformer
        return self

Enter fullscreen mode Exit fullscreen mode

Step 2: Define a base Transformer interface

Each transformer is a self-contained unit that holds any trained variables (e.g., mean, model) and knows how to transform a DataPod.

class TransformerA:
    def fit_transform(self, dp: DataPod):
        # Learn from the data
        self.mean_val = dp.dfs["main"]["feature1"].mean()

        # Optionally store the learned state for deployment
        dp.metadata["mean_val"] = self.mean_val

        return self  # Important: Return self to store in footprints

    def transform(self, dp: DataPod):
        # Apply transformation using learned state
        dp.dfs["main"]["feature1_scaled"] = dp.dfs["main"]["feature1"] / self.mean_val
        return dp

Enter fullscreen mode Exit fullscreen mode

Step 3: Compose the pipeline

You create a DataPod with your raw data and apply transformations in a chainable, declarative way:

import pandas as pd

# Example input data
main_df = pd.DataFrame({"feature1": [100, 200, 300], "target": [1, 0, 1]})
support_df = pd.DataFrame({...})  # Optional

# Initialize the data container
dfs = {"main": main_df, "support_df": support_df}
dp = DataPod(dfs=dfs)

# Compose the pipeline with transformers
dp = (
    dp.fit_transform(TransformerA())
    .fit_transform(TransformerB())
    .fit_transform(TransformerC())
)

# Access outputs
print(dp.dfs["main"].head())
print(dp.metadata)

Enter fullscreen mode Exit fullscreen mode

One of the powerful aspects of this design is the ability to easily compose and reuse sequences of transformations during the research phase. The Serializer class is essentially a convenient way to chain multiple transformers together into a single reusable pipeline, enabling you to apply all transformations in order without repeating code.

Here’s the Serializer class that applies a list of transformers sequentially:

class Serializer:
    def __init__(self, transformers):
        self.transformers = transformers

    def transform(self, dp: DataPod):
        for transformer in self.transformers:
            dp = transformer.transform(dp)
        return dp


pipeline = Serializer(
    transformers=[
        TransformerA(),
        TransformerB(),
        TransformerC(),
    ]
)

dp = dp.fit_transform(pipeline)

Enter fullscreen mode Exit fullscreen mode

Step 4: Reproduce and Deploy the Pipeline with Trained Transformers

One of the key benefits of this monadic design is that each Transformer stores its trained parameters internally (e.g., learned model weights, scaling factors). This means the entire pipeline can be reproduced exactly for deployment, ensuring consistency between research and production environments.

One detail worth calling out: the footprints list is the single artifact you ship. It holds the fitted transformers in application order, so research and production run byte-identical logic with no export/import step in between.

After training, your DataPod keeps a record of all applied transformers in dp.footprints. This list acts as a serialized artifact capturing the entire pipeline’s state.

To deploy the pipeline on new production data, you simply:

1. Initialize a fresh DataPod with the production dataset.
2. Apply the saved transformers (the pipeline footprint) to the new data, using their stored trained parameters.

Here’s how it looks in code:

# Assume dp is the trained DataPod from research with footprints saved
pipeline = dp.footprints  # List of trained Transformer instances

# Initialize DataPod with new production data
dp_prod = DataPod(dfs=data_prod)

# Sequentially apply each trained transformer (using stored trained vars)
dp_prod = dp_prod.transform(pipeline)

# Now dp_prod contains transformed production data ready for inference or downstream tasks

Enter fullscreen mode Exit fullscreen mode

Features at a Glance

The framework grew to support a wide range of ML tasks out of the box:

• Train-Test Splitting, Imputation, Encoding
• Upsampling, Resampling, Cross-validation
• Supervised/Unsupervised Learning, Deep Learning
• Neural Networks, Recommendation Systems
• Natural Language Processing (NLP)

It also included built-in error handling to catch and adapt to common production-time issues, like incompatible data types, schema mismatches, or missing fields, without halting execution.

Results and Benefits

Across our internal projects, the framework cut research-to-deployment time roughly in half and eliminated the “works in the notebook, breaks in production” class of incidents entirely.

• 50% faster development time for research-to-deployment pipelines
• Reproducible pipelines across dev, QA, and production environments
• Zero critical incidents in production due to robust pipeline design
• Scalable architecture that allows team members to add or swap transformers easily

Final Thoughts

What started as a developer’s frustration turned into a powerful internal ML framework, unifying machine learning best practices with composable software design.

Using monads might seem abstract at first, but they offer real, pragmatic value in ML engineering: allowing you to build predictable, traceable, and extensible pipelines that scale from experiment to production without rework.

If you’re tired of rebuilding pipelines for every use case or firefighting deployment issues, this architecture may be the shift you need.