DEV Community: Nicole Onyango

Deploying a Customer Lifetime Value(CLV) Prediction Model Using FastAPI

Nicole Onyango — Mon, 09 Feb 2026 05:17:13 +0000

Introduction

Customer Lifetime Value (CLV) is one of the most important metrics in modern data-driven businesses. It estimates the total revenue a business can expect from a customer over the entire duration of their relationship. Instead of treating all customers equally, CLV allows organizations to prioritize high-value customers, optimize marketing spend, improve retention strategies, and make smarter long-term decisions.

Machine learning makes CLV estimation more accurate by learning patterns from historical customer behavior. However, building a model is only half the job. For real-world impact, the model must be deployed in a way that other systems can access and use it. This article explains how a Customer Lifetime Value prediction model is deployed as a REST API using FastAPI, based on the referenced GitHub project.

⸻

Understanding Customer Lifetime Value (CLV)

Customer Lifetime Value represents the predicted monetary value a customer brings to a business over time. Traditional CLV calculations often rely on simple formulas using averages, but these approaches fail to capture complex behavioral patterns.

A machine learning–based CLV model improves this by learning from multiple customer attributes simultaneously. Features such as customer age, income, tenure, spending behavior, visit frequency, basket value, and support interactions are combined to predict future value more accurately. This allows businesses to move from intuition-based decisions to evidence-based customer strategies.

⸻

Dataset and Model Overview

The project uses structured customer data containing features relevant to purchasing behavior and engagement. Typical features include:
• Customer age
• Annual income
• Customer tenure (in months)
• Monthly spending
• Visits per month
• Average basket value
• Number of support tickets

These variables capture both financial behavior and customer engagement, which are critical for estimating lifetime value.

A supervised machine learning regression model is trained using this dataset. Since CLV is a continuous numerical value, regression algorithms are appropriate. The trained model learns how combinations of customer attributes relate to lifetime value outcomes. After training, the model is serialized using joblib, allowing it to be saved and reused without retraining.

Two files are saved:
• The trained model (clv_model.joblib)
• The list of feature names used during training (model_features.joblib)

Saving the feature list ensures that inputs during deployment follow the exact order expected by the model.

⸻

Why FastAPI for Deployment

FastAPI is a modern Python web framework designed specifically for building APIs. It is well suited for machine learning deployment for several reasons:
• High performance due to its asynchronous design
• Automatic data validation using Pydantic
• Built-in interactive API documentation
• Clean and readable syntax

FastAPI makes it easy to convert a trained machine learning model into a production-ready API that can be accessed by applications, dashboards, or other services.

⸻

Deploying the CLV Model with FastAPI

The deployment process begins by loading the trained model and feature list using joblib. A FastAPI application instance is then created to handle incoming HTTP requests.

To ensure reliable inputs, a Pydantic model is defined. This model specifies the exact data fields required for prediction, along with their data types. Any request that does not match this structure is automatically rejected, reducing the risk of invalid predictions.

When a prediction request is sent to the API, the following steps occur:
1. The API receives customer data in JSON format.
2. The data is validated using the Pydantic schema.
3. The values are arranged into a NumPy array in the same order used during model training.
4. The model generates a CLV prediction.
5. The predicted value is returned as a JSON response.

This structure ensures consistency, reliability, and ease of integration.

⸻

How the API Works

The deployed API exposes two main endpoints:
• Root endpoint (GET /)
This endpoint is used to verify that the API is running correctly. It returns a simple confirmation message.
• Prediction endpoint (POST /predict)
This endpoint accepts customer data and returns a predicted CLV value. The request body contains customer attributes in JSON format, and the response includes the predicted lifetime value.

By separating health checks from prediction logic, the API follows good design practices and is easier to maintain.

⸻

Testing the API

Testing is a critical step in deployment. The API can be tested in several ways:
• Using FastAPI’s automatic Swagger UI, accessible through the browser
• Sending requests via tools like Postman or cURL
• Integrating the API into another application for end-to-end testing

A typical test involves sending a JSON request with valid customer data and verifying that the API returns a numeric CLV prediction. Successful testing confirms that the model is correctly loaded, inputs are processed properly, and predictions are generated as expected.

⸻

Conclusion

Deploying a Customer Lifetime Value prediction model using FastAPI bridges the gap between data science and real-world application. While model training provides insights, deployment enables those insights to drive actual business decisions.

This project demonstrates a complete machine learning deployment workflow: preparing data, training a regression model, serializing it, and exposing it through a FastAPI-based REST API. The result is a scalable, reusable, and production-ready CLV prediction service.

By combining machine learning with modern API frameworks, organizations can transform predictive models into actionable tools that support smarter customer management and long-term growth.

How to Connect PostgreSQL to Power BI Using Local PostgreSQL and Aiven

Nicole Onyango — Tue, 02 Dec 2025 16:39:10 +0000

How to Connect PostgreSQL to Power BI Using Local PostgreSQL and Aiven (Full Guide)

Power BI doesn’t ship with a native PostgreSQL connector out of the box — but with the right setup, it becomes a clean, reliable pipeline for analytics.

In this guide, I’ll walk you through how to connect Power BI to:
•PostgreSQL running locally on your machine
•PostgreSQL hosted on Aiven, a fully managed cloud service

You’ll learn all the required configuration steps, drivers, connection settings, and common errors to avoid. This tutorial is built using Windows + DBeaver + PostgreSQL + Power BI Desktop.

Prerequisites

Before you begin, ensure you have:

✔ PostgreSQL installed locally

Windows installer: https://www.postgresql.org/download/

✔ Power BI Desktop installed

Microsoft Store or https://powerbi.microsoft.com/

✔ Npgsql .NET Data Provider

Required for Power BI to talk to PostgreSQL.
Download: https://www.npgsql.org/

Install the MSI → restart Power BI.

✔ DBeaver (optional but recommended)

Used to import and manage your PostgreSQL data.
https://dbeaver.io/

Part 1 — Connecting Local PostgreSQL to Power BI

Step 1: Collect your PostgreSQL connection details

Open pgAdmin or DBeaver and confirm:
• Host: localhost
• Port: 5432
• Database name: e.g., healthcare_db
• Username: e.g., postgres
• Password: your local DB password
Step 2: Install the Npgsql provider

Power BI requires a PostgreSQL driver to connect.
1. Download from: https://www.npgsql.org/download.html
2. Install the MSI.
3. Restart your machine (important).
4. Reopen Power BI.

Step 3: Connect in Power BI

Inside Power BI:

1.  Home → Get Data → More
2.  Search PostgreSQL
3.  Select PostgreSQL Database

Enter your DB credentials

Step 4: Allow native database queries

If Power BI prompts:

Allow Native Queries?

Click Run.

Your tables will appear in the Navigator window.

[Screenshot: Power BI Navigator listing your PostgreSQL tables]

Select the tables (patients, doctors, appointments, bills, etc.) → Load.

Part 2 — Connecting Aiven PostgreSQL to Power BI

Aiven is a cloud-hosted Postgres provider.
It uses SSL certificates — this is the only tricky part.

Step 1: Log in to Aiven

Go to https://console.aiven.io

Open your PostgreSQL service.

[Screenshot: Aiven PostgreSQL dashboard]

Step 2: Download SSL Certificates

In the service dashboard:

Service Settings → Connection Information → SSL → Download CA Certificate

You will get a .crt file.

Save it somewhere safe.

Step 3: Locate your Aiven connection string

Aiven provides this in the console,

Break it down:
• Host: pg-yourproject.aivencloud.com
• Port: 00000
• User: avnadmin
• Password: your generated password
• Database: defaultdb
• SSL: Required

Step 4: Connect Power BI to Aiven

In Power BI:
1. Home → Get Data → PostgreSQL
2. Enter:

Go to Advanced Options → Paste this in Additional connection string parameters:
Click OK Enter username and password.

Troubleshooting Common Errors

❌ “We couldn’t authenticate using the credentials provided.”

✔ Check username and password
✔ Ensure you copied the Aiven password without spaces

❌ “The Npgsql Provider is not installed.”

Install the Npgsql driver again → restart Power BI.

❌ “Certificate not trusted.”

Use either:
• Trust Server Certificate=True
or
• Import Aiven CA cert into Windows Certificate Store

Bonus Section — How to Import CSV Files Into PostgreSQL Using DBeaver

Many students struggled with this in class, so here’s a fast version.

✔ Step 1 — DBeaver → Right-click schema (e.g., hospital) → Import Data

[Screenshot placeholder]

✔ Step 2 — Select CSV

Check “Header”
Set delimiter = ,

✔ Step 3 — Map columns

Rename columns to snake_case lowercase (best practice)

If you skip renaming, PostgreSQL will lock your life with "QuotedNames" forever.

✔ Step 4 — Bulk Load

Enable Use Bulk Load → Finish.

Final Output — Power BI Dashboard

Once connected (local or Aiven), you can build visuals such as:
• Appointment trend line
• Total bills: Paid vs Outstanding
• Doctor workload distribution
• Patient demographic distribution
• Billing per admission
• Specialization performance

Final Thoughts

Connecting PostgreSQL to Power BI is a core data engineering skill.
Two big takeaways from this assignment:

Local PostgreSQL teaches fundamentals — drivers, ports, credentials, schemas.
Aiven PostgreSQL teaches real-world cloud connection handling — SSL, ports, certs, and connection strings.

Once you can connect both, you can work across local → cloud workflows, which is how modern analytics pipelines operate.