DEV Community: Ephantus Macharia

Statistics for Data Science

Ephantus Macharia — Tue, 22 Sep 2026 14:03:46 +0000

Data science is often presented as:

Python + Machine Learning + Data = Data Science

But there is something underneath all three:

Statistics.

Machine learning can build a prediction. Python can process the data. A dashboard can make the result look beautiful.

But statistics helps you answer the most important question:

"Can I trust what the data is telling me?"

Start With Descriptive Statistics

Before predicting anything, understand what you already have.

Imagine these exam scores:

45, 50, 52, 55, 60, 62, 90

You can summarize them using:

Mean → average
Median → middle value
Mode → most frequent value
Range → maximum − minimum
Variance → how spread out the data is
Standard deviation → typical distance from the mean

In Python:

import numpy as np

scores = [45, 50, 52, 55, 60, 62, 90]

print("Mean:", np.mean(scores))
print("Median:", np.median(scores))
print("Standard deviation:", np.std(scores))

Why does this matter?

The mean alone can be misleading.

That 90 is pulling the average upward.

Statistics helps you notice the story hidden behind the average.

Distribution: How Is Your Data Behaving?

Data doesn't always behave nicely.

It can be:

Normal       →    
Right-skewed →     
Left-skewed  →     
Uniform      →     
Bimodal      →

Understanding distributions helps you decide how to analyze your data.

For example:

import matplotlib.pyplot as plt

plt.hist(scores, bins=5)
plt.xlabel("Score")
plt.ylabel("Frequency")
plt.title("Distribution of Exam Scores")
plt.show()

Strong pointer

Always visualize your data before trusting a statistical summary.

A graph can reveal patterns that a table of numbers hides.

Probability: Measuring Uncertainty

Data science rarely deals with certainty.

Instead, we ask:

"How likely is this?"

For example:

Probability of rain = 70%

Or in machine learning:

Probability customer will churn = 0.82

Probability gives us a mathematical language for uncertainty.

And uncertainty is everywhere in data science.

. Hypothesis Testing

Suppose a company introduces a new website design.

The average conversion rate increases from:

5.1% → 5.8%

Is that a real improvement?

Or could it simply be random variation?

This is where hypothesis testing comes in.

We formulate:

H₀ → No meaningful difference
H₁ → There is a difference

Then we use an appropriate statistical test.

Common tests include:

t-test
ANOVA
Chi-square
Mann–Whitney U
Wilcoxon
Pearson correlation
Spearman correlation

P-Values: Don't Worship 0.05

You will often hear:

p < 0.05

But statistics is more than checking whether a number crossed 0.05.

A p-value helps quantify how compatible the observed data are with the null hypothesis under the assumptions of the statistical test.

And remember:

A small p-value does not automatically mean the effect is important.

Always consider:

Statistical significance
        +
Effect size
        +
Confidence interval
        +
Real-world importance

Confidence Intervals

Suppose your analysis estimates that the average delivery time is:

42 minutes

Instead of reporting only:

42 minutes

you might report an interval such as:

95% CI: 39–45 minutes

The interval communicates uncertainty around the estimate.

Think of it as:

"Here is our estimate, and here is the uncertainty surrounding it."

. Correlation: When Variables Move Together

Suppose we discover:

Hours studied ↑
        ↓
Exam scores ↑

There may be a positive relationship.

Python makes this easy:

from scipy.stats import pearsonr

correlation, p_value = pearsonr(hours, scores)

print(correlation)
print(p_value)

But remember the golden rule:

Correlation does not prove causation.

Ice cream sales and swimming accidents might increase during summer.

That doesn't mean ice cream causes swimming accidents.

A third factor—temperature—may influence both.

Sampling: You Usually Don't Need Everyone

Imagine a country has:

50 million people

and you want to understand consumer preferences.

You don't necessarily need to ask all 50 million.

You can study a sample.

Population
     ↓
   Sample
     ↓
Analysis
     ↓
Inference about population

But there is a catch:

A bad sample can produce a confidently wrong conclusion.

Sampling bias is therefore a major concern in data science.

. Statistics Meets Machine Learning

Statistics isn't separate from machine learning.

They overlap everywhere.

Statistics	Data Science / ML
Probability	Classification probabilities
Distributions	Model assumptions
Correlation	Feature analysis
Sampling	Train/test datasets
Confidence intervals	Uncertainty
Hypothesis testing	Experimentation
Regression	Predictive modeling
Variance	Model generalization

This is why learning statistics makes machine learning concepts much easier to understand.

The Data Scientist's Statistical Mindset

When you receive a dataset, don't immediately open your machine-learning library.

Ask:

What does each variable mean?
          ↓
What does the distribution look like?
          ↓
Are there outliers?
          ↓
How much variation exists?
          ↓
Is the sample representative?
          ↓
Are variables related?
          ↓
Could this pattern be random?
          ↓
What uncertainty exists?
          ↓
What conclusion can the data actually support?

That mindset is more valuable than memorizing formulas.

The Statistics Toolkit

If you're learning data science, build your statistics foundation around these areas:

Descriptive Statistics

Mean • Median • Mode • Variance • Standard Deviation

Probability

Events • Conditional Probability • Bayes' Theorem

Distributions

Normal • Binomial • Poisson • Uniform

Inferential Statistics

Sampling • Confidence Intervals • Hypothesis Testing

Relationships

Correlation • Covariance • Regression

Statistical Tests

t-test • ANOVA • Chi-square • Mann–Whitney • Wilcoxon

Experimental Thinking

A/B Testing • Control Groups • Randomization • Bias

Conclusion

Statistics isn't about making data complicated.

It's about learning how to question the numbers.

When you see:

📈 Revenue increased 20%

don't immediately celebrate.

Ask:

20% compared with what?

When you see:

🎯 Model accuracy = 95%

ask:

95% on which dataset?

When you see:

🔗 Correlation = 0.85

ask:

Does correlation actually explain the relationship?

And when you see:

p < 0.05

ask:

Is the effect statistically significant, and does it actually matter?

That's the difference between reading numbers and thinking with data.

Statistics doesn't just tell you what happened. It teaches you how confident you should be in the story your data is telling.

Parametric vs Non-Parametric Statistical Tests in Python

Ephantus Macharia — Tue, 22 Sep 2026 12:55:14 +0000

When working with data, knowing the mean, median, or standard deviation is often not enough.

At some point, you may want to answer questions like:

Is the average of two groups significantly different?
Are two variables related?
Did an intervention change the results?
Are three or more groups statistically different?
Does my sample provide enough evidence to reject the null hypothesis?

This is where statistical hypothesis testing becomes useful.

Two major families of statistical tests are:

Parametric tests and non-parametric tests

Understanding when to use each one is an important skill for anyone working in data analysis, data science, or machine learning.

The Basic Idea

Most hypothesis tests start with two competing statements.

Null hypothesis — H₀

There is no statistically significant difference or relationship.

Alternative hypothesis — H₁

There is a statistically significant difference or relationship.

The test produces a p-value.

A common significance level is:

α = 0.05

A simplified interpretation is:

p < 0.05  → evidence against H₀
p ≥ 0.05 → insufficient evidence against H₀

Strong pointer

A p-value is not the probability that the null hypothesis is true.

It tells you how compatible your observed data are with the null hypothesis under the assumptions of the test.

What Are Parametric Tests?

Parametric tests make assumptions about the underlying population distribution and its parameters.

Common assumptions can include:

Approximately normally distributed data
Independence of observations
Continuous measurements
Equal or appropriately modeled variances in some tests

Common parametric tests include:

Test	Typical Use
t-test	Compare means
ANOVA	Compare means across 3+ groups
Pearson correlation	Measure linear association
Paired t-test	Compare paired measurements

Parametric tests can be powerful when their assumptions are reasonably satisfied.

What Are Non-Parametric Tests?

Non-parametric tests generally make fewer distributional assumptions.

They are particularly useful when:

Data are strongly skewed
Data contain influential outliers
The sample is small and normality is questionable
Data are ordinal/ranked
Parametric assumptions are not reasonably satisfied

Common examples include:

Parametric	Non-Parametric Alternative
Independent t-test	Mann–Whitney U
Paired t-test	Wilcoxon signed-rank
One-way ANOVA	Kruskal–Wallis
Pearson correlation	Spearman correlation

Strong pointer

Non-parametric does not mean "no assumptions."

These tests still have assumptions about things such as independence, measurement structure, and the form of the distributions or relationships being tested.

Install the Python Libraries

For most statistical testing in Python, SciPy is a great starting point.

pip install scipy pandas numpy

Import them:

import numpy as np
import pandas as pd
from scipy import stats

Independent t-test

Suppose we want to compare the average exam scores of two independent groups.

group_a = [72, 75, 78, 70, 74, 77, 73]
group_b = [82, 85, 88, 84, 86, 89, 83]

result = stats.ttest_ind(group_a, group_b)

print("t-statistic:", result.statistic)
print("p-value:", result.pvalue)

Interpretation:

if result.pvalue < 0.05:
    print("Statistically significant difference")
else:
    print("Insufficient evidence of a difference")

The independent t-test is designed to compare the means of two independent groups under its assumptions.

Mann–Whitney U Test

What if the data are heavily skewed or ordinal and the assumptions for the t-test aren't appropriate?

We can consider the Mann–Whitney U test.

group_a = [72, 75, 78, 70, 74, 77, 73]
group_b = [82, 85, 88, 84, 86, 89, 83]

result = stats.mannwhitneyu(
    group_a,
    group_b,
    alternative="two-sided"
)

print("U-statistic:", result.statistic)
print("p-value:", result.pvalue)

This test works with the ranks of observations rather than relying on the same distributional assumptions as the t-test.

Important

Don't simply say:

"Mann–Whitney compares medians."

That's an oversimplification.

Its interpretation depends on the distributions of the two groups. Under additional conditions, differences in location can be interpreted more directly.

Paired t-test

Sometimes observations come in natural pairs.

For example:

Student's score BEFORE training
Student's score AFTER training

The same students are measured twice.

before = [65, 70, 72, 68, 75, 71]
after = [70, 74, 78, 73, 79, 76]

result = stats.ttest_rel(before, after)

print("t-statistic:", result.statistic)
print("p-value:", result.pvalue)

This is different from an independent t-test because the observations are paired.

Wilcoxon Signed-Rank Test

If the paired data do not reasonably satisfy the assumptions of a paired t-test, the Wilcoxon signed-rank test is a common alternative.

result = stats.wilcoxon(before, after)

print("Statistic:", result.statistic)
print("p-value:", result.pvalue)

Think of the relationship like this:

Paired numerical data
        │
        ├── assumptions reasonable
        │       ↓
        │   Paired t-test
        │
        └── assumptions questionable
                ↓
        Wilcoxon signed-rank

ANOVA

What if we have three or more independent groups?

For example:

Method A
Method B
Method C

We could use one-way ANOVA.

method_a = [72, 75, 78, 70, 74]
method_b = [80, 82, 85, 81, 84]
method_c = [88, 90, 87, 91, 89]

result = stats.f_oneway(
    method_a,
    method_b,
    method_c
)

print("F-statistic:", result.statistic)
print("p-value:", result.pvalue)

If the ANOVA is statistically significant, it tells us that at least one group differs, but it does not tell us which groups differ.

That requires appropriate post-hoc testing.

Strong pointer

Don't run multiple t-tests instead of ANOVA just because you have several groups.

Repeated testing can increase the chance of false-positive findings unless you appropriately control for multiple comparisons.

Kruskal–Wallis Test

The non-parametric counterpart commonly used for comparing three or more independent groups is the Kruskal–Wallis test.

result = stats.kruskal(
    method_a,
    method_b,
    method_c
)

print("H-statistic:", result.statistic)
print("p-value:", result.pvalue)

Again, a significant result tells you that there is evidence of a difference somewhere among the groups.

You may need appropriate post-hoc pairwise comparisons to determine where the differences occur.

Pearson Correlation

Suppose we want to measure the linear relationship between:

Hours studied

and:

Exam score

We can use Pearson correlation.

hours = [2, 3, 4, 5, 6, 7, 8]
scores = [55, 60, 65, 70, 74, 80, 85]

result = stats.pearsonr(hours, scores)

print("Correlation:", result.statistic)
print("p-value:", result.pvalue)

The correlation coefficient ranges from:

-1 → strong negative linear relationship
 0 → no linear relationship
+1 → strong positive linear relationship

Important

Correlation does not establish causation.

Correlation ≠ Causation

Spearman Correlation

When the relationship is better represented by ranks or monotonic association, Spearman's correlation can be useful.

result = stats.spearmanr(hours, scores)

print("Spearman correlation:", result.statistic)
print("p-value:", result.pvalue)

A monotonic relationship means that as one variable increases, the other tends to consistently increase or decrease, even if the relationship isn't linear.

How Do I Choose the Test?

Here's a practical cheat sheet:

                 What are you testing?
                         │
        ┌────────────────┼─────────────────┐
        │                │                 │
     2 groups         3+ groups       Relationship
        │                │                 │
        ↓                ↓                 ↓
   ┌─────────┐      ┌──────────┐      ┌──────────┐
   │Independent│     │  ANOVA   │      │ Pearson  │
   │ t-test    │     │          │      │          │
   └─────────┘      └──────────┘      └──────────┘
        │                │                 │
        ↓                ↓                 ↓
   Mann–Whitney     Kruskal–Wallis     Spearman

For paired observations:

Paired measurements
        │
        ├── Parametric assumptions reasonable
        │        ↓
        │    Paired t-test
        │
        └── Assumptions questionable
                 ↓
        Wilcoxon signed-rank

. Don't Automatically Test for Normality

A common beginner workflow is:

Run Shapiro-Wilk
       ↓
p > 0.05?
       ↓
Use t-test

This is too simplistic.

Normality testing should not be the only thing determining your choice.

Also consider:

Sample size
Distribution shape
Outliers
Independence
Measurement scale
Study design
Equal variance assumptions
Robustness of the chosen test

Visual inspection can help:

import matplotlib.pyplot as plt

plt.hist(group_a)
plt.xlabel("Score")
plt.ylabel("Frequency")
plt.title("Distribution of Scores")
plt.show()

You can also use a Q-Q plot:

stats.probplot(group_a, dist="norm", plot=plt)
plt.show()

. Statistical Significance vs Practical Significance

This is one of the most important lessons in statistics.

Suppose:

p = 0.001

That may provide strong evidence against the null hypothesis under the test assumptions.

But the actual difference might be extremely small.

For example:

Group A average = 70.01
Group B average = 70.10

A large dataset can make tiny differences statistically significant.

Therefore, don't report only:

p < 0.05

Also consider:

Effect size
Confidence intervals
Magnitude of the difference
Practical/business importance
Sample size

Golden rule

Statistical significance tells you about evidence; practical significance tells you whether the size of the effect matters.

. A Better Python Workflow

When performing a statistical test, use this workflow:

1. Understand the research/business question
             ↓
2. Identify the variables
             ↓
3. Define the groups or relationship
             ↓
4. Understand the study design
             ↓
5. Check assumptions
             ↓
6. Choose the appropriate test
             ↓
7. Run the test
             ↓
8. Examine the p-value
             ↓
9. Report effect size / confidence interval
             ↓
10. Interpret the result in context

This is much better than:

Load data → run test → look at p-value

. Parametric vs Non-Parametric: Quick Reference

Question	Parametric	Non-Parametric
2 independent groups	Independent t-test	Mann–Whitney U
2 paired measurements	Paired t-test	Wilcoxon signed-rank
3+ independent groups	One-way ANOVA	Kruskal–Wallis
Linear association	Pearson	Spearman for rank/monotonic association
Distribution assumptions	Generally stronger	Generally fewer distributional assumptions
Works with ordinal data	Usually not ideal	Often appropriate
Outlier sensitivity	Often higher	Often lower, but not immune

Conclusion

Parametric and non-parametric tests are not competitors where one is universally better.

They are tools designed for different situations.

Think of the decision this way:

             BUSINESS / RESEARCH QUESTION
                         ↓
                    YOUR DATA
                         ↓
                   STUDY DESIGN
                         ↓
                   ASSUMPTIONS
                         ↓
              ┌──────────┴──────────┐
              ↓                     ↓
       Parametric test       Non-parametric
              ↓                     ↓
        t-test / ANOVA       Mann-Whitney /
        / Pearson            Wilcoxon / Kruskal
              └──────────┬──────────┘
                         ↓
                 INTERPRET RESULTS
                         ↓
          Effect size + CI + Context

The goal isn't to memorize dozens of statistical tests.

The real data-analysis skill is knowing why a particular test is appropriate for a particular question and dataset.

Once you understand that, Python becomes the tool that helps you execute the analysis not the thing making the statistical decision for you.

Star, Snowflake, or Galaxy? A Practical Guide to Data Warehouse Modeling

Ephantus Macharia — Tue, 22 Sep 2026 11:45:43 +0000

When building a data warehouse, one of the most important decisions is how to organize the data for analytics.

You will often encounter three dimensional modeling patterns:

Star Schema
Snowflake Schema
Galaxy Schema (Fact Constellation)

At first, they can seem like three completely different architectures. They are not.

They are better understood as different ways of organizing fact tables and dimension tables around analytical requirements.

The real question isn't:

"Which schema is the best?"

A better question is:

"Which schema best fits the business processes, query patterns, data relationships, and analytical requirements I have?"

This article breaks down all three approaches and provides a practical framework for choosing between them.

First: What Is a Data Warehouse Schema?

A data warehouse schema defines how analytical data is organized into tables and relationships.

Unlike an operational database, where the primary concern may be efficient transaction processing, a data warehouse is designed primarily for analysis, reporting, aggregation, and decision-making.

A dimensional warehouse generally revolves around two important table types:

Fact tables

Fact tables contain measurable business events.

Examples:

Sales
Orders
Payments
Shipments
Inventory movements
Website clicks
Transactions

A sales fact table might look like:

fact_sales

sale_id
date_id
customer_id
product_id
store_id
quantity
sales_amount
discount_amount

Dimension tables

Dimensions provide descriptive context around the facts.

For example:

dim_customer
dim_product
dim_date
dim_store
dim_employee

A product dimension might contain:

product_id
product_name
category
subcategory
brand
supplier

This allows an analyst to ask questions such as:

How much revenue did we generate from electronics in Nairobi during Q2?

The fact table provides the measurement.

The dimension tables provide the context.

2. The Most Important Concept: Grain

Before choosing a schema, define the grain of your fact table.

The grain answers:

"What does one row in this fact table represent?"

For example:

One row = one product on one customer order

or:

One row = one customer transaction

or:

One row = daily inventory balance for one product at one warehouse

This decision is extremely important.

Example

Suppose we have:

fact_sales

and define its grain as:

One row represents one product sold in one transaction.

We can then safely store:

order_id
product_id
customer_id
date_id
quantity
sales_amount

But if another developer assumes:

One row = one complete order

the same table could easily be misinterpreted.

That can lead to incorrect:

revenue calculations
order counts
averages
inventory metrics
dashboards

Strong pointer

Never design the schema before defining the grain.

A well-defined grain is one of the foundations of reliable dimensional modeling.

. Star Schema ⭐

The star schema is one of the most common dimensional modeling patterns.

It consists of:

             dim_customer
                   |
                   |
dim_product — fact_sales — dim_date
                   |
                   |
               dim_store

The fact table sits at the center.

Dimension tables surround it.

This creates a shape that resembles a star.

Example Star Schema

Imagine an online store.

Fact table

CREATE TABLE fact_sales (
    sale_id INT,
    date_id INT,
    customer_id INT,
    product_id INT,
    store_id INT,
    quantity INT,
    sales_amount DECIMAL(12,2)
);

Product dimension

CREATE TABLE dim_product (
    product_id INT,
    product_name VARCHAR(100),
    category VARCHAR(100),
    subcategory VARCHAR(100),
    brand VARCHAR(100)
);

Customer dimension

CREATE TABLE dim_customer (
    customer_id INT,
    customer_name VARCHAR(100),
    city VARCHAR(100),
    country VARCHAR(100),
    customer_segment VARCHAR(50)
);

Date dimension

CREATE TABLE dim_date (
    date_id INT,
    full_date DATE,
    month INT,
    month_name VARCHAR(20),
    quarter INT,
    year INT
);

The dimensions are relatively denormalized.

For example, the product dimension can contain:

product
   ↓
subcategory
   ↓
category

as columns in the same table:

product_id | product_name | subcategory | category

rather than creating separate tables for every level.

4. Why Use a Star Schema?

The major advantage is simplicity.

Suppose an analyst wants revenue by product category.

The query can be straightforward:

SELECT
    p.category,
    SUM(f.sales_amount) AS revenue
FROM fact_sales f
JOIN dim_product p
    ON f.product_id = p.product_id
GROUP BY p.category;

There is only one dimension join.

This makes the model easier for:

Data analysts
BI developers
Data scientists
Reporting teams
Business users

Microsoft's dimensional-modeling guidance describes star schema as a design optimized for analytical workloads involving filtering, grouping, sorting, and summarization.

. Advantages of Star Schema

Simple queries

Fewer joins generally make analytical SQL easier to write and understand.

Easy for BI tools

Business intelligence tools can navigate a relatively simple model more easily.

Easy for analysts

An analyst doesn't need to understand a complicated hierarchy of dimension tables just to answer a simple business question.

Good analytical performance

The relatively direct fact-to-dimension relationships can make analytical queries efficient, although actual performance depends heavily on the warehouse engine, data volume, partitioning, clustering, indexing, and query design.

Easier maintenance

Adding an attribute can often be as simple as adding a column to a dimension.

6. Disadvantages of Star Schema

Star schemas intentionally introduce some redundancy.

For example:

product_id | product | category
-----------|---------|----------
101        | Laptop  | Electronics
102        | Phone   | Electronics
103        | Tablet  | Electronics
104        | Camera  | Electronics

The word:

Electronics

is repeated.

With very large dimensions, this can increase storage and create additional maintenance considerations.

However, an important modern-data-warehouse lesson is:

Don't automatically normalize everything simply because normalization reduces duplication.

Modern analytical warehouses often make storage relatively inexpensive compared with the human and query complexity introduced by excessive normalization.

The actual trade-off depends on the platform and workload.

. Snowflake Schema ❄️

A snowflake schema starts with the same basic idea as a star schema.

The difference is that dimensions are normalized into additional related tables.

Instead of:

dim_product

product_id
product_name
subcategory
category

you might have:

dim_product
    |
    ↓
dim_subcategory
    |
    ↓
dim_category

Conceptually:

                 dim_category
                       |
                       |
                dim_subcategory
                       |
                       |
fact_sales → dim_product

The dimension has been broken into multiple related tables.

Microsoft describes this as a "snowflake dimension": a normalized set of tables representing a single business entity.

. Snowflake Example

Instead of this:

dim_product

product_id
product_name
subcategory
category

we create:

Product

CREATE TABLE dim_product (
    product_id INT,
    product_name VARCHAR(100),
    subcategory_id INT
);

Subcategory

CREATE TABLE dim_subcategory (
    subcategory_id INT,
    subcategory_name VARCHAR(100),
    category_id INT
);

. Why Use a Snowflake Schema?

Snowflaking can make sense when a dimension contains a genuine hierarchy or reusable structure that benefits from normalization.

For example:

Country
   ↓
State
   ↓
City
   ↓
Store

If these relationships are complex, independently maintained, or reused in meaningful ways, splitting them into related tables may be useful.

Snowflaking can also reduce repeated values in dimensions.

But don't use it simply because:

"Normalization is always better."

That is an important misconception.

A data warehouse has a different purpose from an OLTP system.

. Advantages of Snowflake Schema

Less redundancy

Repeated dimensional attributes can be stored once.

Explicit hierarchies

Relationships such as:

Category → Subcategory → Product

can be represented explicitly.

Easier centralized maintenance in some cases

If a shared hierarchy changes frequently, maintaining it in one normalized structure can sometimes be advantageous.

Useful for complex dimensions

Snowflaking can be appropriate when dimensions contain complex, reusable relationships.

. Disadvantages of Snowflake Schema

More joins

A simple analytical question may require several tables.

More complex SQL

Analysts need to understand the relationships between multiple dimension tables.

More complicated BI models

Longer relationship chains can make semantic models harder to understand and can affect filter propagation and usability. Microsoft specifically notes these considerations when snowflake designs are modeled in Power BI.

Greater modeling complexity

More tables mean more relationships, testing, documentation, and governance.

. Galaxy Schema

Now imagine that your organization doesn't have only one business process.

You have:

Sales
Inventory
Shipping
Returns
Payments

Each process may require its own fact table.

Instead of building one giant fact table, we can create multiple fact tables that share common dimensions.

This is known as a:

Galaxy Schema
Fact Constellation
Fact Constellation Schema

Conceptually:

                    dim_date
                       |
                       |
       ┌──────── fact_sales ────────┐
       |             |              |
       |             |              |
dim_customer   dim_product     dim_store
       |             |              |
       |             |              |
       └────── fact_returns ────────┘
                       |
                       |
                 fact_inventory

The key idea is:

Multiple fact tables share common dimensions.

This is why it is called a constellation: several stars connected through shared dimensions.

The fact-constellation concept is documented as a model where multiple fact tables share dimension tables.

. Example: An E-Commerce Galaxy

Imagine an e-commerce company.

We have three business processes:

Sales

fact_sales

Measures:

quantity
sales_amount
discount

Returns

fact_returns

Measures:

return_quantity
refund_amount

Inventory

fact_inventory

Measures:

stock_quantity
inventory_value

All three can share:

dim_product
dim_date
dim_store

So:

                    dim_date
                       |
          ┌────────────┼────────────┐
          |            |            |
          ↓            ↓            ↓
     fact_sales   fact_returns   fact_inventory
          ↑            ↑            ↑
          |            |            |
          └──────── dim_product ────┘

This gives analysts the ability to analyze several business processes using common dimensions.

. The Critical Concept: Conformed Dimensions

Galaxy schemas introduce an extremely important data-warehousing concept:

Conformed dimensions

A conformed dimension is a dimension that is consistently defined and can be shared across multiple fact tables.

For example:

dim_date

should mean the same thing whether you're analyzing:

Sales
Inventory
Returns
Shipping

Likewise:

dim_product

should have consistent definitions across the business processes that use it.

This allows meaningful cross-process analysis.

For example:

Sales revenue
        +
Inventory levels
        +
Product returns

can be analyzed using the same:

Product
Date
Store

dimensions.

. Star vs Snowflake vs Galaxy

Here's the big picture:

Feature	⭐ Star	❄️ Snowflake	🌌 Galaxy
Main idea	One fact + dimensions	Normalized dimensions	Multiple fact tables
Dimensions	Mostly denormalized	More normalized	Shared/conformed
Fact tables	Usually one or several stars	Usually one or several	Multiple
Query complexity	Low	Medium	Medium–High
Number of joins	Fewer	More	Depends
Redundancy	Higher	Lower	Depends
Ease of use	High	Moderate	Moderate–Low
Best for	Straightforward analytics	Complex dimensions	Multiple business processes
Governance needs	Moderate	Higher	High
Typical use	BI/reporting	Complex hierarchies	Enterprise analytics

These are not absolute performance rules. Actual performance depends on the warehouse engine, data size, physical design, workload, and query patterns.

. So Which One Should You Choose?

This is where data modeling becomes interesting.

Don't start with:

"I need a star schema."

Start with the business requirements.

Ask these questions.

: What business process am I modeling?

If you're modeling:

Sales

a star schema may be sufficient.

If you're modeling:

Sales
Inventory
Returns
Shipping

you may eventually need a galaxy/fact constellation.

Question 2: How complex are my dimensions?

Suppose you have:

Product
 └── Subcategory
      └── Category

Ask yourself:

Does this hierarchy actually need to be normalized?

If not, keeping it inside:

dim_product

may be simpler.

If the hierarchy is independently managed, reused, or genuinely complex, snowflaking may be justified.

: Who will query the data?

This is often overlooked.

If your users are:

Business analysts
BI developers
Data scientists
Managers

simplicity matters.

A model like:

fact_sales
dim_product
dim_customer
dim_date
dim_store

is easier to understand than:

fact_sales
dim_product
dim_subcategory
dim_category
dim_brand
dim_supplier
dim_region
dim_country
...

The schema isn't just a database structure.

It is also a user interface for your data.

. Question 4: How often do dimensions change?

Consider:

Product Category

If category information changes frequently and is maintained centrally, normalization may offer advantages.

But if the dimension is relatively stable, introducing several additional tables may create complexity without enough benefit.

. Question 5: Do Multiple Business Processes Share Dimensions?

Suppose:

Sales
Inventory
Returns

all need:

Product
Date
Store

That's a strong signal that you should think about a fact constellation / galaxy architecture.

Instead of duplicating dimensions, use shared conformed dimensions.

. A Practical Decision Tree

You can simplify the decision process like this:

START
  |
  ↓
What are you modeling?
  |
  ├── One main business process
  |        |
  |        ↓
  |    Start with STAR
  |
  └── Multiple business processes
           |
           ↓
      Shared dimensions?
           |
       ┌───┴───┐
       |       |
      YES      NO
       |       |
       ↓       ↓
    GALAXY   Separate
             dimensional
              models

Then ask:

Are any dimensions genuinely complex or
strongly hierarchical?
          |
      ┌───┴───┐
      |       |
     YES      NO
      |       |
      ↓       ↓
Consider     Keep
SNOWFLAKE    STAR
selectively

. A Better Real-World Approach: Don't Be Dogmatic

One of the biggest mistakes beginners make is thinking:

Project = one schema

In reality, you can combine approaches.

For example:

                    dim_date
                       |
                       |
                  fact_sales
                 /     |     \
                /      |      \
       dim_product   dim_customer   dim_store
            |
            |
       dim_category

Here:

The overall model is a star
dim_product has been partially snowflaked
Multiple fact tables could turn the overall warehouse into a galaxy

This hybrid approach is often more practical than forcing an entire warehouse into one pure pattern.

Modern guidance also recognizes that production warehouses can combine star modeling with selective snowflaking rather than treating the choice as all-or-nothing.

. Strong Data Modeling Principles

Regardless of the schema you choose, remember these principles.

. Define the grain first

Write this sentence:

"One row in this fact table represents ______."

If you cannot complete that sentence clearly, stop modeling.

2. Identify the business process

Ask:

What event are we measuring?

Examples:

A sale
A shipment
A payment
A return
An inventory snapshot

. Separate facts from descriptive attributes

Facts:

quantity
revenue
cost
profit
discount

Dimensions:

customer
product
location
date
employee

4. Think about query patterns

Don't optimize only for theoretical normalization.

Ask:

What questions will analysts actually ask?

. Avoid unnecessary joins

Every additional relationship adds cognitive and technical complexity.

If an analyst needs five joins to answer:

"What were sales by product category?"

your model may deserve another look.

6. Use conformed dimensions

When multiple fact tables share:

Date
Customer
Product
Location

make sure those dimensions have consistent definitions.

. Design for the people using the warehouse

A technically elegant model that nobody understands is not necessarily a successful analytical model.

. The Interview Question You Should Be Ready For

You may hear:

"When would you choose a star schema over a snowflake schema?"

A strong answer is not:

"Star schema is faster."

That's too simplistic.

Instead:

"I would generally start with a star schema when the workload is primarily analytical and users benefit from simple fact-to-dimension relationships. I would consider snowflaking when a dimension contains a hierarchy or structure that has a clear reason to be normalized, such as independent maintenance or significant reuse. If multiple business processes need to share dimensions, I would consider a fact constellation or galaxy design. Ultimately, the choice depends on grain, query patterns, dimension complexity, governance, and the capabilities of the warehouse platform."

That's a much stronger data-engineering answer.

. The Golden Rule

If you remember only one thing from this article, remember this:

Start simple. Add complexity only when the business or data gives you a reason.

A practical starting point for many analytical workloads is:

              dim_customer
                   |
                   |
dim_product — fact_sales — dim_date
                   |
                   |
                dim_store

Start with a clean star.

Then ask:

Does this dimension genuinely need normalization?
                    ↓
              Snowflake it.

And:

Do I have multiple business processes
sharing common dimensions?
                    ↓
          Build a fact constellation.

The goal isn't to build the most complicated schema.

The goal is to build a schema that makes reliable analysis easier.

. Final Takeaway

The three schemas can be thought of as a progression in modeling complexity:

⭐ STAR
Simple dimensional analytics
        ↓
❄️ SNOWFLAKE
More normalized dimensions
        ↓
🌌 GALAXY
Multiple fact tables + shared dimensions

But don't interpret this as:

Star → Snowflake → Galaxy = better

It isn't a ranking.

Each solves a different modeling problem.

⭐ Star

Think:

"Keep analytics simple."

❄️ Snowflake

Think:

"This dimension has a good reason to be normalized."

🌌 Galaxy

Think:

"We have multiple business processes that need shared dimensions."

And above everything else:

Understand the business process, define the grain, understand the users and query patterns, then choose the schema.

That is the real skill behind data warehouse modeling.

Quick Cheat Sheet

STAR
├── Simple
├── Denormalized dimensions
├── Fewer joins
├── Analyst-friendly
└── Great starting point

SNOWFLAKE
├── Normalized dimensions
├── Explicit hierarchies
├── More joins
├── More complex
└── Use when normalization has a clear benefit

GALAXY
├── Multiple fact tables
├── Shared dimensions
├── Multiple business processes
├── Requires strong governance
└── Useful for broader enterprise analytics

The best data warehouse schema isn't the one with the most tables.

It's the one that allows your organization to answer important questions accurately, consistently, and efficiently.

Introduction to Machine Learning: A Beginner's Guide

Ephantus Macharia — Tue, 22 Sep 2026 10:16:59 +0000

Machine learning is about teaching computers to find patterns in data and use those patterns to make predictions or decisions.

So, What Exactly Is Machine Learning?

Let's start with a simple example.

Imagine you have data showing how many hours students studied and the scores they received in an exam.

Hours Studied	Exam Score
1	42
2	48
3	55
4	61
5	68
6	73
7	78
8	84
9	89

If you look at this data, you can probably notice a pattern:

Students who studied more hours generally scored higher.

Now imagine giving this data to a computer and asking:

"Can you learn this pattern and predict the score of a student who studies for 6.5 hours?"

That's where machine learning comes in.

Instead of explicitly programming every possible answer, we give the computer data and an algorithm that can learn from it.

The computer builds a model that represents the pattern it discovered.

We can then use that model to make predictions about new data.

How Machine Learning Works

At a high level, machine learning follows a process like this:

       DATA
         ↓
   Clean & Prepare
         ↓
    Train the Model
         ↓
      Evaluate
         ↓
    Make Predictions

The important thing to understand is that the model is not magically intelligent.

It learns from examples.

The quality and relevance of the data we give it can have a huge impact on the results.

A Simple Machine Learning Example

Let's return to our student example.

We have:

Input: Hours studied
Output: Exam score

In machine learning terminology, the input is called a feature, while the value we're trying to predict is called the target.

So:

Feature
   ↓
Hours Studied
   ↓
Machine Learning Model
   ↓
Predicted Exam Score

For example:

6 hours studied
       ↓
     Model
       ↓
Approximately 73 marks

The prediction doesn't have to be perfect.

Machine learning is often about finding useful patterns and making predictions with an acceptable level of accuracy.

🧩 The Main Types of Machine Learning

Machine learning is commonly divided into three major categories:

Supervised Learning
Unsupervised Learning
Reinforcement Learning

Let's look at each one.

1. Supervised Learning

In supervised learning, we train a model using data where the correct answer is already known.

For example:

Hours Studied → Exam Score

We already know the exam scores in our training data.

The model learns the relationship between the input and the known output.

Common supervised learning problems

Regression

Used when we're predicting a numerical value.

Examples:

Predicting house prices
Predicting sales
Predicting temperature
Predicting exam scores

Classification

Used when we're predicting a category.

Examples:

Spam or not spam
Fraud or not fraud
Pass or fail
Cat or dog

Some popular supervised learning algorithms include:

Linear Regression
Logistic Regression
Decision Trees
Random Forest
Support Vector Machines
K-Nearest Neighbors
Gradient Boosting

2. Unsupervised Learning

What happens when we don't have the answers?

That's where unsupervised learning comes in.

Instead of telling the model what the correct answer is, we give it data and ask it to find patterns or structures.

For example, imagine a supermarket has thousands of customers.

We might have:

Customer
   ↓
Age
Income
Spending
Purchase Frequency

We don't tell the algorithm which customers belong together.

Instead, it can discover groups of customers with similar characteristics.

This is called clustering.

One popular clustering algorithm is K-Means.

Unsupervised learning can be useful for:

Customer segmentation
Finding groups in data
Anomaly detection
Exploring large datasets
Recommendation systems

3. Reinforcement Learning

Reinforcement learning works a little differently.

Instead of learning from a dataset with known answers, an agent learns by interacting with an environment.

Think about teaching a computer to play a game.

        Environment
             ↓
           Agent
             ↓
          Action
             ↓
          Reward
             ↓
          Learn
             ↓
        Try Again

Good actions can receive positive rewards, while poor actions can receive negative rewards.

Over time, the agent learns which actions tend to produce better results.

Reinforcement learning is used in areas such as:

Robotics
Games
Autonomous systems
Resource optimization
Decision-making systems

The Machine Learning Workflow

Learning machine learning isn't just about knowing algorithms.

There is a complete workflow behind a machine learning project.

Step 1: Collect Data

First, we need data.

This could come from:

CSV files
Databases
APIs
Sensors
Websites
Business systems

For example:

customer_data.csv

might contain thousands of customer records.

Step 2: Clean the Data

Real-world data is rarely perfect.

You might find:

Missing values
Duplicate records
Incorrect dates
Outliers
Spelling inconsistencies
Wrong data types

This is where tools like Pandas become extremely useful.

For example:

import pandas as pd

df = pd.read_csv("customer_data.csv")

print(df.head())
print(df.info())
print(df.isnull().sum())

Before training a model, we need to understand what we're working with.

Step 3: Prepare the Data

Now we transform the data into something the machine learning algorithm can use.

This can include:

Selecting relevant features
Encoding categorical variables
Scaling numerical values
Handling missing data
Removing unnecessary columns

For example:

Gender
Male
Female
Female
Male

might need to be converted into numerical values before being passed to some algorithms.

Step 4: Split the Data

One of the most important concepts for beginners is the train-test split.

We generally don't want to train and evaluate a model using exactly the same data.

Instead:

                 Dataset
                    |
          --------------------
          |                  |
       Training            Testing
        Data                Data
          |                  |
          ↓                  ↓
       Learn from       Evaluate on
          data          unseen data

In Python:

from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(
    X,
    y,
    test_size=0.2,
    random_state=42
)

The model learns from the training data.

The test data is then used to see how well the model performs on data it hasn't seen before.

Step 5: Train the Model

Now comes the exciting part.

We choose an algorithm and train it.

For our simple example, we'll use Linear Regression.

from sklearn.linear_model import LinearRegression

model = LinearRegression()

model.fit(X_train, y_train)

The .fit() method is where the model learns from the training data.

Step 6: Make Predictions

Once the model has learned, we can use it to make predictions.

predictions = model.predict(X_test)

print(predictions)

For example, the model might receive:

Hours Studied = 6.5

and return something like:

Predicted Score ≈ 75

The exact result depends on the data and the model.

Creating the Visualization with Python

Here's the Python code used to create the visualization:

import numpy as np
import matplotlib.pyplot as plt
from sklearn.linear_model import LinearRegression

# Create sample data
hours = np.array([
    1, 2, 2.5, 3, 4, 4.5,
    5, 6, 7, 8, 9
]).reshape(-1, 1)

scores = np.array([
    42, 48, 51, 55, 61, 64,
    68, 73, 78, 84, 89
])

# Create and train the model
model = LinearRegression()
model.fit(hours, scores)

# Make predictions
predicted = model.predict(hours)

# Visualize
plt.figure(figsize=(9, 6))

plt.scatter(
    hours,
    scores,
    s=65,
    label="Actual exam scores"
)

plt.plot(
    hours,
    predicted,
    linewidth=2,
    label="Model prediction"
)

plt.title("Study Hours vs Exam Score")
plt.xlabel("Hours Studied")
plt.ylabel("Exam Score")

plt.legend()
plt.grid(alpha=0.25)
plt.tight_layout()

plt.show()

You don't need to understand every line immediately.

At the beginning, focus on the bigger picture:

Create Data
     ↓
Create Model
     ↓
Train Model
     ↓
Make Predictions
     ↓
Visualize Results

The deeper understanding will come as you practice.

What Is Overfitting?

Here's one of the first concepts that confused many beginners when learning machine learning:

Overfitting.

Imagine a student memorizes every question from a practice exam.

They perform extremely well on that exact exam.

But when you give them different questions, their performance drops significantly.

A machine learning model can do something similar.

An overfitted model learns the training data too closely, including noise and unusual patterns.

As a result:

Training Performance → Very High
New Data Performance  → Poor

We usually want a model that can generalize well.

In simple terms:

Don't just memorize the training data. Learn patterns that also work on new data.

How Do We Know If a Model Is Good?

Training a model is only half the job.

We also need to evaluate it.

The evaluation metric depends on the type of problem.

Regression

Common metrics include:

Mean Absolute Error (MAE)
Mean Squared Error (MSE)
Root Mean Squared Error (RMSE)
R² Score

Classification

Common metrics include:

Accuracy
Precision
Recall
F1 Score
ROC-AUC

For example, accuracy can be calculated using:

Correct Predictions
------------------- × 100
Total Predictions

But accuracy isn't always enough.

For some problems, such as fraud detection or medical screening, precision and recall can provide more useful information.

Tools You Will See Everywhere

If you're starting your machine learning journey with Python, you'll quickly encounter these libraries:

NumPy

Useful for numerical operations and arrays.

import numpy as np

Pandas

Useful for working with structured data.

import pandas as pd

Matplotlib

Useful for creating visualizations.

import matplotlib.pyplot as plt

Scikit-learn

One of the most useful libraries for learning traditional machine learning.

import sklearn

Together, these tools give you a strong foundation for many beginner machine learning projects.

A Beginner's Machine Learning Roadmap

If you're wondering "What should I learn next?", don't try to learn everything at once.

A practical path looks like this:

Python
  ↓
NumPy & Pandas
  ↓
Data Cleaning
  ↓
Data Visualization
  ↓
Statistics
  ↓
Supervised Learning
  ↓
Unsupervised Learning
  ↓
Model Evaluation
  ↓
Feature Engineering
  ↓
Machine Learning Projects

Once you're comfortable with these concepts, you can start exploring:

Deep Learning
Natural Language Processing
Computer Vision
Recommendation Systems
Time Series
Large Language Models

But there's no need to rush.

A strong foundation is more valuable than knowing fifty algorithms without understanding what they actually do.

Titanic Survival Prediction

Predict whether a passenger survived based on information such as:

Age
Sex
Passenger class
Fare

Customer Segmentation

Use K-Means to group customers based on:

Income
Spending
Purchase frequency

Spam Detection

Build a classification model that predicts whether a message is spam.

The goal isn't to create a perfect model.

The goal is to understand the entire process:

Problem
  ↓
Data
  ↓
Cleaning
  ↓
Exploration
  ↓
Features
  ↓
Model
  ↓
Evaluation
  ↓
Improvement

The Most Important Lesson

Machine learning isn't simply:

"Give Python some data and let it predict the future."

There's much more to it.

A good machine learning project starts with a good question.

Then you need relevant data.

Then you explore and clean that data.

Then you choose an appropriate model.

Then you evaluate the model.

And finally, you ask whether the result is actually useful.

That's why understanding the process is more important than memorizing algorithms.

Conclusions

Machine learning can look complicated from the outside.

But when you break it down, the foundation is surprisingly approachable.

You start with data.

You look for patterns.

You train a model.

You evaluate what it learned.

And then you use it to make predictions or discover something useful.

You won't understand everything after reading one article and that's completely normal.

The best way to learn machine learning is to take one concept at a time and build something with it.

Start small.

Write the code.

Break it.

Fix it.

Visualize the results.

Then move to the next concept.

That's how the pieces start coming together.

A Beginner’s Guide to Unsupervised Learning in Machine Learning

Ephantus Macharia — Wed, 16 Sep 2026 06:16:54 +0000

What Is Unsupervised Learning?

Unsupervised learning is a type of machine learning where an algorithm learns patterns from data without being given labeled answers.

Imagine you have information about 1,000 customers.

You know things such as:

Age
Annual income
Amount spent
Number of purchases

But you don't have a column telling you what type of customer each person is.

There might not be a column like:

Customer	Income	Spending	Customer Type
A	25,000	15,000	Budget
B	60,000	45,000	Regular
C	90,000	80,000	Premium

Instead, you give the data to an algorithm and ask it to discover patterns or groups.

It might discover:

Group 1 → Low income + low spending
Group 2 → Medium income + medium spending
Group 3 → High income + high spending

You didn't tell the algorithm that these groups existed.

It discovered them from the data.

That's the basic idea behind unsupervised learning.

Supervised vs. Unsupervised Learning

One of the easiest ways to understand unsupervised learning is by comparing it with supervised learning.

Supervised Learning

In supervised learning, we have data with known answers.

Input Data → Known Labels → Machine Learning Model

For example:

House Size + Bedrooms → House Price

The model learns from historical examples where the correct answer is already known.

House Size	Bedrooms	Price
800 sq ft	2	$100,000
1,200 sq ft	3	$160,000
1,800 sq ft	4	$240,000

The model can then predict the price of a new house.

Unsupervised Learning

With unsupervised learning, there is no target label.

Input Data → Algorithm → Hidden Patterns

For example:

Customer Data
      ↓
Machine Learning Algorithm
      ↓
Discover Groups
      ↓
Customer Segments

The key difference is:

Supervised learning learns from known answers, while unsupervised learning searches for patterns without known answers.

How Unsupervised Learning Works

A simple way to visualize the process is:

flowchart LR
    A[Raw Data] --> B[Explore Data]
    B --> C[Choose Features]
    C --> D[Unsupervised Algorithm]
    D --> E[Discover Patterns]
    E --> F[Interpret Results]

The algorithm isn't necessarily trying to predict a specific answer.

Instead, it might be trying to answer questions such as:

Which observations are similar?
Are there natural groups?
Which observations are unusual?
Can we represent this dataset using fewer dimensions?

Why Do We Need Unsupervised Learning?

Real-world datasets aren't always neatly labeled.

Sometimes we have thousands or millions of records but don't know what patterns exist inside them.

Unsupervised learning helps us explore these datasets.

Some common applications include:

Customer Segmentation

Businesses can group customers according to:

Spending habits
Income
Purchase frequency
Product preferences

This can help businesses create more targeted marketing strategies.

Recommendation Systems

Unsupervised techniques can help identify products, movies, songs, or other items that are similar.

For example:

Customer purchases Product A
            ↓
Find similar customers/products
            ↓
Recommend Products B and C

Anomaly Detection

Unsupervised algorithms can identify observations that look very different from normal behavior.

For example, a bank could analyze transaction behavior and identify unusual transactions.

Data Exploration

Sometimes you don't even know what you're looking for.

Unsupervised learning can help you explore a dataset and discover hidden structures.

Main Types of Unsupervised Learning

There are several important techniques you should understand as a beginner.

The three I recommend learning first are:

Clustering
Dimensionality Reduction
Anomaly Detection

Clustering

Clustering is one of the most common applications of unsupervised learning.

The goal is simple:

Group similar data points together.

Imagine having hundreds of points on a graph.

Before clustering, you might see something like:

The algorithm attempts to identify natural groups within those points.

After clustering:

Cluster A          Cluster B          Cluster C

  • • •              • •               • •
 • • • •            • • •             • • •
  • •                • •               • •

Some popular clustering algorithms include:

K-Means
Hierarchical Clustering
DBSCAN

Dimensionality Reduction

Datasets can contain hundreds or even thousands of features.

Imagine having:

Feature 1
Feature 2
Feature 3
Feature 4
...
Feature 100

Trying to visualize 100 dimensions isn't practical.

Dimensionality reduction attempts to reduce the number of features while preserving important information.

A common technique is Principal Component Analysis (PCA).

flowchart TD
    A[100 Features] --> B[PCA]
    B --> C[Important Components]
    C --> D[2D or 3D Visualization]

Other techniques include:

PCA
t-SNE
UMAP

These techniques are especially useful when exploring complex datasets.

Anomaly Detection

Anomaly detection focuses on finding observations that don't look like the rest of the data.

Imagine most transactions from a customer look like this:

$10
$25
$40
$15
$30

Then suddenly:

$5,000

That transaction might be considered unusual.

Anomaly detection algorithms can help identify observations like this.

Some algorithms include:

Isolation Forest
Local Outlier Factor
One-Class SVM

A Practical Example: Customer Segmentation

Let's make things more practical.

Suppose a company has customer data containing:

Annual income
Annual spending

Our goal is to discover whether customers naturally form different groups.

We can use K-Means clustering.

Our dataset might look something like this:

Customer	Annual Income	Annual Spending
A	25,000	15,000
B	30,000	20,000
C	35,000	18,000
D	60,000	45,000
E	65,000	50,000
F	80,000	75,000

We can visualize this data using a scatter plot.

The x-axis represents income, while the y-axis represents spending.

Once K-Means is applied, the algorithm may discover three different groups.

How Does K-Means Work?

K-Means is easier to understand when broken down into steps.

Suppose we want to create 3 clusters.

We tell the algorithm:

n_clusters = 3

The algorithm then roughly follows this process.

Step 1 Choose K

We decide how many clusters we want.

K = 3

Step 2 Initialize Centroids

The algorithm selects initial cluster centers called centroids.

          X
       Centroid

Step 3 Assign Data Points

Each data point is assigned to the closest centroid.

Data Point → Closest Centroid

Step 4 Recalculate Centroids

The algorithm calculates new centers based on the assigned data points.

Step 5 Repeat

The assignment and centroid calculation process continues until the clusters stabilize.

The basic process looks like this:

flowchart TD
    A[Choose K] --> B[Initialize Centroids]
    B --> C[Assign Points to Closest Centroid]
    C --> D[Recalculate Centroids]
    D --> E{Clusters Stable?}
    E -->|No| C
    E -->|Yes| F[Final Clusters]

Let's Implement K-Means in Python

Now let's put the concept into practice.

We'll use:

Pandas
Matplotlib
Scikit-learn

Install them with:

pip install pandas matplotlib scikit-learn

Then import the libraries:

import pandas as pd
import matplotlib.pyplot as plt

from sklearn.cluster import KMeans

Load the Dataset

Let's assume we have a file called:

customer_data.csv

We can load it using Pandas:

data = pd.read_csv("customer_data.csv")

print(data.head())

Select Our Features

For this example, we'll use:

Annual Income
Annual Spending

X = data[
    ["Annual Income", "Annual Spending"]
]

These are the features we want the algorithm to use when creating clusters.

Create the K-Means Model

Let's create three clusters:

kmeans = KMeans(
    n_clusters=3,
    random_state=42
)

Then train the model:

kmeans.fit(X)

We can obtain the cluster assigned to each customer:

data["Cluster"] = kmeans.labels_

Now each customer has a cluster number.

For example:

Customer	Income	Spending	Cluster
A	25,000	15,000	0
B	30,000	20,000	0
C	60,000	45,000	1
D	65,000	50,000	1
E	80,000	75,000	2

Remember:

Cluster 0, 1, and 2 don't automatically mean "bad", "average", and "good".

They are simply labels assigned by the algorithm.

We need to interpret what each cluster represents.

Visualizing Our Clusters

Visualization is one of the most useful parts of machine learning because it allows us to see what the algorithm discovered.

We can create a scatter plot:

plt.scatter(
    X["Annual Income"],
    X["Annual Spending"],
    c=data["Cluster"]
)

plt.xlabel("Annual Income")
plt.ylabel("Annual Spending")

plt.title("Customer Segmentation Using K-Means")

plt.show()

The resulting visualization allows us to see how customers have been grouped.

A simplified representation looks like:

Annual Spending
       ↑
       |
  ● ● ●              Cluster 3
 ● ● ● ●
       |
              ● ● ●
            ● ● ●        Cluster 2
       |
 ● ● ●
● ● ●                  Cluster 1
       |
       +------------------------→ Annual Income

The visualization makes the concept much easier to understand:

Customers that are closer together tend to belong to the same cluster.

Understanding the Distance

K-Means relies heavily on the concept of distance.

A common distance measure is Euclidean distance.

For two points:

A = (x₁, y₁)
B = (x₂, y₂)

The Euclidean distance is:

distance = √((x₂ - x₁)² + (y₂ - y₁)²)

You don't need to memorize the mathematics immediately.

The important idea is:

K-Means uses distance to determine which data points are closest to each centroid.

How Do We Choose the Number of Clusters?

This is one of the most important questions when working with K-Means.

We can't always simply guess:

n_clusters=3

So how do we choose K?

One popular approach is the Elbow Method.

The Elbow Method

The basic idea is to test different values of K and measure how well the clusters fit the data.

We can calculate the inertia for different values of K:

inertia = []

for k in range(1, 11):

    model = KMeans(
        n_clusters=k,
        random_state=42
    )

    model.fit(X)

    inertia.append(model.inertia_)

Then visualize the results:

plt.plot(
    range(1, 11),
    inertia,
    marker="o"
)

plt.xlabel("Number of Clusters")
plt.ylabel("Inertia")

plt.title("Elbow Method")

plt.show()

(https://miro.medium.com/0*aY163H0kOrBO46S-.png)

You may see a graph where the improvement becomes much smaller after a certain point.

That bend is called the elbow.

The elbow can help us choose a reasonable number of clusters.

However, it isn't a magic rule.

Domain knowledge and other evaluation techniques can also be important.

Important Things to Understand

K-Means is powerful, but it isn't perfect.

There are several things beginners should be aware of.

1. You Need to Choose K

K-Means requires you to specify the number of clusters.

KMeans(n_clusters=3)

Choosing the wrong K can produce misleading groups.

2 Feature Scaling Can Matter

Suppose one feature ranges from:

1–10

while another ranges from:

1–1,000,000

The larger-scale feature can dominate distance calculations.

This is why feature scaling is often important.

For example:

from sklearn.preprocessing import StandardScaler

scaler = StandardScaler()

X_scaled = scaler.fit_transform(X)

Then:

kmeans.fit(X_scaled)

3. Clusters Need Interpretation

The algorithm gives you:

Cluster 0
Cluster 1
Cluster 2

But the numbers themselves don't explain what the groups mean.

As a data analyst, you still need to investigate the characteristics of each cluster.

For example:

Cluster 0
→ Lower income
→ Lower spending

Cluster 1
→ Medium income
→ Medium spending

Cluster 2
→ Higher income
→ Higher spending

This is where data analysis and domain knowledge become extremely important.

Real-World Applications

Unsupervised learning appears in many different industries.

Banking

Fraud detection
Customer segmentation
Transaction analysis

Retail

Customer segmentation
Product grouping
Shopping behavior analysis

Entertainment

Music recommendations
Movie recommendations
User behavior analysis

Healthcare

Patient grouping
Identifying unusual observations
Exploring medical datasets

Cybersecurity

Detecting unusual network activity
Identifying suspicious behavior
Finding unusual patterns

Beginner Project Idea

If you're learning unsupervised learning, one of the best projects you can build is a:

Customer Segmentation Project

Your workflow could look like this:

flowchart LR
    A[Find Dataset] --> B[Clean Data]
    B --> C[Explore Data]
    C --> D[Select Features]
    D --> E[Scale Features]
    E --> F[Apply K-Means]
    F --> G[Choose K]
    G --> H[Visualize Clusters]
    H --> I[Interpret Results]
    I --> J[Write Business Insights]

You could investigate questions such as:

Who are our high-value customers?
Which customers have low spending?
Are there natural groups of customers?
Which customer segment should receive a marketing campaign?
How does income relate to spending?

This transforms machine learning from just writing Python code into actual data-driven problem solving.

Conclusion

Unsupervised learning is a powerful part of machine learning because it allows us to discover patterns, relationships, and structures hidden within data even when we don't have predefined labels.
The most important lesson is that machine learning isn't always about predicting a known outcome. Sometimes, the goal is simply to understand the data and discover what it is telling us.

Nobody Tells You This, But Statistics Is the Thing Actually Doing the Work in "Data Science"

Ephantus Macharia — Thu, 10 Sep 2026 11:39:15 +0000

A few months ago I was messing around with a spreadsheet, trying to figure out the average price my dad's paintings were selling for on his website. Simple enough, right? Average the column, done. Except some months he sold one painting for 200,000 shillings and nothing else for weeks. The "average" said his business was doing great. The reality was one lucky sale was carrying the whole story.

That's the moment statistics stopped being a boring word from a textbook and started being the thing standing between me and looking like an idiot in front of actual data.

Here's what I've come to believe , data science gets all the glamour the Python, the models, the "AI did this" headlines but statistics is the part nobody photographs. It's the kitchen, not the dining room. And if your kitchen is a mess, it doesn't matter how nice the table looks.

A model is just a guess with better manners

People love to say machine learning "learns patterns." Sure. But underneath nearly every algorithm linear regression, logistic regression, even the loss functions inside a neural network there's a statistical idea doing the heavy lifting: variance, probability, distributions, correlation. The model isn't magic. It's statistics wearing a hoodie and calling itself AI.

When I built out sample data for a tracker recently, I had to think about what a "realistic" spread of sale prices and dates would actually look like not just random numbers, but numbers shaped the way real-world data is shaped: lumpy, skewed, occasionally weird. That's a statistical decision before it's ever a coding decision.

The dataset lies to you in very polite ways

Outliers. Missing values. Sampling bias. These aren't side topics you cover in week 3 of a course and forget. They're the reason two analysts can look at the exact same CSV file and walk away with opposite conclusions.

I learned this the hard way working through a housing dataset for Nairobi some neighborhoods had ten times more listings than others, just because that's where the data happened to get collected, not because that's where all the housing actually is. Without understanding sampling and bias, I would've confidently reported a "trend" that was really just a data collection accident.

Statistics is the discipline of asking "wait, is this real, or is this just how the data was gathered?" before you ask Python to plot it.

"Significant" doesn't mean what you think it means

This one quietly ruins a lot of beginner analyses. You run a test, you get a result, the result looks different from what you expected, and you announce a finding. But "different" and "statistically significant" are not the same sentence. A 3% bump in sales could be a real shift in customer behavior or it could be noise that would disappear if you reran the week.

Without a grounding in hypothesis testing, p-values, and confidence intervals, data science turns into expensive guessing with extra charts.

For the small-business side of things, this is survival, not theory

I'm involved with a farm business that runs two sides supplying groceries in town, and turning potatoes into fries on the production side. The inventory numbers, the cashflow, the leave days employees take, the spoilage rate on produce none of that becomes useful until you can say things like "this branch's costs vary more month to month than that one" or "this dip looks seasonal, not a real decline."

That's not deep learning. That's basic statistical reasoning, applied to a real business, by someone without a fancy title. And it matters just as much arguably more than anything you'd build for a Kaggle competition.

So what is data science, actually?

Strip away the buzzwords and data science is basically: collect data → understand its shape and limitations (statistics) → build something that uses that understanding to predict or explain (modeling) → check whether your conclusion could be a fluke (more statistics) → communicate it without lying by accident.

Three out of those five steps are statistics with a different outfit on.

The honest takeaway

If you're new to this field and trying to decide where to spend your limited hours more frameworks, more libraries, more flashy visualizations, or actually sitting with distributions, variance, and what a confidence interval is really telling you pick the boring one. The libraries change every two years. The statistical reasoning underneath them doesn't.

Getting Started with Python: A Structured Guide for New Beginners.

Ephantus Macharia — Tue, 19 May 2026 08:40:43 +0000

Python has consistently ranked among the world's most popular programming languages, and for good reason. Its clean syntax, extensive ecosystem, and broad applicability across domains from web development and data science to automation and artificial intelligence make it an exceptionally strong first language for aspiring developers.

However, getting started can feel overwhelming. The sheer volume of tutorials, courses, and conflicting advice online often leaves beginners unsure of where to focus their energy. This article cuts through that noise by providing a deliberate, structured learning path covering the foundational concepts every Python developer needs, presented in the order that makes the most sense for building lasting understanding.

Each section includes practical code examples you can run immediately. Whether you are exploring programming for the first time or transitioning from another discipline, this guide is designed to give you a clear and confident starting point.

1. Install Python

Before anything else, get Python on your machine. Head to python.org, download the latest stable version, and install it. Then write your very first program:

# Your very first Python program
print("Hello, World! I'm learning Python 🐍")

Run it. See those words appear on your screen. That's your rite of passage in programming — welcome aboard!

Tip: Use VS Code with the Python extension. It gives you syntax highlighting, error hints, and a run button right in the editor.

2. Variables and Data Types 📦

Think of variables as labelled boxes that hold information. Python has four basic types you'll use constantly:

# String — text
name = "Amara"

# Integer — whole number
age = 24

# Float — decimal number
height = 1.72

# Boolean — True or False
is_student = True

print(f"Hi, I'm {name} and I'm {age} years old.")
# Output: Hi, I'm Amara and I'm 24 years old.

💡 Python figures out the type automatically no need to declare int x = 5 like in Java or C. This is called dynamic typing, and it makes Python very beginner-friendly.

3. Control Flow — Making Decisions

Programs need to make decisions. That's where if, elif, and else come in.

score = 75

if score >= 90:
    print("🏆 Distinction!")
elif score >= 60:
    print("✅ You passed!")
else:
    print("📚 Keep studying, you've got this.")

# Output: ✅ You passed!

Notice that Python uses indentation (spaces) to define code blocks — no curly braces {} needed. This forces clean, readable code from day one.

4. Loops — Doing Things Repeatedly

Instead of writing the same line 10 times, loops do the repetition for you.

# for loop — great for going through a list
fruits = ["mango", "banana", "avocado"]

for fruit in fruits:
    print(f"I love {fruit}! ")

# while loop — runs as long as a condition is True
count = 1
while count <= 3:
    print(f"Count: {count}")
    count += 1

Use a for loop when you know how many times to repeat. Use a while loop when you're waiting for a condition to change.

5. Functions — Reusable Blocks of Code 🔧

Functions let you write code once and use it many times. This is one of the most important ideas in all of programming.

def greet(name, language="English"):
    if language == "Swahili":
        print(f"Karibu, {name}! 🇰🇪")
    else:
        print(f"Welcome, {name}! 👋")

greet("Brian")
greet("Amara", language="Swahili")

# Output: Welcome, Brian! 👋
# Output: Karibu, Amara! 🇰🇪

Rule of thumb: If you find yourself copy-pasting the same code more than twice, it belongs in a function.

6. Lists and Dictionaries

Python has powerful built-in ways to organize data. Two you'll use constantly:

Lists — ordered, changeable collections:

tasks = ["learn Python", "build a project", "get a job"]
tasks. Append("celebrate 🎉")

print(tasks[0])   # learn Python
print(len(tasks)) # 4

Dictionaries — store data as key-value pairs:

user = {
    "name": "Juma",
    "age": 28,
    "city": "Nairobi"
}

print(user["city"])  # Nairobi
user["age"] = 29     # update a value

Dictionaries are incredibly useful — you'll see them everywhere in real Python projects.

7. Working with Files

Real programs read and write data. Python makes file handling simple and safe:

# Writing to a file
with open("notes.txt", "w") as f:
    f.write("Python is awesome!\n")
    f.write("I'm going to build great things.\n")

# Reading from a file
with open("notes.txt", "r") as f:
    content = f.read()
    print(content)

The with keyword automatically closes the file when the block ends — preventing data corruption or memory leaks. Always use it!

8. Modules and the Standard Library

Python ships with a huge collection of ready-made tools. No need to reinvent the wheel:

import random
import datetime
import math

print(random.choice(["keep going", "you're doing great", "almost there!"]))
print("Today is:", datetime.date.today())
print("√144 =", math.sqrt(144))  # 12.0

Once you're comfortable with the basics, explore popular third-party packages using pip install:

Package	What it does
`requests`	Fetch data from the web
`pandas`	Data analysis and spreadsheets
`flask`	Build simple web apps
`pygame`	Build games
`beautifulsoup4`	Scrape websites

🗺️ Your 7-Week Learning Roadmap

Don't rush — spend real time on each step before moving forward.

Week	Topic	Focus Areas
Week 1	The Basics	Variables, types, `print()`, `input()`, operators
Week 2	Control Flow	`if/elif/else`, `for` loops, `while` loops
Week 3	Functions	`def`, `return`, parameters, scope
Week 4	Data Structures	Lists, dicts, tuples, sets
Week 5–6	Files & Modules	File I/O, stdlib, `pip` packages
Week 7+	Build Something!	CLI tool, quiz app, data script — anything!

Common Beginner Mistakes to Avoid

Forgetting indentation — Python will throw an Indentation Error. Always use 4 spaces (or your editor will handle it).
Confusing = and == — = assigns a value, == compares two values.
Trying to learn everything before building — you don't need to. Start building early, even if it's messy.
Ignoring error messages — read them carefully. Python's error messages are actually very helpful!

Where to Learn More 📖

Here are some free, high-quality resources to keep you going:

Python Official Docs — The source of truth
Real Python — Excellent tutorials and articles
CS50P on edX — Harvard's free Python course
Automate the Boring Stuff — Free book, very practical

Final Thoughts

The most important thing is write code every single day, even if it's just 15 minutes. Reading tutorials is not the same as building things. Break stuff, fix it, Google the error messages, and repeat.

You don't need to know everything before you start building. Start with something small a number guessing game, a to-do list, a weather script and grow from there.

Subqueries vs CTEs in SQL: Master Nested Queries and Write Cleaner, Smarter Code

Ephantus Macharia — Thu, 30 Apr 2026 13:41:06 +0000

If you've been writing SQL for a while, you've hit this wall your query works, but it's a mess of nested parentheses and you can barely read it yourself. That's the moment subqueries and CTEs become your best friends.

Both tools let you break complex logic into manageable steps.

Subqueries

A subquery is a query inside another query. The inner query runs first, and its result is used by the outer query.

The Classic Use Case

Say you want to find all employees earning above the company average:

SELECT name, salary
FROM employees
WHERE salary > (
    SELECT AVG(salary)
    FROM employees
);

The inner query calculates the average first let's say 58,000 then the outer query filters for everyone above that. Simple and effective.

Subquery in the FROM Clause

You can also use a subquery as a temporary table by placing it in the FROM clause:

SELECT dept_name, avg_salary
FROM (
    SELECT department AS dept_name,
           ROUND(AVG(salary), 2) AS avg_salary
    FROM employees
    GROUP BY department
) AS dept_summary
WHERE avg_salary > 60000;

The inner query builds a summary table per department. The outer query then filters it. You can't filter on an aggregate alias directly in WHERE, so this pattern is really handy.

Correlated Subquery

A correlated subquery references the outer query it runs once for every row:

SELECT name, salary, department
FROM employees e
WHERE salary = (
    SELECT MAX(salary)
    FROM employees
    WHERE department = e.department
);

For each employee, the inner query finds the highest salary in their department. This gives you the top earner from every department in one query.

Using IN with a Subquery

-- Employees who have made at least one sale
SELECT name
FROM employees
WHERE id IN (
    SELECT DISTINCT employee_id
    FROM sales
);

And the opposite employees who have never made a sale:

SELECT name
FROM employees
WHERE id NOT IN (
    SELECT employee_id
    FROM sales
    WHERE employee_id IS NOT NULL
);

Always filter out NULLs when using NOT IN. If the subquery returns even one NULL, you'll get zero results a silent bug that's easy to miss.

CTEs (Common Table Expressions)

A CTE lets you name a subquery and place it at the top of your statement using WITH. Same result, but much easier to read and maintain.

Basic Syntax

WITH cte_name AS (
    SELECT ...
    FROM ...
)
SELECT *
FROM cte_name;

Rewriting Our First Example as a CTE

WITH company_avg AS (
    SELECT AVG(salary) AS avg_salary
    FROM employees
)
SELECT e.name, e.salary
FROM employees e, company_avg
WHERE e.salary > company_avg.avg_salary;

Same logic, but now the average calculation has a name. Anyone reading this query immediately knows what company_avg means.

Chaining Multiple CTEs

This is where CTEs really shine you can stack them, each building on the previous:

WITH 
dept_totals AS (
    SELECT department,
           SUM(salary)  AS total_salary,
           COUNT(*)     AS headcount
    FROM employees
    GROUP BY department
),
dept_averages AS (
    SELECT department,
           ROUND(total_salary / headcount, 2) AS avg_salary
    FROM dept_totals
),
top_departments AS (
    SELECT department, avg_salary
    FROM dept_averages
    WHERE avg_salary > 65000
)
SELECT *
FROM top_departments
ORDER BY avg_salary DESC;

Read it top to bottom calculate totals, derive averages, filter the top ones.

Reusing a CTE

One thing subqueries can't do cleanly a CTE can be referenced multiple times in the same query:

WITH high_earners AS (
    SELECT * FROM employees
    WHERE salary > 70000
)
SELECT 'Count'         AS metric, COUNT(*)        AS value FROM high_earners
UNION ALL
SELECT 'Total Payroll',           SUM(salary)              FROM high_earners
UNION ALL
SELECT 'Average Salary',          ROUND(AVG(salary), 2)    FROM high_earners;

One definition, three uses. With a subquery you'd repeat the same block three times.

Recursive CTE For Hierarchical Data

CTEs have one trick subqueries simply cannot do recursion. Perfect for org charts, category trees, or any parent-child relationship:

WITH RECURSIVE org_chart AS (
    -- Start: the CEO (no manager above them)
    SELECT id, name, manager_id, 1 AS level
    FROM employees
    WHERE manager_id IS NULL

    UNION ALL

    -- Recurse: find everyone who reports to someone already in the CTE
    SELECT e.id, e.name, e.manager_id, oc.level + 1
    FROM employees e
    JOIN org_chart oc ON e.manager_id = oc.id
)
SELECT name, level
FROM org_chart
ORDER BY level, name;

Output:

name	level
Sarah (CEO)	1
Alice	2
Bob	2
Charlie	3
Diana	3

The query keeps joining until no more reports are found. No loops, no procedural code just SQL.

Takeaways

Subqueries are great for quick, inline logic filtering with IN, comparing against an aggregate, or building a derived table
CTEs shine when your logic is multi-step, needs to be reused, or involves recursion
Both are tools for breaking complex problems into steps picking one is about readability and context, not right vs wrong

How to Publish a Power BI Report and Embed It on a Website

Ephantus Macharia — Wed, 29 Apr 2026 10:46:52 +0000

A Step-by-Step Guide Using the Electronic Sales Data Dashboard

Introduction

Microsoft Power BI is a leading business intelligence platform that transforms raw data into rich, interactive dashboards. Once you've built a report like the Electronic Sales Data Dashboard used in this guide the next step is sharing it with stakeholders by publishing it to Power BI Service and embedding it on a website for broader access.

This guide walks through every stage of that process, with steps tailored directly to the Electronic Sales Data Dashboard (.pbix), which contains three report pages:

Page	Description
Dashboard	KPI cards, bar charts, line chart, pie chart, slicers, and a product table
Profit Margin (City, Product)	Column and bar charts breaking down profit margin by city and product
Geographical Sales Analysis	Interactive maps showing sales by city and country

Step 1 Create a Workspace in Power BI Service

Before publishing, you need a workspace a collaborative container in the cloud where your reports and datasets live.

How to do it:

Open your browser and go to https://app.powerbi.com.
Sign in with your Microsoft 365 or Power BI account.
In the left navigation panel, click Workspaces.
Click + New workspace at the top right.
In the panel that slides open:
- Enter a Name (e.g., Electronics Sales Analytics)
- Optionally add a Description (e.g., Sales performance reports for electronic products)
- Select a License mode — choose Pro or Premium per user if you need to share with others outside your organisation
Click Save.

Step 2

Upload and Publish the Report from Power BI Desktop

With the workspace ready, publish the .pbix file from Power BI Desktop.

How to do it:

Open the file Electronic_Salesdata_Dashboard.pbix in Power BI Desktop.
In the Home ribbon, click the Publish button (cloud icon).
A dialog box will appear — Select a destination:
- Choose the workspace you just created (e.g., Electronics Sales Analytics)
Click Select.
Power BI Desktop will upload the report and data model to the cloud.
Once complete, a success message appears with a link: Open 'Electronic_Salesdata_Dashboard' in Power BI.
Click the link to verify all three pages — Dashboard, Profit Margin (City, Product), and Geographical Sales Analysis — are rendering correctly in the browser.

Step 3

Generate the Embed Code

Once the report is live in Power BI Service, you can generate an iframe embed code.

How to do it:

Open the report in Power BI Service at app.powerbi.com.
Click File in the top menu bar.
Select Embed report → Publish to web (public).
A warning dialog will appear confirming the report will be publicly accessible — click Create embed code to proceed.
The next dialog presents two things:
- A shareable link (for direct URL sharing)
- An HTML iframe snippet ready to paste into any webpage

Example embed snippet generated:

<iframe
  title="Electronic Sales Data Dashboard"
  width="1140"
  height="541.25"
  src="https://app.powerbi.com/reportEmbed?reportId=YOUR_REPORT_ID&autoAuth=true&ctid=YOUR_TENANT_ID"
  frameborder="0"
  allowFullScreen="true">
</iframe>

Step 4

Embed the Report on Your Website

Paste the iframe into your HTML. Below are two approaches — a fixed-size embed and a fully responsive one.

Option A — Fixed-size embed (simplest)

<iframe
  title="Electronic Sales Data Dashboard"
  width="1140"
  height="541"
  src="https://app.powerbi.com/reportEmbed?reportId=YOUR_REPORT_ID&autoAuth=true&ctid=YOUR_TENANT_ID"
  frameborder="0"
  allowFullScreen="true">
</iframe>

Option B — Responsive embed (recommended)

<!-- Responsive Power BI embed wrapper -->
<div style="position: relative; padding-top: 56.25%; overflow: hidden;">
  <iframe
    title="Electronic Sales Data Dashboard"
    src="https://app.powerbi.com/reportEmbed?reportId=YOUR_REPORT_ID&autoAuth=true&ctid=YOUR_TENANT_ID"
    style="position: absolute; top: 0; left: 0; width: 100%; height: 100%;"
    frameborder="0"
    allowFullScreen="true">
  </iframe>
</div>

Embedding a Specific Page

To load a specific report page on page load, append the pageName parameter to the src URL:

Report Page	URL Parameter to Append
Dashboard	`&pageName=ReportSection`
Profit Margin (City, Product)	`&pageName=ReportSection1`
Geographical Sales Analysis	`&pageName=ReportSection2`

Example:

src="https://app.powerbi.com/reportEmbed?reportId=YOUR_REPORT_ID&pageName=ReportSection2"

Report Pages Overview

Page 1 _ Dashboard

The main dashboard contains the following visuals:

3 KPI Cards — Total Sales, Total Profit, Profit Margin
Bar chart — Sales by Product Name
Bar chart — Sales by Region
Bar chart — Sales by Product Category
Line chart — Sales over time (by Quarter and Month)
Pie chart — Sales by Region and Country
2 Slicers — Filter by Region and by Customer Name
Table — Product Name list

Page 2_ Profit Margin (City, Product)

Column chart — Total Sales by Country
Clustered column chart — Profit Margin by City
Bar chart — Profit Margin by Product Name
2 Slicers — Filter by Product Name and by City

Page 3 _ Geographical Sales Analysis

Bubble map — Sales Amount sized by city
Bubble map — Sales Amount sized by country

Key Insights & Best Practices

1. Use Premium Capacity for Scale

Power BI Premium capacity lets you embed reports without requiring every viewer to have a Pro licence. This is essential for public-facing websites where visitor volumes are unknown.

2. Apply Row-Level Security (RLS)

Before publishing this dashboard to a public or semi-public audience, define RLS roles in Power BI Desktop (Modelling → Manage roles) to restrict which rows of the fact, Customer, or Location tables individual users can see.

3. Schedule Data Refresh

The sales data in this dashboard is static until refreshed. Set up a data gateway and configure a scheduled refresh (daily or weekly) in the workspace settings so the embedded report always reflects current figures.

4. Make the Embed Responsive

Always use the padding-top wrapper approach (Option B above) so the dashboard scales cleanly on mobile, tablet, and desktop screens without horizontal scrollbars.

5. Control Which Page Loads First

Use the pageName URL parameter to decide whether visitors land on the summary Dashboard, the Profit Margin drill-down, or the Geographical map view depending on your audience.

6. Monitor Usage

Use the Usage Metrics report in the workspace to track how many users view the embedded report, which pages they visit most, and peak viewing times.

7. Secure Sensitive Sales Data

For any scenario involving authenticated users or confidential sales figures, replace "Publish to web (public)" with the Power BI Embedded (Azure) approach. This uses a service principal and generates tokens server-side, keeping data protected behind authentication.

Summary

Step	Action
1	Create a workspace in Power BI Service
2	Publish `Electronic_Salesdata_Dashboard.pbix` from Power BI Desktop
3	Generate an iframe embed code via File → Embed report → Publish to web
4	Paste the responsive frame snippet into your website HTML

With these four steps, your Electronic Sales Data Dashboard complete with KPI cards, regional sales charts, profit margin analysis, and geographic maps is live and fully interactive on your website.

Understanding Data Modelling in Power BI: Joins, Relationships, and Schemas.

Ephantus Macharia — Mon, 30 Mar 2026 18:39:36 +0000

Data modelling is the process of defining how your tables are structured and how they relate to one another. Instead of dumping everything into one giant flat table, you organise your data into multiple purpose-built tables and link them together. Power BI then uses those links to filter, aggregate, and display data correctly across your entire report.

Joins

How Tables Connect at the Query Level
A join is how you combine rows from two tables based on a shared column. In Power BI, joins happen inside Power Query before the data even hits your model.

There are four main join types:

Inner Join

Returns only rows that have a match in both tables. If a farmer exists in your Sales table but not in your Customers table, that row is dropped.

You only use when you want complete, matched records.

Left Outer Join

Returns all rows from the left table, plus any matches from the right. Unmatched rows from the right come back as nulls.

you use it when you want to keep all records from your primary table regardless of whether a match exists.

Right Outer Join

The mirror of a left join keeps all rows from the right table and fills nulls where the left has no match.

Full Outer Join

Returns all rows from both tables. Nulls appear wherever there's no match on either side.

Use when you want a complete picture and you are willing to handle the nulls.

In Power Query, you access these through Home → Merge Queries, then pick your join type from the dropdown.

Relationships

How Tables Connect in the Model
Once your tables are loaded, relationships are how Power BI understands the links between them inside the data model. Unlike joins (which physically merge rows), relationships are virtual they let Power BI filter one table through another without duplicating data.

You define relationships in the Model view, and they work automatically whenever you use fields from multiple tables in a visual.

The Three Relationship Types

One-to-Many (1:*) —The most common type. One row in Table A matches multiple rows in Table B. Example: one County matches many farmers. One Product matches many sales transactions.

One-to-One (1:1) Each row in Table A matches exactly one row in Table B. Example: one Employee record maps to one HR Profile. Rare in practice, often a sign you could just merge the tables.

Many-to-Many (:) Multiple rows in Table A match multiple rows in Table B. Example: one Order can contain many Products, and one Product can appear in many Orders. Power BI supports this natively, but it can create ambiguous filter paths best handled with a bridge table in between.

Filter Direction

Every relationship has a filter direction it controls which way filters flow between tables.

Single direction

filters flow one way only (from the "one" side to the "many" side). This is the safe default.
Both directioners flow both ways, Powerful, but can cause unexpected results in complex models. Use sparingly.
How Joins and Relationships Are Connected
This is where it clicks: joins and relationships solve the same problem at different stages of your pipeline.

A join in Power Query physically combines two tables into one before loading. A relationship in the model keeps tables separate but links them logically. The choice between them comes down to this:

Join (Power Query) Relationship (Model)
When it runs At data refresh / load time At query / visual render time
Result One merged table Two separate linked tables
Best for Lookup columns you need in the fact table Filtering and aggregating across tables
Performance Can increase table size Keeps model lean
A common pattern: use a join to bring a single lookup column (like County Region) into your fact table, while using relationships to connect your full dimension tables (Date, Product, Customer) for filtering.

Schemas

How You Arrange Your Tables
A schema is the overall blueprint of your model how many tables you have and how they're arranged. There are two schemas you'll encounter most in Power BI.

Star Schema

The star schema has one central fact table surrounded by several dimension tables. The fact table holds your numbers (revenue, yield, quantity). The dimension tables hold your descriptive context (who, what, when, where).

dim_Date ─┐
dim_County ─┤
dim_CropType ─┼──── fact_FarmerProduction
dim_Season ─┤
dim_SoilType ─┘

Every dimension connects directly to the fact table in a one-to-many relationship. This is the recommended structure for Power BI it's simple, fast, and the DAX engine is optimised for it.

Snowflake Schema

The snowflake schema normalises the star further by splitting dimension tables into sub-tables. Instead of one flat dim_Product table, you might have dim_Product → dim_Category → dim_SubCategory.

It reduces data duplication but adds complexity. In Power BI, the extra join hops can slow down queries and make DAX harder to write. Unless you have a strong reason (very large dimension tables with many repeated values), stick with the star schema.

Flat Table

A single flat table with no relationships is fine for small, simple datasets. If you're working with under 10,000 rows and don't need to join to anything else, a flat table keeps things uncomplicated. The moment you need to combine data sources, or your dimension data is repeated hundreds of times, move to a star schema.

Putting It All Together

Load your raw tables into Power Query
Use joins to pull in any lookup values you need directly in the fact table (e.g., a region name from a county lookup)
Load separate dimension tables  Date, County, Crop Type, Season — without merging them

Define relationships in Model view between your fact table and each dimension (one-to-many, single-direction filter)
Arrange your model as a star schema — fact table in the centre, dimensions around it

Concept : What it does, Where in Power BI

Inner join: Keep only matched rows  Power Query → Merge
Left join:  Keep all left rows + matches    Power Query → Merge
One-to-many relationship: Link dimension to fact table  Model view
Many-to-many relationship:Complex links, use bridge table   Model view
Star schema:    Fact + flat dimensions  Model view layout
Snowflake schema:Fact + normalised sub-dimensions   Model view layout

Conclusion

Data modelling in Power BI isn't about complexity, it's about clarity. A well-structured star schema with clean one-to-many relationships will outperform a messy flat table every time, both in query speed and in how easy your DAX becomes to write and maintain.

Start with your fact table, build your dimensions, connect them with single-direction relationships, and keep it flat.

From confusion to clarity;How Excel-Data analysis has Transformed my skills

Ephantus Macharia — Fri, 27 Mar 2026 09:54:01 +0000

Introduction

The Dataset That Changed Everything
I will be honest. When I first opened the Jumia Kenya product dataset, I had no idea where to begin. There were 115 rows of product data, but the prices were buried inside text strings like "KSh 1,525", the ratings were written as "4.5 out of 5", the review counts were all negative numbers, and a full 50 per cent of the rows had no rating information at all. It looked less like a dataset and more like a problem waiting to punish me.
That experience, the confusion, the slow process of fixing each issue one by one, and the moment when the data finally came alive is exactly what this article is about. Learning Excel data analysis did not just teach me a set of formulas. It changed the way I think, the way I approach problems, and the way I trust my own conclusions. This is my story of how that happened, told through the real data I cleaned, interpreted, and turned into a working dashboard.

Step One:

Working on Messy Data

What Real-World Data Taught Me First

Real-world data is rarely clean I learned that the hard way!
Data analysis means looking at clean and beautiful tables and extracting insights or so I thought!
Well, I was wrong most of the work happens before even a single chart is drawn!

The 6 Problems I Found in the Jumia Dataset
Prices were stored as text every price had a "KSh" prefix attached to it.
Ratings were written as sentences "4.5 out of 5" instead of just "4.5".
Review counts were negative every review count was entered as a minus value.
One product had a price range "KSh 1,620 – KSh 1,980" instead of a single value.
Percentage Discounts were stored as text "38%" instead of a real number.
58 products had no rating at all half of the products were blank for ratings!

What This Taught Me

Every single problem needed a deliberate solution in Excel.
Not only did I learn how to solve these problems, but I also learned how to solve them permanently!
The order in which I solved these problems also taught me how to diagnose the problem before even touching the data!.

=VALUE(SUBSTITUTE(SUBSTITUTE(A2,"KSh",""),",",""))   // Strip KSh and commas from price text, then convert to a true number
=VALUE(LEFT(A2,3))   // Extract just the numeric rating from "4.5 out of 5."

=ABS(A2)   // Convert negative review counts to positive values
=IF(ISBLANK(A2),"No Rating",IF(A2<3,"Poor",IF(A2<4.5,"Average","Excellent")))   //

What Actually Surprised Me About Data Cleaning

The difficulty was not the surprising part. Each fix is straightforward once you know the function
What surprised me is the amount of change the data underwent after the fixes The column of seemingly random characters, the wall of meaningless text, suddenly looked like: ✅ Sortable ✅ Calculable ✅ Chart-ready

The Real Meaning of Data Cleaning

Data cleaning is not about correcting errors. It is about transforming noise into a signal
The moment the data underwent its transformation is the moment I understood the true meaning of cleaning
No explanation or book can do justice to the experience of going through the transformation yourself

Skill Gained: What I Do Differently Now

I instinctively inspect every new dataset for the following six things before I do anything else
It takes five minutes to inspect
It saves hours of confusion
This is not something I learned by reading about it. This is something I learned by going through the experience once.

Step Two:

Creating Meaning with Formulas Data Enrichment

Clean data tells you what exists. Enriched data tells you what it means
This is where Excel formulas started feeling genuinely powerful
I was no longer just correcting errors; I was creating knowledge

New Columns I Added to the Dataset
Discount Amount (KES)

Formula: Current Price subtracted from Old Price
Reveals the real savings in shillings, not just a percentage
Why it matters:

64% off a KES 199 item = only KES 354 saved
39% off a KES 3,750 drill = KES 2,393 saved
Percentage figures alone were hiding this distinction entirely

Rating Category

Used an IFS formula to classify every product into a clear tier:

Poor — rating below 3
Average — rating between 3 and 4.4
Excellent — rating of 4.5 and above

Turns a raw number into a label anyone can read instantly

Discount Category

Grouped every product into one of three discount tiers:

Low Discount — below 20%
Medium Discount — between 20% and 40%
High Discount — above 40%

Why These Columns Mattered

Rating Category and Discount Category became the foundation of almost every comparison in the final analysis
Without them, grouping and comparing products would have required manual sorting every single time
With them, a single AVERAGEIF or COUNTIF formula answers any group-level question instantly

=IFS(D2<3,"Poor",D2<4.5,"Average",D2>=4.5,"Excellent
=IFS(C2<20,"Low Discount",C2<=40,"Medium Discount",C2>40,"High Discount")

This step taught me something important about data analysis: the raw data rarely tells the whole story. The enriched data does. A number like 3.7 says very little on its own. The label "Average" is placed alongside it, in context with 114 other products.

Step Three:

Charts

After cleaning and enriching the data, I ran a full descriptive analysis using AVERAGE, COUNTIF, AVERAGEIF, and CORREL functions. But the moment the analysis truly came alive was when I built the visualizations. The charts below were produced directly from the cleaned Jumia dataset, and each one taught me something that the tables had kept hidden.

This chart showed me immediately that 65 out of 115 products more than half carry a discount above 40%. At first, I assumed this meant they were the best-performing products.

The rating category chart was the most visually striking finding of the entire analysis. The grey "No Rating" segment representing 50% of all products dominates the chart. This is not just a design choice; it is a data quality alarm. Half the products in this dataset have never been reviewed. Any conclusion I draw about ratings applies only to the other half, and I must clearly state this every time I present findings. Learning to read that caveat into a chart and to communicate it honestly felt like a genuine step forward as an analyst.

The top 10 discount chart delivered a surprise. The highest-discounted products are not expensive electronics or premium appliances. They are small everyday items: a bottle opener, a keychain, crochet needles, and a pillowcase. The product with the single highest discount in the entire dataset (64% off) costs just KES 199. That is a powerful reminder that percentage discounts and absolute value are entirely different things, a lesson I learned from the data, not from a textbook

Average rating and average reviews by discount category

Finding that medium-discount products outperform high-discount ones on both measures
This final chart is the one I am most proud of, because it contradicts the most natural assumption in the entire dataset. I expected high-discount products to have the most reviews and the highest ratings. More discounts should mean more buyers, and more buyers should mean more reviews. The data said the opposite. Medium-discount products (20–40% off) had an average rating of 4.28 and 15.3 reviews. High-discount products rated only 3.61 and averaged 11.1 reviews. The correlation between discount percentage and reviews was just −0.14, essentially zero. Higher discounts do not drive customer engagement. Product quality does.

Products Analysed-115
Avg Current Price-1174
Avg Discount-36.96%
Avg Rating-3.89/5

How This Has Made Me a Better Analyst and a Better Thinker
Working through this project from raw CSV to finished dashboard gave me five concrete skills that I did not have before, and that I now use every time I open a spreadsheet.
1) Skills This Project Built

Diagnose the first scan for broken data before touching anything
Write self-explanatory formulas SUBSTITUTE, VALUE, ABS, IFS, AVERAGEIF
Trust the data, not your expectations correlation was −0.14, not what I hoped
Charts are not decoration every chart reveals what the table could not
Declare data gaps honestly 50% missing ratings must be stated. not hidden

The Spreadsheet That Taught Me to Think

Here I Started vs Where I finished
Started, finished 115 rows of messy data. A fully formatted Excel dashboard. Did not know VLOOKUP. Can clean, enrich, analyse, and visualise. Assumed data was neat. Know how to diagnose and fix real problems. Trusted percentages. Know how to check the numbers behind them

What This Project Actually Taught Me

Not just which function to use, but when and why
Not just how to build charts, but how to read and explain them
Not just Excel skills, but thinking skills

Things That Made It Real

Excel gave me the tools
The Jumia dataset gave me the practice
This course gave me the framework

I will carry these skills into every dataset, every report, and every decision I face from here on.

Data Analysis Setup: Tools, Installation, and Best Practices

Ephantus Macharia — Mon, 23 Mar 2026 06:38:00 +0000

In previous centuries, we used to decide as we always used to: based on a gut feeling, a coin toss or a prayer. However, we can not afford to guess in a world that is changing this rapidly. However, it is feared that the analysis of data removes humanity in the decision-making process- that it reduces individuals to statistics. I want to argue the opposite. Proper data analysis is the most understanding thing that you can do. It prevents the projection of personal prejudices on the world and makes one see people as they are, not as you think they are. It is not a de-humanizing of the process, it is simply a human element that has gotten right at last.

Below are various tools that will help you kickstart your journey of Data Analysis:

EXCEL INSTALLATION GUIDE

Step 1

Steps into Installaling Excel on windows

1.Go to the official page of MICROSOFT OFFICE Website:https://www.office.com/

2 . Sign in with your Microsoft Account.

Click install Office

4 Open the downloaded OfficeSetup.exe file.

5 Wait for the installation to complete.

6.After installation:

7 Open Microsoft Excel from the Start Menu.

8 Sign in to activate the software.

ANACONDA INSTALLATION GUIDE.

Steps into Installing Anaconda On windows

Anaconda-platforms is a tool developed to design to securely build, and deploy artificial intelligence and machine learning models, primarily using Python and open-source software.

Step 2

1 .Go to the official Anaconda website: https://www.anaconda.com

2 .Download the Anaconda Distribution for Windows.

3 .Open the downloaded .exe installer.

4 .Click Next → Agree to License.

5 .Choose Just Me installation.

6 .Select the installation location (default recommended).

7 .Click Install.

8 .After installation, click Finish.

9 .To verify installation:

10 .Open Anaconda Navigator from the Start Menu