DEV Community: Andrea D'Attero

Building a Machine Learning Data Pipeline with Gridscript: From JSON and CSV to Machine Learning Model

Andrea D'Attero — Mon, 17 Nov 2025 07:30:00 +0000

JSON and CSV to Machine Learning Model Data pipelines are the foundation of modern analytics and machine learning workflows.

With gridscript.io, you can connect multiple data sources, clean and transform your data, and seamlessly integrate Python and scikit-learn - all inside one visual, reproducible environment.

In this tutorial, you'll create a simple yet powerful Gridscript pipeline that predicts whether employees will leave a company based on HR, payroll, and satisfaction data.

Scenario

You have three datasets:

A JSON file with employee info
A CSV file with payroll data
An XLSX file with satisfaction survey results

Your goal:

Merge all sources
Clean and enrich the data
Train a simple Logistic Regression model using scikit-learn

Sample Data

employees.json

[
  {"employee_id": 1, "name": "Alice", "department": "Engineering", "years_at_company": 3, "left_company": 0},
  {"employee_id": 2, "name": "Bob", "department": "Sales", "years_at_company": 2, "left_company": 1},
  {"employee_id": 3, "name": "Charlie", "department": "Engineering", "years_at_company": 5, "left_company": 0},
  {"employee_id": 4, "name": "Diana", "department": "HR", "years_at_company": 4, "left_company": 1},
  {"employee_id": 5, "name": "Ethan", "department": "Marketing", "years_at_company": 1, "left_company": 0}
]

payroll.csv

employee_id,salary,bonus
1,85000,5000
2,62000,2000
3,90000,7000
4,55000,1500
5,60000,3000

satisfaction.xlsx

employee_id satisfaction_score
1            0.8
2                0.4
3            0.9
4            0.3
5            0.6

Step 1: Load and Merge Data

In your Gridscript pipeline, create three “Import” stages as follows:

Then create a Code stage to merge the data together (I will use JavaScript for this example but you can go ahead and use Python if you prefer it):

const {employees, satisfaction, payroll} = context;

let names = [];
let department = [];
let years_at_company = [];
let left_company = [];
let salary = [];
let bonus = [];
let satisfaction_score = [];

context.employees.forEach((emp, i) => {
  names.push(emp.name);
  department.push(emp.department);
  years_at_company.push(emp.years_at_company);
  left_company.push(emp.left_company);
  salary.push(context.payroll[i + 1][1]);
  bonus.push(context.payroll[i + 1][2]);
  satisfaction_score.push(context.satisfaction[i + 1][1]);
})

context.data = {
    "name": names,
    department,
    years_at_company,
    left_company,
    salary,
    bonus,
    satisfaction_score
};
log(context.data)

This is the result that we get from running the previous stage:

{
    "name":["Alice","Bob","Charlie","Diana","Ethan"],
    "department":["Engineering","Sales","Engineering","HR","Marketing"],
    "years_at_company":[3,2,5,4,1],
    "left_company":[0,1,0,1,0],
    "salary":[85000,62000,90000,55000,60000],
    "bonus":[5000,2000,7000,1500,3000],
    "satisfaction_score":[0.8,0.4,0.9,0.3,0.6]
}

Step 2: Clean and Transform Data

Once the raw data has been merged into a single unified table, the next step is data cleaning and feature engineering. This is where we convert all values into a modeling-friendly format and create new features that may improve model performance.

In Gridscript, we can do this using a Python code stage. The code below performs several important preprocessing steps:

import pandas as pd
from gridscript import table

df = pd.DataFrame(context['data'])
df["salary_k"] = df["salary"] / 1000
df["loyalty_score"] = df["years_at_company"] * df["satisfaction_score"]
df = pd.get_dummies(df, columns=["department"], drop_first=True)
df = df.drop(columns=["name", "salary"])
context['df'] = df

What’s happening here?

Converting raw salary to salary_k: Machine learning models often work better when numerical values are in a similar range. Dividing salary by 1,000 makes the feature easier to learn from and easier to interpret.
Creating a new feature loyalty_score: years_at_company × satisfaction_score gives a simple proxy for engagement or stability. Someone who has been at the company 5 years with a 0.9 satisfaction score is likely much more loyal than someone who has been there 1 year with 0.3 satisfaction. Feature engineering like this often boosts predictive performance.
One-hot encoding the department column: Machine learning algorithms can't directly understand text categories (like "Engineering" or "HR"). pd.get_dummies() converts each department into a binary (0/1) column. Using drop_first=True avoids multicollinearity by removing one reference category.
Removing unnecessary columns: name is not useful for prediction and salary is replaced by the cleaner salary_k.

Result

After this transformation, every column in df is numeric, making it fully ready for machine learning in the next stage.

Step 3: Prepare Features and Train a Logistic Regression Model

Now that the dataset is clean and numeric, it’s time to train a machine learning model.
In this example, we use Logistic Regression, one of the most common algorithms for binary classification problems like predicting employee attrition (left_company).

from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.pipeline import Pipeline
from sklearn.metrics import accuracy_score, confusion_matrix
import pandas as pd

scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

df = pd.DataFrame(context["df"])

# Separate features and target
X = df.drop(columns=["left_company"])
y = df["left_company"]

# Full Pipeline: scale numeric features + logistic regression
model = Pipeline(steps=[
    ("scaler", StandardScaler()),
    ("classifier", LogisticRegression())
])

# Split the data
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

# Train
model.fit(X_train, y_train)

# Predict
preds = model.predict(X_test)

# Results
print("Predictions:", preds)
print("Accuracy:", accuracy_score(y_test, preds))
print("Confusion Matrix:\n", confusion_matrix(y_test, preds))

Explanation of Step 3

Separating features (X) from the target (y): X contains the variables used to make a prediction, y contains 0 or 1 — whether the employee left the company. This is standard practice in machine learning.
Using a Pipeline: The pipeline bundles preprocessing and model training into one reproducible sequence.
Splitting the dataset (train/test split): 80% of the data is used to train the model, 20% is kept unseen to test how well the model generalizes, this is essential to avoid overfitting.
Evaluating the model, the code outputs: Predictions, Accuracy — percentage of correct predictions, Confusion matrix — how many 0s and 1s were classified correctly or incorrectly.

This gives you a quick understanding of the model’s performance.

Step 4: Run It All as a Gridscript Pipeline

Now that each stage works, you can chain them visually inside Gridscript.io to build a fully reproducible end-to-end data pipeline.

A typical Gridscript pipeline for this project looks like this:

Import the JSON, CSV, and XLSX datasets
Merge Data
Clean & Transform Data
Engineer features
Create, Train & Evaluate Model

Why This Example Works

This example demonstrates how Gridscript pipelines:

Integrate multiple data sources (JSON, CSV, XLSX)
Perform data transformation and feature engineering
Enable machine learning workflows with scikit-learn
Make your process reproducible and shareable

Pipeline Features

Reproducibility: Every stage is versioned and saved. If new data arrives, you just rerun the pipeline — no code changes needed.
Transparency: You can inspect outputs at each stage. This makes debugging and experimentation far easier than writing a monolithic script.
Modularity: Want to try A RandomForestClassifier? A different set of features? A new data source? Just swap in or duplicate a stage — the rest of the pipeline stays intact.
Collaboration: Teams can share pipelines, comment on steps, and review changes — ideal for data scientists, analysts, and ML engineers.

Next Steps

Try extending the pipeline by:

Adding more features (e.g., bonus/salary ratio)
Trying a RandomForestClassifier
Visualizing feature importance in another Gridscript cell

Try now Gridscript pipelines here.

Stop Copy-Pasting Between Excel and Code: Automate Your Data Workflows with GridScript

Andrea D'Attero — Sun, 09 Nov 2025 16:36:15 +0000

If you’ve ever exported data from an app or database, you know the drill.
You open a CSV file in Excel, fix a few columns, clean a few headers… then realize you need to write a script to automate it next time.

And before you know it, you’re bouncing between Excel, VS Code, and a folder full of “final_v3_cleaned.csv” files.

I built Gridscript.io to stop that cycle — and give developers and analysts one place to transform data instantly, using JavaScript or Python, right in the browser.

💥 The Problem: Excel Is Great Until It Isn’t

Excel is amazing for quick inspection, filtering, and small edits.
But once you need to automate logic — like converting date formats, merging datasets, or renaming headers — things get messy.

You end up writing scripts like this:

import pandas as pd
df = pd.read_csv("data.csv")
df["price"] = df["price"].astype(float)
df.to_csv("data_cleaned.csv")

All of that just to import the data and this doesn't take into account the time spent to setup the project and install dependencies.

⚙️ The Idea: Script Data Directly in the Browser

GridScript eliminates the need for setups, dependencies, or switching tools.

Here’s the workflow:

Upload your Excel or CSV file
See it instantly in a spreadsheet-like grid
Write a few lines of JavaScript or Python
Preview your changes live
Export clean data when done

Everything runs entirely in your browser — private, fast, and serverless.

Example: Clean and Reformat a Dataset in Seconds

Let’s say you have a CSV with messy data like this:

name	price	active	date
Laptop	799.99	TRUE	01-05-25
Mouse	25	FALSE	04-12-24

In a Gridscript project you can fix and reformat everything with just a few lines:

gridData = gridData.filter(r => r[2] === "TRUE");
gridData.forEach(r => {
  r[1] = `\$${Number(r[1]).toFixed(2)}`;
  r[3] = new Date(r[3]).toISOString().split('T')[0];
});
updateGridData(gridData);

or in Python:

grid_data = [r for r in grid_data if r[2] == "TRUE"]
for r in grid_data:
    r[1] = f"${float(r[1]):.2f}"
    r[3] = r[3].replace("-", "/")

✅ One click on “Run” — your grid updates instantly.\
✅ One click on “Export” — you’ve got a clean file ready to go.

🔄 Automate Repetitive Workflows

Once you find a script that cleans your data perfectly, you can reuse it across files.
Just open a new dataset, paste your script, and hit Run — done.

No more:

Manually editing Excel columns
Copying formulas
Exporting and re-importing between tools

GridScript turns those steps into a single, automated workflow that lives entirely in your browser.

By combining Excel’s interactivity with Python and JavaScript’s power, GridScript makes it effortless to clean, reshape, and prepare data.

No installs. No dependencies. No more copy-paste chaos.

You just write, run, and export.

You can try it right now at https://gridscript.io. Upload a CSV or Excel file, write a few lines of Python or JavaScript, and transform your data instantly.

I Built GridScript: A New Way to Transform Excel Data with JavaScript and Python

Andrea D'Attero — Sat, 08 Nov 2025 11:42:53 +0000

TL;DR

GridScript.io lets you open Excel/CSV files, run JavaScript or Python scripts to transform the data, and export the result — all in your browser.

No backend. No install. Instant feedback.

Why I Built It

Developers constantly bounce between spreadsheets and code when working with data — cleaning CSVs, merging reports, converting formats.

I wanted a way to stay inside the browser and use the languages I already know (JavaScript and Python) to transform and visualize data.

That idea became Gridscript.io.

But it's also more than that, Gridscript offers access to Tensorflow.js and Scikt-learn allowing engineers to directly build AI/ML models.

Tech Stack

Next.js – fast frontend framework
AG Grid – Excel-like grid for editing and filtering
Monaco Editor – same editor used in VS Code
Client-side architecture – no data leaves your browser
Undo/Redo system – safe experimentation

Example Workflow

Create a New Pipeline
Upload an Excel, JSON or CSV file
Write a few lines of code in JS or Python
Instantly see the grid update
Export the result

context.data = context.data.filter(row => row.quantity > 10);
context.data.forEach(row => row.price = `\$${row.price.toFixed(2)}`);

Why Both Languages?

I didn’t want to force users into one ecosystem.
Web devs love JS; analysts live in Python.
Both deserve the same smooth experience.

GridScript makes that possible with a unified scripting interface.

Privacy by Design

Everything happens client-side — no data upload, no server storage.
Perfect for sensitive business files.

Try It Yourself 👉 gridscript.io

If you work with data, this tool might save you hours every week.

And by the way, we care about our users you can find documentation here: Docs check it out!