Modal for Data Science: Free GPU Compute for Your Python Projects

If you’ve ever waited 45 minutes for scikit-learn to finish a grid search on your laptop, you know the pain. The M2 MacBook Air is great for browsing, but when your master’s assignment involves training a neural network on 50,000 rows, you start fantasizing about GPUs you don’t own.

Enter Modal: a serverless GPU cloud that gives you $30/month in free credits — no credit card, no commitment — and lets you run Python functions on NVIDIA GPUs with a single decorator.

What is Modal?

Modal is a serverless compute platform built for AI workloads. Instead of renting a VM, installing CUDA drivers, and configuring Docker, you add a @app.function(gpu="L40S") decorator above your Python function. Modal handles everything else: containerization, GPU scheduling, auto-scaling, and teardown.

Think of it as “cloud functions, but with GPUs.”

import modal

app = modal.App("my-project")

@app.function(gpu="T4")
def train_model():
    import torch
    # Your heavy ML code here — runs on a real GPU
    return {"accuracy": 0.94}

@app.local_entrypoint()
def main():
    result = train_model.remote()
    print(result)

The Free Tier: $30/month, Actually Free

Modal’s Starter plan gives you $30 of compute credits every month. Here’s what that buys you:

For graduate students, there’s also the Modal for Academics program offering up to $10,000 in additional credits. Apply at modal.com/academics.

Setup with uv

I use uv for Python projects. Here’s the complete setup:

# Create a new project
uv init modal-ds --no-readme
cd modal-ds

# Pin Python 3.12 (Modal doesn't support 3.13 yet)
uv python pin 3.12

# Install Modal + data science dependencies
uv add modal jupyter pandas scikit-learn torch matplotlib

# Edit pyproject.toml: change "requires-python" to ">=3.12"
# (uv init defaults to >=3.13)

# Authenticate with Modal (opens browser)
uv run modal setup

⚠️ Important: Modal currently supports Python 3.10–3.12 only. If your system has Python 3.13, you must pin 3.12 or you’ll get InvalidError: Unsupported Python version: '3.13'.

Choosing a Base Image

Modal gives you four ways to define your container environment, all chainable with build methods like .pip_install(), .apt_install(), and .run_commands().

All of these support the same chainable build methods:

image = (
    modal.Image.debian_slim(python_version="3.12")
    .apt_install("git", "ffmpeg")           # system packages
    .pip_install("torch", "transformers")    # Python packages
    .run_commands("echo 'build complete!'")  # arbitrary shell commands
    .env({"HF_HOME": "/cache"})              # environment variables
)

For data science coursework, .debian_slim() with .pip_install() is all you need. Switch to .from_registry() when you need a specific CUDA version, or .micromamba() when a package only exists on conda-forge.

Two Ways to Use Modal

Option 1: Script Mode (modal run)

Best for: batch jobs, scheduled tasks, one-off experiments.

import modal

image = modal.Image.debian_slim(python_version="3.12").pip_install(
    "torch", "scikit-learn", "pandas"
)
app = modal.App("train-model", image=image)

@app.function(gpu="L40S")
def train():
    from sklearn.ensemble import RandomForestClassifier
    # ... training code ...
    return {"score": 0.92}

@app.local_entrypoint()
def main():
    result = train.remote()
    print(result)

Run it:

uv run modal run train.py

The first run takes ~60–90 seconds while Modal builds the container image. Subsequent runs are much faster — the image stays cached.

⚠️ Never use python train.py — Modal decorators only activate through modal run. Running with plain Python produces no output.

Option 2: Notebook Mode (local kernel + remote GPU)

Best for: exploratory data analysis, iterative model development, course assignments.

The pattern is simple: your notebook runs locally on your laptop, but heavy GPU calls go to Modal via .remote(). Data exploration, pandas, and matplotlib stay local (free). Only GPU bursts hit the cloud.

# Cell 1: Setup
import modal

image = modal.Image.debian_slim(python_version="3.12").pip_install(
    "torch", "scikit-learn", "pandas"
)
app = modal.App("nb-hybrid", image=image)

# Cell 2: Define GPU functions
@app.function(gpu="L40S")
def train_model(X_train, y_train, X_test, y_test):
    import torch
    import torch.nn as nn

    device = torch.device("cuda")
    # ... model training on GPU ...
    return {"accuracy": 0.94, "history": [...]}

# Cell 3: Run locally (CPU — free)
import pandas as pd
df = pd.read_csv("dataset.csv")
print(f"Loaded {len(df):,} rows")

# Cell 4: Offload to GPU (Modal cloud)
with app.run():                    # ← CRITICAL: context manager required
    result = train_model.remote(
        X_train, y_train, X_test, y_test
    )

# Cell 5: Analyze locally (CPU)
import matplotlib.pyplot as plt
plt.plot([h["accuracy"] for h in result["history"]])
plt.show()

⚠️ The with app.run(): context manager is mandatory in notebooks. Without it, you’ll get Function has not been hydrated.

How to Choose a GPU

For most data science coursework (scikit-learn, XGBoost, small neural nets), a T4 or L40S is more than enough.

What You’re Actually Billed For

Modal charges per second of active compute, not for idle time:

• GPU billed: Only while your function is executing.
• CPU/RAM billed: Same — per second, only during execution.
• Storage (Volumes): $0.09/GiB/month, but the first 1 TiB is free.
• Idle: $0. Scale-to-zero is the default.

A typical data science notebook that trains a model for 5 seconds on a T4 costs about $0.0008. With $30/month, you can run that ~37,000 times.

💡 Always use the default preemptible tier. The 3× non-preemptible multiplier is for production APIs that can’t tolerate interruptions — your batch jobs and notebooks don’t need it.

When GPU Actually Matters: A Real Benchmark

Not every workload needs a GPU. I ran the exact same neural network on my local CPU and on a Modal T4 to see when the cloud GPU actually pays off.

Small model (30 features, 10K rows, 3-layer NN)

Winner: CPU. The T4’s cold start (~3 seconds) dominates the tiny compute time. For a model this small, your laptop is faster.

Medium model (200 features, 100K rows, 5-layer NN)

Winner: GPU by 5-10x. Once your model has more layers and your dataset hits six figures, the GPU pulls ahead decisively.

The rule of thumb

If training takes < 5 seconds on CPU → don't bother with GPU
If training takes 5–30 seconds on CPU → GPU helps, but CPU is fine
If training takes > 30 seconds on CPU → GPU is a no-brainer

For most coursework assignments, your laptop handles the prototyping fine. Modal earns its keep when you scale up — hyperparameter sweeps, cross-validation on large datasets, or fine-tuning pre-trained models.

Common Pitfalls (and How to Avoid Them)

Where Modal Fits in the Data & ML Ecosystem

Modal is one piece in a larger landscape. Here’s how the major tools relate to each other:

The golden rule

Your data fits in RAM and you just need GPU?
    → Modal

Your pandas pipeline ran out of memory but you just need SQL?
    → DuckDB (yes, it's really that fast)

Your pandas pipeline ran out of memory and you need pandas API?
    → Dask / Coiled

You have a data lake and need SQL at scale?
    → Spark / Databricks

You're training LLMs across 64 GPUs with distributed strategies?
    → Ray / Anyscale

It all fits on your laptop?
    → Don't over-engineer it.

🦆 Why DuckDB? DuckDB is an in-process analytical database that spills to disk automatically when data doesn’t fit in RAM. You query it with standard SQL, it runs columnar-vectorized (think: faster than pandas for aggregations), and it installs with a single pip install duckdb. For datasets up to a few hundred gigabytes, it often outperforms Spark on a single machine. It doesn’t do GPUs — that’s Modal’s job — but for CPU-bound analysis on bigger-than-memory tabular data, DuckDB is the simplest tool that works.

For my Data Science master’s, Modal covers the GPU side and my laptop handles everything else. The $30/month free credit covers all my experiments, and when I’m not running anything, I pay exactly zero. If I ever hit a dataset that doesn’t fit in RAM (50GB+), Dask is the natural next step. Ray and Spark are for when you’re building production ML platforms — they’re overkill for coursework.

Resources

• Modal Documentation
• Modal GPU Guide
• Modal Examples (GitHub)
• Modal for Academics
• Modal Pricing