DEV Community: Suzanne Orido

Schemas in Power BI: Designing Models That Perform

Suzanne Orido — Wed, 04 Feb 2026 10:14:10 +0000

Power BI is a business intelligence and data visualization platform developed by Microsoft. It is used to connect to data from multiple sources, model that data, and produce interactive reports and dashboards for analysis and decision-making.
In the world of business intelligence, data modeling is the "blueprint" that determines whether a Power BI report will be a high-performance engine or a slow, confusing mess.

This article goes into detail on what data models are, why they are important in Power BI, and how to use star schemas and snowflake schemas when designing accurate data models.

What is a data model?

It is a visual representation of how different pieces of information relate to one another within a system.
Think of a data model as a map that defines how your information is stored, connected, and filtered. Without this map, Power BI has to guess how your tables relate, which often leads to errors.

Key components of a Data Model:

Tables: These are the containers for your data. In a good model, these are split into Fact tables (the numbers/metrics) and Dimension tables (the descriptive context).

Fact Tables
They store the measurable business events that an organization wants to analyze. Each row represents an occurrence of something that happened, at a defined level of detail. Facts answer “how much,” “how many,” or “how often.

A fact table contains dimension key columns that relate to dimension tables and numeric measure columns. The dimension key columns determine the dimensionality of a fact table, while the dimension key values determine the granularity of a fact table.

Some key characteristics include:

Large row counts
Numeric, aggregatable columns
Foreign keys linking to dimension tables
One clear grain per table

Dimension Tables
They store the descriptive context used to filter, group, and explain measures in fact tables. They answer “who,” “what,” “where,” and “when.”

Some key characteristics include:

Smaller than fact tables
Mostly categorical or textual attributes
One primary key
Referenced by fact tables through foreign keys
Rarely aggregated

Relationships in Power BI
Relationships in Power BI define how tables interact. They control which rows are included in a calculation. If relationships are wrong, results are wrong, regardless of visuals or DAX.

Common relationship types include:

One-to-many: standard and preferred (dimension → fact) Example: One Product → many Sales rows
One-to-one: rare, use cautiously Example: Employee details are split across two tables
Many-to-many: last resort, high risk Example: Customers belonging to multiple segments

Understanding Star Schema

A star schema is a data modelling structure where a central fact table is directly connected to multiple dimension tables, forming a star-like layout. It is the preferred schema for Power BI and most analytical systems.

Structure

One fact table at the center
Dimension tables radiating outward
Each dimension connects to the fact with a one-to-many relationship
No relationships between dimension tables

How it works
The fact table stores business events. Dimension tables provide descriptive context. Filters flow from dimensions to the fact, ensuring correct aggregation and predictable results.
Usually, fact tables represent the "many" aspect of a relationship, while dimension tables represent the "one" aspect.

Understanding Snowflake Schema

A snowflake schema is a data modelling structure in which dimension tables are normalized into multiple related tables rather than being stored as a single, flat dimension. The resulting layout resembles a snowflake rather than a star.

Structure

One central fact table
A dimension connected to the fact
That dimension is further split into sub-dimensions
Multiple joins required to reach descriptive attributes

When they appear in Power BI

When importing data directly from normalized source systems
When modelling is not intentionally redesigned for analytics

Although this reduces redundancy, too much snowflaking is discouraged because:

It increases query complexity.
It requires more joins.
It may slow down performance

Snowflake schemas are storage-efficient. Star schemas are analytics-efficient.

The importance of good data modelling

Good data modelling is critical because it determines whether the analysis is correct, fast, and repeatable. Visuals and calculations sit on top of the model; they cannot fix structural errors beneath it.

Accuracy
A good model enforces correct filter flow and aggregation. Measures return the same result regardless of visual layout. Poor models cause double-counting and inconsistent totals.

Performance
Power BI’s engine is optimized for star schemas and simple relationships. Clean models reduce joins, improve compression, and deliver faster query execution. Bad models scale poorly as data grows.

Simplicity
Well-modelled data requires fewer complex DAX expressions. Business logic lives in the model, not in workaround calculations. This reduces error rates and maintenance costs.

Consistency
Metrics are defined once and reused everywhere. Reports built by different authors produce the same numbers. This is essential for organizational trust.

Scalability
Good models support new measures, dimensions, and visuals without redesign. Poor models collapse under change and require rewrites.

Decision quality
Executives act on reported numbers. Incorrect models produce confident but wrong answers. That is operational risk.

In Power BI, data modelling is not preparation work. It is the core analytical task.

In conclusion, data modelling is what makes Power BI reports work correctly. When data is well organized into fact and dimension tables with clear relationships, reports are fast, and numbers are accurate. Poor modelling leads to slow reports and wrong results. Good insights start with a good data model.

Beginner-friendly introduction to MS Excel for Data Analytics

Suzanne Orido — Sun, 25 Jan 2026 18:12:59 +0000

Microsoft Excel is a spreadsheet application used to store, organize, and work with data. It helps turn raw data into useful information that supports decisions. It can be described as a digital table or grid for organizing, calculating, and analyzing information.

While professional data analysts often use more advanced tools for big projects, Excel remains popular because it's accessible, familiar, and powerful enough for most everyday data tasks.

In Excel, data is arranged in rows(horizontal groups of cells) and columns(vertical groups of cells). A cell is a single box in Excel's grid where you can store one piece of information.

Why use MS Excel for Data Analytics?

It's easy to learn and use, even for beginners
It quickly organizes large amounts of data
It performs fast calculations and basic statistical analysis
It helps identify trends through charts and pivot tables
It is widely available and accepted in most workplaces
It allows quick insights without complex software

Before analyzing data, it's important to understand the basic interface of Excel. This includes knowing the definition of the following:
Row: A horizontal group of cells labelled 1,2,3... on the left.
Column: A vertical group of cells labelled A,B,C... at the top.
Cell: Intersection of a row and a column.
Workbook: The entire Excel file that contains one or more sheets.
Worksheet: The individual page inside the workbook.

In this article, we will learn:

Data cleaning: Removing duplicates, sorting data, filtering data
Performing calculations using formulas
Performing calculations using operators
Data visualization: Using pivot tables, charts, and dashboards

Data Cleaning

Data cleaning is important because analysis is only as good as the data used.
Some of the cleaning tasks include:

Removing duplicates

This means identifying and deleting repeated entries in a dataset so that each record appears only once.
To do this:
Select the data or the column that may contain duplicates.
Click the Data tab.
Choose Remove Duplicates.
Tick the column(s) Excel should check.
Click OK.

How to clean text with Functions:
TRIM() removes extra spaces
UPPER() and LOWER() standardize text formatting

Sorting Data

Sorting data in Excel means arranging data in a specific order to make it easier to understand and analyze.

To do this:

Select the column or the entire dataset.
Go to the Data tab.
Click Sort A to Z (ascending) or Sort Z to A (descending).

Filtering Data

Filtering data in Excel displays only the rows that meet specific conditions while hiding the rest, allowing you to focus on certain values, dates, or number ranges without deleting any data.

To do this:

Select your dataset.
Go to the Data tab and click Filter.
Small dropdown arrows appear in the column headers.
Click a column’s dropdown arrow.
Choose the criteria you want (specific values, dates, or number ranges).
Excel displays only the rows that meet the selected criteria, hiding the rest.

Performing calculations using formulas:

Click the cell where you want the result to appear.
Type an equal sign (=) to start the formula.
Enter the calculation using numbers, cell references, and operators (like +, -, *, /). For example: =A1+B1 or =C2*D2.
Press Enter to see the result.

=SUM(A2:A877) → Adds all numbers in the range
=AVERAGE(A2:A877) → Calculates the average
=MIN(A2:A877) → Finds the smallest value
=MAX(A2:A877) → Finds the largest value
=COUNT(A2:A877) → Counts numeric values
=COUNTA(A2:A877) → Counts all non-empty cells

Performing calculations using operators:

+ → Addition e.g., =A1+B1
- → Subtraction e.g., =A1-B1
* → Multiplication e.g., =A1*B1
/ → Division e.g., =A1/B1
^ → Exponentiation / Power e.g., =A1^B1

Data Visualization

Pivot Tables
A pivot table is an Excel tool used to quickly summarize and analyze large amounts of data.

It works by reorganizing data to show totals, averages, counts, or comparisons without changing the original dataset.

How to create a Pivot Table:

Select your dataset.
Go to the Insert tab and click PivotTable.
Choose whether to place the pivot table in a new worksheet or the existing worksheet.
Click OK.
In the PivotTable Field List, drag fields into Rows, Columns, Values, or Filters to arrange and summarize your data.

Charts
A chart in Excel is a visual representation of data, like bars, lines, or pie slices, that makes patterns and trends easier to understand.

To create a chart:

Select the data you want to visualize.
Go to the Insert tab.
Choose the chart type you want (e.g., Column, Line, Pie, Bar).
Click the chart style, and Excel inserts it into your worksheet.
Customize the chart using chart tools (titles, labels, colors) if needed.

Dashboards
A dashboard in Excel is a single screen or sheet that displays key information and metrics from your data in a clear, visual way using charts, tables, and pivot tables.

An Excel dashboard typically consists of:

Charts – Bar, line, pie, or combo charts to visualize trends and comparisons.
Pivot Tables – Summarize large datasets into totals, averages, counts, or other key metrics.
Tables – Organized data or key figures for reference.
Slicers and Filters – Interactive tools to quickly view specific data.
Key Performance Indicators (KPIs) – Numbers, percentages, or symbols that show performance at a glance.
Text Boxes / Labels – Titles, headings, or explanations for clarity.

With that, you now know the basics and can Excel in data analytics. Cheers! 😄

LuxDev Assignment 1

Suzanne Orido — Fri, 16 Jan 2026 19:31:14 +0000

What is Git?

Git is a distributed version control software system that is capable of managing versions of source code or data. It is often used to control source code by programmers who are developing software collaboratively.

Why is version control important?

It is a system that records every change made to a file or set of files over time so that you can recall specific versions later.
The importance of version control includes:

Safety Net: You can "undo" mistakes by rolling back to any previous version of your project if something breaks.
Teamwork: It allows multiple people to work on the same files simultaneously without overwriting each other's progress.
Organization: It eliminates messy file naming (like final_v2_new.doc) by keeping one clean version while storing the history in the background.
Branching: You can create "branches" to experiment with new ideas in isolation without risking the stability of the main project.
Documentation: Every change is saved with a note (commit message), creating a detailed history of who changed what and why.

How to push code to Github

To push your code to GitHub, you first need a repository (a project folder) hosted on their site. Here is the standard workflow using the terminal.

1. Initial Upload (New Repository)

Use this sequence to link a local project to a newly created GitHub repository.

- Create Remote Repository: On GitHub, create a new repository. Do not initialize with a README, .gitignore, or license if code already exists locally.

- Initialize Local Git: Navigate to the project root and execute: git init

- Stage Files: Add all files to the staging area: git add.

- Create First Commit: Record the snapshot: git commit -m "initial commit"

- Define Main Branch: Ensure the primary branch is named main: git branch -M main

- Link Remote URL: Connect the local repository to GitHub: git remote add origin <github-repo-url>

Execute Push: Upload the code and set the upstream reference: git push -u origin main

2. Standard Synchronization (Existing Repository)

Use this sequence for ongoing updates to a repository that is already linked.

Stage Specific Changes: git add <file-name> (or git add. for all changes)

Commit: git commit -m "description of changes"

Push: git push

How to pull code from GitHub

Code retrieval from GitHub is categorized into two primary operations: Initial Acquisition (Clone) and Synchronization (Pull).

1. Clone:

Used when the code doesn't exist on the local machine

Identify Repository URL: On the GitHub repository page, click the Code button and copy the URL (HTTPS or SSH).
Initialize Download: Open the terminal and execute: git clone <repository-url>
Result: Git creates a directory named after the repository, downloads all files, branches, and the full commit history, and configures the remote reference (origin).

2. Pull/Synchronization

Used to update an existing local repository with changes from Github
- Navigate to Directory: Enter the local project folder.

- Execute Update: Run the following command: git pull origin <branch-name> Example: git pull origin main

- Mechanism: This command executes two sub-operations:

Fetch: Downloads remote data without altering local files.

Merge: Integrates remote changes into the current active branch.

How to track changes using Git

Git tracks changes by managing data between three logical states: the Working Directory (unsaved changes), the Staging Area (prepared changes), and the Local Repository (permanent history).

1. Initialization

Activate Git tracking in a project directory: git init This creates a .git subdirectory to store metadata and object databases.

2. State Verification

Determine the current status of files: git status

- Untracked: New files unknown to Git.

- Modified: Tracked files with unsaved changes.

- Staged: Changes moved to the Index, ready for the next snapshot.

3. Change Preparation (Staging)

Select specific changes for inclusion in the next version:

Single file: git add <file-name>
All changes: git add .
Interactive (partial file): git add -p

4. Version Finalization (Commit)

Record the staged changes as a permanent snapshot: git commit -m "Direct description of change" Standard format: Use imperative mood (e.g., "Fix logic error" rather than "Fixed logic error").

5. Change Analysis Tools

Real-time Differences

Analyze modifications before staging or committing:

- Unstaged changes: git diff (Compares working directory to staging area)

- Staged changes: git diff --staged (Compares staging area to last commit)

Historical Review

Inspect the chronological record of changes:

- Summary list: git log --oneline

- Detailed patches: git log -p

- File-specific history: git log -- <file-path>

Line-Level Attribution

Identify when and by whom specific lines were altered: git blame <file-name>