Forem: Mburu

SQL Joins & Window Functions: The Skills That Separate Analysts from Beginners

Mburu — Tue, 03 Mar 2026 13:21:05 +0000

You have learned the basics of SQL - 'SELECT', 'WHERE', 'GROUP BY' and now you are ready to level up: to move from I know SQL to I can analyze data. I will help you understand Joins and Window Functions and with these you`ll be able to answer much more complex questions from your data.

PART 1: SQL JOINS

Imagine you have two tables:

One table has Customers
Another table has Orders

If you want to know which customer made which order,
you will need a JOIN.

What Is a JOIN?

A Join lets you combine these two tables so you can see the customer alongside their order all in one result.
In simple terms: A Join connects rows from two or more tables based on a related column between them.

Example Tables

Customers Table

customer_id	name
1	Shujaa
2	Achieng
3	Brian

Orders Table

order_id	customer_id	amount
101	1	5000
102	1	3000
103	2	7000

INNER JOIN

This is the Most Common join and returns only the rows where there is a match in both tables.

sql SELECT c.name, o.order_id, o.amount FROM Customers c INNER JOIN Orders o ON c.customer_id = o.customer_id;

What Happens?

Shujaa → 2 orders
Achieng → 1 order
Brian → No orders → NOT shown

Only records that match in both tables are returned.

LEFT JOIN

Returns all rows from the left table, and the matching rows from the right table. If there's no match, you get NULL on the right side.

sql SELECT c.name, o.order_id, o.amount FROM Customers c LEFT JOIN Orders o ON c.customer_id = o.customer_id;

What Happens?

Shujaa → 2 orders
Achieng → 1 order
Brian → NULL values for order columns

LEFT JOIN keeps all customers even those who haven`t placed an order yet. Those customers will show up with NULL in the order column.

RIGHT JOIN

The opposite of LEFT JOIN. Returns all rows from the right table, and matching rows from the left.

SELECT 
    c.name,
    o.order_id,
    o.amount
FROM Customers c
RIGHT JOIN Orders o
    ON c.customer_id = o.customer_id;

Keeps all orders even if a customer is missing.
Pro tip: RIGHT JOINs are less common. Most developers just flip the table order and use a LEFT JOIN instead: same result, easier to read.

FULL OUTER JOIN

It has give me everything vibes. Returns all rows from both tables, with NULL where there's no match on either side.

SELECT 
    c.name,
    o.order_id,
    o.amount
FROM Customers c
FULL OUTER JOIN Orders o
    ON c.customer_id = o.customer_id;

Keeps all records from both sides.

CROSS JOIN

Every combination possible

Returns the Cartesian product every row from the left table paired with every row from the right table.

SELECT c.name,o.amount
FROM customers
CROSS JOIN amounts;

If Table A has 100 rows and Table B has 100 rows, you get 10,000 rows back so use with caution!

Why JOINS Matter in Real Life

Joins allow you to:

Connect sales with products
Connect patients with visits
Connect employees with departments
Connect transactions with accounts

Without joins, analysis is incomplete.

PART 2: WINDOW FUNCTIONS

If JOINs combine tables, Window functions analyze data without collapsing it. A regular GROUP BY aggregation collapses your rows into one summary row per group. But what if you want the aggregated value AND the individual row at the same time?

That's exactly what Window Functions do.

What Is a Window Function?

A Window Function performs a calculation across a set of rows related to the current row without collapsing them into one.
Think of it like looking through a sliding window across your data. The window moves row by row, and for each row, it calculates something based on a defined group of surrounding rows.

Basic Example: Total Sales Per Customer

SELECT 
    customer_id,
    order_id,
    amount,
    SUM(amount) OVER (PARTITION BY customer_id) AS total_per_customer
FROM Orders;

What Is Happening?

PARTITION BY customer_id
= Group by customer internally

But it does NOT remove rows.

Instead, it adds a new column showing:

Shujaa → 8000 (5000 + 3000)
Achieng → 7000

Each order still appears individually.

Common Window Functions

ROW_NUMBER()

Assigns a sequential number to each row within a partition.

SELECT 
    customer_id,
    order_id,
    amount,
    ROW_NUMBER() OVER (
        PARTITION BY customer_id
        ORDER BY amount DESC
    ) AS rank_per_customer
FROM Orders;

This helps answer:

What is each customer’s highest purchase?
Which transaction came first?

RANK() and DENSE RANK()

Both rank rows, but handle ties differently:

RANK() — Skips numbers after a tie (1, 2, 2, 4)
DENSE_RANK() — Does NOT skip numbers after a tie (1, 2, 2, 3)

SELECT 
    amount,
    RANK() OVER (ORDER BY amount DESC) AS sales_rank
    DENSE RANK() OVER (ORDER BY amount DESC) AS sales_dense_rank
FROM Orders;

If two orders have same amount → same rank.

Running Total

SELECT 
    order_id,
    amount,
    SUM(amount) OVER (
        ORDER BY order_id
    ) AS running_total
FROM Orders;

Shows cumulative growth over time.

Very powerful for dashboards.

LAG() and LEAD()

Look backwards and forwards

LAG() — Gets the value from the previous row
LEAD() — Gets the value from the next row

SELECT
  month,
  revenue,
  LAG(revenue, 1) OVER (ORDER BY month) AS prev_month_revenue,
  revenue - LAG(revenue, 1) OVER (ORDER BY month) AS month_over_month_change
FROM sales;

Use case: Calculate month-over-month revenue growth without a self-join.

SUM(), AVG(), COUNT() as Window Functions

Running totals and moving averages

Yes, your familiar aggregate functions can be used as window functions too!

-- Running total of sales
SELECT
  order_date,
  amount,
  SUM(amount) OVER (ORDER BY order_date) AS running_total
FROM orders;

-- Moving average over the last 3 rows
SELECT
  order_date,
  amount,
  AVG(amount) OVER (
    ORDER BY order_date
    ROWS BETWEEN 2 PRECEDING AND CURRENT ROW
  ) AS moving_avg_3
FROM orders;

NTILE()

Divide rows into buckets

Splits rows into N equal groups (quartiles, deciles, percentiles, etc.).

SELECT
  name,
  salary,
  NTILE(4) OVER (ORDER BY salary DESC) AS salary_quartile
FROM employees;

Use case: Segment customers into top 25%, second 25%, etc.

Window Functions - Key Points Summary

Function	What It Does
`ROW_NUMBER()`	Unique sequential number per row
`RANK()`	Rank with gaps after ties
`DENSE_RANK()`	Rank without gaps after ties
`LAG()`	Value from a previous row
`LEAD()`	Value from a next row
`SUM() OVER()`	Running total
`AVG() OVER()`	Moving average
`NTILE(n)`	Divide rows into n buckets

JOIN vs WINDOW FUNCTION

Feature	JOIN	Window Function
Combines tables	✅ Yes	❌ No
Keeps all rows	Depends	✅ Yes
Used for ranking	❌	✅ Yes
Used for cumulative totals	❌	✅ Yes

They solve different problems.

Real Business Example 1

Imagine you're analyzing hospital data:

You might:

JOIN patients with visits
JOIN visits with prescriptions
Then use window functions to:
- Rank top diseases
- Calculate running monthly admissions
- Find most expensive prescriptions per patient

This is how analysts think.

Real Business Example 2

Let's say you work at an e-commerce company and want to answer this question:

For each customer, show their total orders, their most recent order date, and rank them by total spend.

SELECT
  c.name,
  COUNT(o.id) AS total_orders,
  MAX(o.order_date) AS last_order_date,
  SUM(o.amount) AS total_spend,
  RANK() OVER (ORDER BY SUM(o.amount) DESC) AS spend_rank
FROM customers c
LEFT JOIN orders o ON c.id = o.customer_id
GROUP BY c.name
ORDER BY spend_rank;

This single query uses both a LEFT JOIN (to include customers with no orders) and a Window Function (RANK()) to rank customers by spend - all in one clean result.

Key Concepts Explained Simply

JOIN = Attach Information

-You have information in different places.
JOIN brings them together.
-Master INNER, LEFT, and FULL OUTER and you'll cover 95% of real-world use cases.

WINDOW FUNCTION = Calculations that need context from surrounding rows without losing your individual row data.

The OVER() clause is the heart of every window function. Learn PARTITION BY and ORDER BY inside it first.
LAG() and LEAD() are underrated gems. They eliminate the need for messy self-joins when comparing rows.
You can combine Joins and Window Functions in the same query for powerful, real-world analytics

Beginner Mistakes to Avoid

❌ Using GROUP BY when you need row-level detail
❌ Forgetting the ON condition in JOIN
❌ Mixing up PARTITION BY and GROUP BY
❌ Not ordering inside window functions when needed

What You Should Remember

JOINs combine data from multiple tables.
INNER JOIN returns matches only.
LEFT JOIN keeps everything from the left table.
Window functions calculate across rows without collapsing them.
PARTITION BY groups data internally.
ORDER BY inside OVER() controls ranking and running totals.
As an analysts, you can use JOINs and Window Functions together in real projects.

In My Own Words

If SQL were a toolbox:

JOINs are like screws and bolts - they connect pieces.
Window functions are like measuring tools - they help you analyze the structure without breaking it apart.

If you found this helpful, try this challenge:

Challenge: Write a query that finds the highest purchase per customer using JOIN and ROW_NUMBER().

Happy querying! If this helped you, share it with a fellow developer/analyst who's just getting started with SQL.

How Analysts Translate Messy Data, DAX, and Dashboards into Action Using Power BI

Mburu — Sat, 07 Feb 2026 19:11:20 +0000

Most businesses fail not because they lack data but because they misunderstand their own numbers. Sales are recorded, expenses are tracked and reports are produced yet decisions are still made using instinct, politics, or whichever Excel file looks most convincing in the meeting. You will find most businesses have duplicate transactions from their POS systems, different branches using different product names and discounts entered manually with zero controls. Then in the corporate world you will have member`s data split across systems, inconsistent loan classifications and reports that change depending on who prepared them. From a business perspective, this is not a technical issue. It’s a risk management failure and when Power BI is used properly, it disrupts this culture and that’s why many organizations resist it.

This article explains how analysts use Power BI to turn messy data, DAX, and dashboards into decisions that protect revenue, margins, and strategy.

1. Messy Data Is Not a Technical Problem it’s a Business Risk

In most retail chains, distributors, SACCOs, and NGOs, messy data shows up as:

Branches using different product names for the same item
Discounts entered manually with no approval limits
Duplicate sales from POS exports
Missing or altered transaction dates
Adjusted figures with no audit trail

From a business point of view, this leads to:

Overstated revenue
Inflated branch performance
Incorrect incentive payouts
Poor expansion decisions

Where Power BI comes in

Using Power Query, analysts enforce discipline by: standardizing product and branch names, remove duplicate transactions, flag negative prices or extreme discounts and create audit-ready transformation steps. This is not data cleaning. It is risk control.

Typical Messy Business Data Flow

(Raw Excel → POS exports → WhatsApp files → Final.xlsx)

2. KPIs Mean Nothing if the Data Model Is Wrong

If your totals change when filters are applied, your business decisions are already compromised. Executives rarely see the model they see the numbers and everyone trust numbers.

Many businesses still operate with:

One massive flat table
Multiple calculated totals
Conflicting monthly reports

How poor modelling Impacts Business

Sales appears higher than reality
Branch comparisons are misleading
Year-on-year growth cannot be trusted

Power BI Fix: Star Schema

A proper model separates:

Fact tables: Sales, Loans, Transactions
Dimension tables: Branch, Product, Customer, Date

This ensures:

KPIs remain consistent
Finance and operations see the same numbers
Strategic discussions focus on action, not reconciliation

3. Dashboards Are Executive Control Panels

If a dashboard does not change decisions, it is a waste of money. A business-grade dashboard should highlight uncomfortable truths, show who is missing targets and expose margin erosion with the ability to change the tone of a meeting. In most businesses, where hierarchy can silence data, Power BI dashboards give analysts evidence that speaks louder than titles.

Analysts Who Don’t Understand Business Will Be Replaced
Analysts who only build charts are replaceable but analysts who challenge assumptions are not. Executives don’t need more visuals, more tables, more complexity; They need clarity and Power BI gives analysts the evidence to comfortably say: Sales are up, but profit is down due to big discount margins and low revenue in Nairobi branches. This statement alone statement changes the strategy on how the business handles the market.

Conclusion

Power BI does not improve businesses, it exposes the truth about margins, controls performance, and have a say in leadership decisions. Organizations that embrace this grow stronger and those that resist continue doing guess work. For analysts, Power BI is not a reporting tool, it is leverage!!!

Understanding Data Modeling in Power BI: Your Guide to Building Better Reports

Mburu — Mon, 02 Feb 2026 17:47:11 +0000

Have you ever opened Power BI and wondered why your reports are running slower than a Monday morning, or why your calculations aren't quite adding up, chances are the culprit isn't the tool itself, it's how your data is structured. Let me walk you through the world of data modeling and I promise to keep it as simple as possible.

What Exactly Is Data Modeling?

Think of data modeling like organizing your kitchen. You could throw everything into one giant drawer, your utensils, plates, spices, and that random collection of takeout from KFC and Pizza Inn, but good luck finding anything when you need it. Or, you could organize things logically: plates in the plates drawer, spices in a rack, utensils in their own drawer and the take outs boxes in the dustbin. Data modeling is essentially the same concept, but for your business information.

In Power BI, data modeling is how you structure and connect your data tables to make them work efficiently together. It's the foundation that everything else sits on your visuals, your calculations, your insights. Get this right, and you're golden. Get it wrong, and you'll be waiting for reports to load while questioning your career choices.

The Two Heavyweights: Star Schema and Snowflake Schema

When it comes to organizing data in Power BI, two approaches dominate the conversation: star schema and snowflake schema. Let's break them down.

Star Schema:

Imagine looking down at a star from above and you've got a bright center with points radiating outward. That's exactly how a star schema works. At the center, you have your fact table (this is the numbers, the metrics, the stuff you actually want to analyze), and surrounding it are your dimension tables (the context that makes those numbers meaningful).

Here's a real-world example: Let's say you have a few stores around Nairobi. Your fact table might be called "Sales" and contain:

Time
Item
Branch
Location
Units sold
Revenue Your dimension tables would then provide the details:
Time table: Time, day, day of the week, month, quarter, year
Items table: Customer ID, Name, Location, Age Group
Branch table: Date, Month, Quarter, Year, Day of Week
Location table: Date, Month, Quarter, Year, Day of Week

Each dimension table connects directly to the fact table i.e. no middlemen, no complicated chains. It's clean, it's simple, and Power BI loves it.

Advantages of Star Schema:

Lightning fast query performance
Easy to understand (even your manager will get it)
Simpler DAX calculations
Less room for error

Snowflake Schema:

Now, take that star schema and imagine someone said, "let`s be extra and organize this even more!" That's snowflake schema. It is an extension of the star Schema, where each point explodes into more points. In a star schema, each dimension is represented by a single dimensional table, whereas in a snowflake schema, that dimensional table is normalized into multiple lookup tables, each representing a level in the dimensional hierarchy.

Using our Nairobi store example, instead of having all product information in one table, you might split it:

Sales table: Time, Item, branch, location, revenue, units sold
Items table: Item ID, Item name, Brand, Type, Supplier Key
Supplier table: Supplier, Supplier type

See what happened? We created a chain. Sales connects to Items, which connects to Supplier. It looks like a snowflake with its intricate branches. Same with the sales which connects to location which then connects to City.

Snowflake advantages:

Helps to reduce space by normalizing dimension tables
Potentially smaller storage footprint
It has normalized structures with are easier to build and maintain Snowflake disadvantages:
It is more complex to build
Power BI has to work harder to connect the dots

For Power BI specifically, star schema is almost always the better choice. Power BI's engine is optimized for star schemas, and storage space is rarely an issue these days. Save yourself the headache; stick with star and be a star in data modelling.

Fact Tables vs. Dimension Tables:

Understanding the difference between fact and dimension tables is crucial.

Fact Tables:

Fact tables store the measurements, the metrics, the things you want to add up, average, or analyze. They're typically long and narrow, lots of rows, fewer columns. Think of them as the what happened tables.

Common characteristics:

Contain numeric values (sales amounts, quantities, costs)
Have many rows
Represent transactions or events
Grow over time as new events occur

Examples: Sales transactions, website clicks, inventory movements, customer service tickets.

Dimension Tables:

Dimension tables are the who, what, where, when, and why of your data. They're typically shorter and wider with fewer rows, more descriptive columns. They give meaning to the numbers in your fact tables.

Common characteristics:

Contain descriptive text and attributes
Have fewer rows
Include a primary key
Provide context for analysis
Change less frequently

Examples: Customer details, product catalogs, geographic locations, time periods.

The relationship between the two: Fact tables reference dimension tables through keys. A sale (fact) happened to a specific customer (dimension) for a specific product (dimension) on a specific date (dimension). This is how you can slice and dice your numbers in a million different ways.

Relationships:

In Power BI, relationships are the bridges between your tables. They tell Power BI how data in one table relates to data in another. Get these wrong, and your reports will show incorrect numbers or worse, nothing at all.

Types of Relationships

One-to-Many: This is the bread and butter of Power BI relationships. One record in the dimension table relates to many records in the fact table. For example, one customer can have many sales transactions.

Many-to-One: Just the reverse of one-to-many. Power BI automatically handles the direction.

One-to-One: Rare in practice. Each record in one table matches exactly one record in another. Usually indicates you could combine the tables.

Many-to-Many: The complicated one. Avoid if possible, but sometimes necessary. Requires careful handling and can impact performance.

Relationship Best Practices

Use single-column relationships: Don't try to relate tables on multiple columns. If you need to, create a composite key column first.

2.Set the correct cardinality: Power BI usually detects this automatically, but always double-check.

3.Mind the filter direction: Typically, filters flow from dimension to fact (one-side to many-side). This is called single direction filtering. Bi-directional filtering can be useful but use it sparingly as it can create ambiguity and slow things down.

4.Avoid circular relationships: If Power BI can navigate from Table A to Table B to Table C and back to Table A, you've created a circular dependency. Power BI will complain, and rightfully so.

5.Use inactive relationships when needed: Sometimes you need multiple relationships between the same tables like Order Date and Ship Date both connecting to a Date table. Make one active and use DAX's USERELATIONSHIP function for the others.

Why Good Data Modeling Matters

Let me paint you two scenarios.

Scenario A: You import all your data as it is, create some relationships that seem right, and start building visuals. Your report takes 30 seconds to load. Your all year calculations are showing weird numbers. Your boss asks why the regional breakdown doesn't match the finance report. You spend hours troubleshooting, only to realize your relationships are creating duplicate counts.

Scenario B: You spend an afternoon properly modeling your data; creating a clean star schema, establishing correct relationships, building a proper date table. Your reports load in 2 seconds. Your calculations are accurate. When your boss asks for a new breakdown, you add it in minutes. You look like a tech wizard.

Which scenario sounds better? Tell me down in the comments.

Performance Benefits

Good data modeling directly impacts performance:

Faster queries: Star schemas mean Power BI's engine can retrieve data quickly
Smaller file sizes: Proper modeling eliminates redundancy and allows better compression
Efficient calculations: Clean relationships mean DAX doesn't have to work overtime
Smoother user experience: Nobody likes waiting for visuals to load

Accuracy Benefits

Even more critical than speed is correctness:

No duplicate counting: Proper relationships prevent the same sale from being counted multiple times
Correct aggregations: Your totals actually total correctly
Reliable filters: When users filter by region, they get that region's data—all of it, and only it
Trustworthy insights: When your CEO makes a decision based on your report, you can sleep at night

Maintenance Benefits

Future you will thank present you:

Easier updates: Adding new data sources or columns is straightforward
Simpler troubleshooting: When something breaks, you can find the issue quickly
Better collaboration: Other people can understand and work with your model
Scalability: As your data grows, your model still performs well

Practical Tips for Building Your Model

Ready to put what you have learnt into practice? Here's your game plan:

1. Start with a Plan

Before importing anything, sketch out your model on paper or a whiteboard. Identify:

What are you measuring? (These become fact tables)
What provides context? (These become dimension tables)
How do they connect?

2. Build a Proper Date Table

Never ever use the auto-generated date hierarchy. Create a dedicated date dimension table with all the columns you need: year, quarter, month, week, day of week, fiscal periods, holidays, etc. This single table will be used by all your fact tables.

3. Keep Dimension Tables Clean

Each dimension table should have a clear primary key. Avoid duplicates. Keep descriptive attributes together. If you find yourself with a dimension table that has millions of rows, it might actually be a fact table in disguise.

4. Use Meaningful Names

Call your tables and columns what they actually are. "DimCustomer" and "FactSales" are better than "Table1" and "Query2." Your future self will thank you.

5. Hide What Users Don't Need

Hide foreign columns, intermediate calculation columns, and anything else that would just confuse report builders. Keep the field list clean and intuitive.

6. Test Your Model

Before building dozens of visuals, create a few simple tables to verify:

Totals match your source systems
Filters work as expected
Relationships are functioning correctly
No unexpected blanks or duplicates appear

7. Document Your Decisions

Add descriptions to your tables and measures. When someone, probably you, in six months from now asks "Why did we model it this way?" you'll have the answer.

Common Pitfalls to Avoid

Learn from others' mistakes:

Using flat files: Importing one giant Excel file with everything might seem easier, but it's a performance nightmare and makes calculations complicated.

Bi-directional filters everywhere: These can create ambiguous filter paths and slow performance. Use them only when absolutely necessary.

Ignoring data types: Make sure numbers are numbers, dates are dates, and text is text. Wrong data types break calculations and sorting.

Skipping the date table: Seriously, build a proper date table. Time intelligence functions need it.

Creating calculated columns when measures would work: Calculated columns are computed during refresh and stored, bloating your file. Measures are computed on-the-fly and are usually more efficient.

Conclusion and Take aways

Data modeling might not be the flashiest part of Power BI. Building those gorgeous visuals is way more fun, but it's absolutely the most important. A well-modeled dataset is like a solid foundation for a house, you don't see it, but everything depends on it.

Start with a star schema. Clearly separate your facts from your dimensions. Establish clean, simple relationships. Test thoroughly. And remember: the hour you spend modeling properly will save you dozens of hours of troubleshooting later.

Your reports will load faster, your numbers will be accurate, and you'll actually enjoy working in Power BI instead of fighting with it. And isn't that worth the effort?

Now go forth and model with confidence. Your data is waiting to be organized, and you've got the knowledge to do it right.

Introduction to MS Excel for Data Analytics

Mburu — Sun, 25 Jan 2026 12:59:43 +0000

If you’re new to data, Microsoft Excel is the best place to start. You can download Microsoft office from Google and you will find excel there.

If you`re new to data, before you learn Power BI, SQL, Python, or Data Science you start with Excel. It’s simple, powerful, and used everywhere: in schools, businesses, NGOs, startups, and tech companies.

This guide explains how data works using Excel in a way that is friendly for complete beginners.

What Is Data?

Data is simply information.

Examples of data:

Names of students
Exam scores
Sales records
Monthly expenses
Attendance lists

When the above information is listed it holds simple to no meaning but when the information is organized, it becomes meaningful. Excel helps you to organize this data in a way that you will understand.

What Is Microsoft Excel?

Microsoft Excel is a spreadsheet application developed by Microsoft which is used to:

Store data
Organize data
Calculate values
Analyze information
Create charts and reports

Think of Excel as a digital notebook with calculation powers.

Understanding the Excel Workspace

When you open Excel, you’ll see several important parts.

Workbook

A workbook is the entire Excel file.

Excel startup screen showing a blank workbook

Worksheet

Inside a workbook are worksheets (tabs at the bottom).

Sheet tabs labeled Sheet1, Sheet2, Sheet3

Each worksheet holds data. You have have different or same data in each worksheet. You add a worksheet using the plus (+) Infront of the sheet.

Rows, Columns, and Cells

Rows → horizontal (1, 2, 3…)
Columns → vertical (A, B, C…)

Where a row and column meet is a cell.

Example:

Excel grid highlighting rows, columns, and a selected cell

How Data Is Stored in Excel.

Data is stored in tables.

A good table has:

Clear headers
One idea per column
One record per row

Example Table

Student Name	Subject	Score
Amina	Math	78
Brian	English	65
Faith	Science	82

Simple student results table in Excel

Types of Data in Excel

1. Text Data

Used for names and descriptions.

Examples:

John Nairobi Economics

2. Number Data

Used for calculations.

Examples:

450 78.5 12000

3. Date & Time Data

Used for tracking time-based records.

Examples:

25/01/2026 14:26

Cells formatted as date and time

Why Data Structure Matters

Bad structure leads to:

Errors
Wrong results
Confusion

Good structure allows:

Accurate calculations
Easy analysis
Clean reports

NB: Golden rule of data:

One column = one type of data

Basic Excel Skills Every Beginner Must Know

1. Entering Data

Click a cell
Type your data
Press Enter

Typed data into Excel cells

2. Saving Your Work

Always save your file.

Shortcut:

Ctrl + S

Use clear file names:

January Sales 2026.xlsx

3. Formatting Data

Formatting improves readability:

Bold headers
Adjust column width
Add borders
Apply number formats

Formatted table with bold headers and borders

For Student name and subject use text (for all columns that aren`t calculated)

For score and any data that you can calculate use numbers.

NB: Number formats change how numbers look without changing their actual value.

Common formats:

General (default)
Number (can show decimal places)
Currency (shows a currency symbol)
Accounting
Percentage (%)
Date
Time

Steps:

Select the cells with numbers.
Home tab > Number group.
Use the dropdown to choose Number, Currency, Percentage, Short Date, etc.

Introduction to Excel Formulas

This is now the powerhouse of Excel.

What Is a Formula?

A formula tells Excel to calculate something.

Something key to note is that all formulas start with =

Common Beginner Formulas

SUM – Add Numbers

=SUM(c2:c4)

SUM formula calculating total score

AVERAGE – Find the Mean

=AVERAGE(c2:c4)

Average score calculation

MAX and MIN – Highest & Lowest Values

Max is the highest value in the dataset
Min is the lowest value in the dataset

=MAX(C2:C4)
=MIN(C2:C4)

Highest and lowest score highlighted

Why Excel Is Important for Data Beginners

Excel helps you learn:

Data organization
Logical thinking
Accuracy
Problem solving

Once you understand Excel, moving to:

Power BI
SQL
Python
Data Analytics

becomes so much easier and understandable.

Common Beginner Mistakes

Mixing text and numbers in one column
Missing headers
Using merged cells in raw data
Not saving regularly
Clean data beats fancy formatting.

How to Practice Excel as a Beginner

Try these simple projects:

Personal budget tracker
Daily expenses list
Student marks sheet
Shop inventory list
Monthly sales report

Date	Description	Category	Amount (KES)
01/01/2026	Transport to work	Transport	200
02/01/2026	Lunch	Food	350
03/01/2026	Internet bundle	Utilities	500
04/01/2026	Groceries	Food	1,200
05/01/2026	Movie night	Entertainment	600

EXAMPLE: A Simple expense tracker created in Excel

Conclusion

Excel is not just for accountants or finance bros. It’s a foundational data skill used in almost every profession. If you’re new to data, start here, master the basics, and build confidently.

Happy learning

If this helped you, give it a ❤️ and follow for more beginner-friendly data content.

A Beginner’s Guide: Mastering Git, GitHub, and Basic Workflows

Mburu — Fri, 16 Jan 2026 18:39:51 +0000

A simple Beginner`s tutorial on how to install Git, connect to GitHub, and use basic Git workflows

New to tech? Don't worry. I will take you through a simple step by step guide to help you install Git, connect it to GitHub, and use basic git commands that will help your new journey and boost your understanding. I started my Data analytics, science and AI journey early this week at LUX DEV HQ on 12/01/2026 and I am happy to share my journey here.

Overview
Install Git (Windows / macOS / Linux)
Configure Git identity
Create a GitHub account and connect (SSH recommended)
Create, commit, push, and pull (basic workflow)
Inspecting history and tracking changes
Undoing changes (safe commands)
Simple teamwork workflow (feature branches + pull requests)
Quick cheat-sheet you can use later

Overview

Git saves snapshots of your project so you can track changes, collaborate, and revert mistakes. GitHub stores repositories online so you can share code.

Install Git

Windows

Download the installer: https://git-scm.com/download/win
Run the installer and accept the default options.

Open Git Bash from the Start menu and verify:

Windows

Open Terminal and run: git --version

macOS

Open Terminal and run: git --version If not installed, macOS will prompt to install the Xcode command line tools — accept to install. Alternatively download: https://git-scm.com/download/mac

Linux (Ubuntu/Debian)

Open Terminal and run: sudo apt update sudo apt install git -y git --version

Configure Git identity

Run these once (replace with your name and email):
git config --global user.name "Your Name" git config --global user.email "you@example.com"

Check your settings:
git config --list

Create a GitHub account and connect Git to GitHub (SSH recommended)

Create a GitHub account

Go to https://github.com and sign up.

Generate an SSH key (recommended)

In Git Bash: ssh-keygen -t ed25519 -C "you@example.com"

If ed25519 is unavailable, use:
ssh-keygen -t rsa -b 4096 -C "you@example.com"
Press Enter to accept defaults and optionally set a passphrase.

Start the ssh-agent and add your key:

macOS / Linux:
eval "$(ssh-agent -s)" ssh-add ~/.ssh/id_ed25519
Windows (Git Bash): Copy the path where your path was saved
eval "$(ssh-agent -s)" ssh-add //c/Users/Administrator/.ssh/id_ed25519

Copy the public key to your clipboard:

macOS:
pbcopy < ~/.ssh/id_ed25519.pub
Linux (with xclip):
xclip -sel clip < ~/.ssh/id_ed25519.pub
Windows (Git Bash):
cat ~/.ssh/id_ed25519.pub | clip

On GitHub: Settings → SSH and GPG keys → New SSH key → paste the key → Save.

Test the connection: ssh -T git@github.com You should see a welcome message confirming authentication.

Basic Git workflow (create, track, commit, push, pull)

Create a local repository and make your first commit

Create a project folder and initialize Git:
mkdir my-project cd my-project git init
This creates a .git folder that tracks changes.

Add files and make first commit

Create a file (example):
echo "# My Project" > README.md
Check repository status:
git status
Stage files:
git add README.md
To stage everything:
git add .
Commit staged files with a message:
git commit -m "Add README"

Link the local repo to GitHub (push)

On GitHub: click New repository, name it (for example: my-project), and copy the SSH URL:
git@github.com:username/my-project.git
Link remote and push:
git remote add origin git@github.com:username/my-project.git git branch -M main git push -u origin main
For HTTPS use the HTTPS URL instead:
https://github.com/username/my-project.git

Push your main branch:

`
git branch -M main
git push -u origin main

Pull changes from remote

To fetch and merge remote changes into your current branch:
git pull

Understand version control basics

Key concepts:

Repository: a project with its history.
Working directory: your current files.
Staging area (index): files you marked to include in next commit.
Commit: a saved snapshot with a message and ID.
Branch: a parallel line of development (main is default).
Remote: an online copy (e.g., GitHub).
Push: send commits to remote.
Pull: fetch remote commits and merge into local branch.