Forem: Samuel Wachira

HOW TO CONNECT POWER BI TO A SQL DATABASES

Samuel Wachira — Wed, 25 Mar 2026 09:29:33 +0000

1. Introduction to Power BI and SQL Databases

In today's data-driven business environment, organization's generate enormous volumes of information every day. i.e from sales transactions to inventory movements and financial records. To make sense of this data, it requires powerful tools that connect to where data lives, transforms it into a usable shape and present it through visualization that decision-makers can act on. Power Bi, developed by Microsoft is one of the most widely used adopted platforms for exactly this purpose.

Power BI is a cloud-based business intelligence and data visualization service that enables analysts to connect hundreds of data sources, build interactive dashboards and share reports across organizations.
It is available as free desktop application (Power BI Desktop), a cloud-hosted service(Power BI service) and a mobile application making it accessible to analysts working in all environments.

What is Power BI used For

Sales analysis by tracking performance by region, product line or individual representative.
Executive dashboard that summarizes KPIs such as revenue, customer acquisition costs and profit margin.
Financial reporting by building profit and loss statements and cash flow summaries from accounting systems.

Why Companies Connect Power Bi to Databases
While Power Bi can load data from Excel spreadsheets, CSV files and web API's, the majority of enterprise data resides in relational databases. Connecting Power Bi directly to databases give analysts access to live authoritative data rather than outdated extracts and allows dashboards to refresh automatically on a schedule.

SQL databases are important in this context because they are backbone of most business information systems. Customer records, transactional sales data and inventory tables are always mostly stored in relational databases such as PostgreSQL, Microsoft SQL server or MySQL.

SQL databases enforces data integrity through primary keys, foreign keys and constraints, scale efficiently to million rows and allows complex analytical queries to run close to where data is stored.

Connecting Power BI to a local PostgreSQL Database

PostgreSQL is a powerful open source relational database widely used by developers, data engineers and analysts.

If your organization runs PostgreSQL on a local server or your own machine during development, Power Bi Desktop can connect to it in the following steps:

Step 1: Open and launch Power Bi Desktop from the windows Start menu.

Step 2: Open the Get Data Dialog

Step 3: In the Get Data dialog, select PostgreSQL Database and click connect.

Step 4: The PostgreSQL connection dialog will appear and enter the Server and Database Name.

Step 5 : Provide credentials and click connect.

Step 6: A Navigator window will open showing all tables in your database. Select the checkboxes and load tables into Power Bi

Connecting Power Bi to a Cloud Database(Aiven PostgreSQL)

Aiven is a managed cloud database platform that hos PostgreSQL on major cloud providers including AWS, Google Cloud and Microsoft Azure.

Aiven is commonly used because it handles server provisioning, automated backups and security hardening.

Connecting Power Bi to an Aiven PostgreSQL follows the following steps:

Step 1 : Obtaining Connection details from Aiven

Step 2: Downloading the SSL Certificate.

SSL Certificate(Secure Socket Layer Certificate) allows Power Bi to verify that is connecting to the genuine Aiven server and not fraud or fake.

Step 3: Entering Aiven Details in Power Bi.

Step 4: Load your tables and build a data model.

Understanding data model
Power BI needs to understand how tables relate to one another so that calculations can correctly join data across them.
This is called data modelling, it is related to the concept of primary and foreign keys in SQL.

Why SQL Skills Matters

SQL remains one of the most valuable skills a business intelligence professionals can possess.
It helps in:

Retrieving targeted data

select first_name,last_name,membership_status
from customers;

Results:

Filtering Datasets

select product_name,category,price
from products 
where category ='Electronics';

Results:

Performing aggregations

select product_id,
sum(quantity_sold) as total_quantity_sold
from sales
group by product_id;

Results:

Preparing data before building dashboards

CREATE TABLE customers (
    customer_id INT PRIMARY KEY,
    first_name VARCHAR(50),
    last_name VARCHAR(50),
    email VARCHAR(100),
    phone_number VARCHAR(50),
    registration_date DATE,
    membership_status VARCHAR(10)
);

Results:

CONCLUSION
Power BI is a transformative tool for business intelligence, but its true power is unlocked when connected to the structured data that lives in SQL databases. Whether you are working with a local PostgreSQL instance during development or a fully-managed cloud database on Aiven, the connection process is straightforward once you understand the parameters involved.

Loading tables such as customers, products, sales, and inventory into Power BI is only the first step. Building a meaningful data model is what enables Power BI to answer cross-domain business questions accurately.

The combination of Power BI proficiency and SQL knowledge is one of the most valuable skill sets a data professional can develop.

Happy reading!

SQL JOINS AND WINDOW FUNCTIONS WITH CASE EXAMPLE

Samuel Wachira — Tue, 03 Mar 2026 18:47:36 +0000

SQL JOINS

When working with relational databases, data is often split across multiple tables. SQL Joins is used to combine data from two or more tables based on related column into one result.
It helps in:

Matching records using related columns.
Retrieving connected data from multiple tables.
Improving data analysis by combining related information.

Types of SQL Joins
SQL joins are categorized into different types based on how rows from two tables are matched and combined.
For this article, we will use two tables. i.e

STUDENT TABLE and COURSE TABLE

For Student table, we create the table first, then we Insert values as shown below:

CREATE TABLE Students (
    Student_ID INT PRIMARY KEY,
    First_name VARCHAR(50) NOT NULL,
    Last_name VARCHAR(50) NOT NULL,
    Gender CHAR(1),
    Email VARCHAR(100) UNIQUE
);

INSERT INTO Students (Student_ID,First_name, Last_name, Email, Gender)
VALUES 
(201,'Alice', 'Johnson', 'alice.j@university.com', 'F'),
(202,'Robert', 'Smith', 'rob.smith@college.edu', 'M'),
(203,'Elena', 'Rossi', 'e.rossi@academy.net', 'F'),
(204,'Kenji', 'Sato', 'kenji.s@global.org', 'M'),
(205,'Zara', 'Khan', 'z.khan@tech.edu', 'O');

Result:

For Course table, we create the table first, then we Insert Values as shown below:

CREATE TABLE Courses (
    Course_ID INT PRIMARY KEY,
    Student_ID INT,
    Full_name VARCHAR(100),
    Last_name VARCHAR(50),
    Course VARCHAR(50),
    FOREIGN KEY (Student_ID) REFERENCES Students(Student_ID)
);

INSERT INTO Courses (Course_ID, Student_ID, Full_name, Last_name, Course)
VALUES 
(1001, 201, 'Alice Johnson', 'Johnson', 'Data Science'),
(1002, 202, 'Robert Smith', 'Smith', 'Graphic Design'),
(1003, 203, 'Elena Rossi', 'Rossi', 'Architecture'),
(1004, 204, 'Kenji Sato', 'Sato', 'Artificial Intelligence'),
(1005, 205, 'Zara Khan', 'Khan', 'Cyber Security');

Result:

SQL Inner Join It is used to retrieve rows where matching values exist in both tables.

Consider the two tables, Students and Course, which share a common column Student_ID.

Using SQL inner Join, we combine data from these tables based on their relationship, allowing us to retrieve meaningful information like student details along with their enrolled courses.

Query:

SELECT 
    Students.Student_ID, 
    Students.First_name, 
    Students.Last_name, 
    Students.Email, 
    Courses.Course
FROM Students
INNER JOIN Courses ON Students.Student_ID = Courses.Student_ID;

Result:

This helps in:

Combining records based on related column.
Returning only matching rows from both tables.
Excluding non-matching data from the result set.

2.SQL Left Join
It is used to retrieve all rows from the left table(Students) and matching rows from the right table(Course).

Query:

SELECT 
    Students.Student_ID, 
    Students.First_name, 
    Students.Last_name, 
    Courses.Course
FROM Students
LEFT JOIN Courses ON Students.Student_ID = Courses.Student_ID;

Result:

This helps in:

Returning all records from the left table.
Showing matching data from the right table.
Displaying NULL values where no match exists in the right table.

3.SQL Right Join
It is used to retrieve all rows from the right table(Course) and matching rows from the left table(Students).

Query:

SELECT 
    Students.Student_ID, 
    Students.First_name, 
    Students.Last_name, 
    Courses.Course_ID,
    Courses.Course
FROM Students
RIGHT JOIN Courses ON Students.Student_ID = Courses.Student_ID;

Result:

This helps in:

Returning all records from the right table.
Showing matching data from the left table.
Displaying NULL values where no match exists in the left table.

4.SQL Full Join
Its is used to combine the results of both right join and left join.

Query:

SELECT 
    Students.Student_ID, 
    Students.First_name, 
    Courses.Course_ID,
    Courses.Course
FROM Students
FULL JOIN Courses ON Students.Student_ID = Courses.Student_ID;

Result:

This helps in:

Returning all rows from both tables.
Displaying NULL values where no match exists in either table.
Providing complete data from both sides of the join.

5.SQL Natural Join
It is a type of Inner Join that automatically joins two tables based on columns that have the same name and data type in both tables.

Query:

SELECT Student_Id,First_name,Last_name,gender,course_id,course
FROM Students
NATURAL JOIN Courses;

Result:

Summary
By combining rows from multiple tables based on related columns, SQL joins allows you to transform fragmented data into a comprehensive and actionable result.

SQL Window Functions

It is a set of SQL Functions that allows you to perform calculations over a set of rows without needing to group by each row.
To explain window function, we must understand its syntax. The basic syntax is as follows:

window_function_name([ALL] expression)     
OVER (    
    [partition_defintion]    
    [order_definition]   
)

window_function-This indicates the name of our window function.
Over()- It contains two expression. i.e. partition by and order by clauses which are responsible for dividing rows into partitions in relation to given criteria before performing calculations.
Partition by -This divides up our rows into partitions based on the given criteria.
Order by -It is used to determine the order of values based on each partition.

Types of Windows Functions
There are three different types of SQL window functions. They include:

Aggregate Window function: This allows to perform operations on set of rows within a window. e.g. SUM(),MAX(),MIN(),AVG() or COUNT().
Ranking Window Function: This helps to ranks the rows within a given window. e.g. RANK(),DENSE_RANK() or ROW_NUMBER().

3.Value Window Function(): This combines multiple operations into one. Can be found through LAG(),LEAD(),FIRST_VALUE() among others.

We are going to create a table in our database called employee_salary to perform SQL Window functions.

Query:


CREATE TABLE employee_salary (
  employee_id SERIAL PRIMARY KEY,
  employee_name VARCHAR(30),
  department VARCHAR(40),
  salary INT
);

INSERT INTO employee_salary VALUES (1, 'Sam', 'IT', 5000);
INSERT INTO employee_salary VALUES (2, 'Sarah', 'Finance', 6000);
INSERT INTO employee_salary VALUES (3, 'Michael', 'HR', 5500);
INSERT INTO employee_salary VALUES (4, 'Emily', 'Marketing', 5200);
INSERT INTO employee_salary VALUES (5, 'David', 'IT', 4800);
INSERT INTO employee_salary VALUES (6, 'Rose', 'Finance', 6100);

Result:

Using Aggregate Window Function

To compare the highest and lowest salary from all records, we will use Max() and MIN() function respectively.

Query:

SELECT employee_name,department,salary, 
MAX(Salary) OVER() as highest_salary,
MIN(Salary) OVER() as lowest_salary
FROM employee_salary;

Result:

To calculate the average salary within each department, we will use the AVG() function.

Query:

SELECT employee_name, department,salary,
AVG(Salary) over(PARTITION BY department) as avg_salary
FROM employee_salary;

Result:

Using Ranking Window Function

Using ROW_NUMBER(), we will assign a unique number to each row based on salary order.

Query:

SELECT employee_name, Department, Salary,
       ROW_NUMBER() OVER(PARTITION BY Department ORDER BY Salary DESC) AS emp_row_no
FROM employee_salary  ;

Result:

Using RANK(), we will rank employees within their department based on salary in descending order.

Query:

SELECT *,
RANK() OVER(PARTITION BY department ORDER BY salary DESC) AS department_rank
FROM employee_salary;

Result:

Using DENSE_RANK(), we will rank employees by salary without skipping ranks.

Query:

SELECT employee_name, Department, Salary,
       DENSE_RANK() OVER(PARTITION BY Department ORDER BY Salary DESC) AS emp_dense_rank
FROM employee_salary ;

Result:

Using PERCENT_RANK(), we will find the relative salary position of each employee within a department.

Query:

SELECT employee_name, Department, Salary,
       PERCENT_RANK() OVER(PARTITION BY Department ORDER BY Salary DESC) AS emp_percent_rank
FROM employee_salary;

Result:

Using Value Window Function

Using LAG(), we will get employee's previous salary within their department.

Query:

SELECT*,
    LAG(salary) OVER(PARTITION BY department ORDER BY employee_id) AS previous_salary
FROM employee_salary;

Result:

Summary
SQL Window functions are powerful tools that allow for complex calculations and analysis without the need for subqueries or complex joins.
They provide flexibility with partitioning and order clauses, enabling data access from multiple rows to calculate aggregates, rank rows and perform various tasks within groups more efficiently.

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

Samuel Wachira — Fri, 13 Feb 2026 09:39:23 +0000

Introduction
In the real world, data is rarely clean, complete or analysis ready. Analysts are often handed messy spreadsheets, inconsistent databases and incomplete records and still expected to produce clear insights that drive decisions. Power BI plays a critical role in this journey by helping analysts transform raw data into structured models, write intelligent DAX calculations and deliver interactive dashboards that turn complexity into clarity.

This article explains how analysts move from messy data to actionable insights, focusing on data preparation, DAX, and dashboard design.

1. From Messy Data to Structured Information
Common Data Challenges

Before analysis even begins, analysts deal with issues such as:

Missing or duplicate records
Inconsistent naming (e.g., “Jan”, “January”, “01”)
Mixed data types (numbers stored as text)
Multiple data sources with no common key

Left unresolved, these issues lead to inaccurate reports and misleading conclusions.

Data Cleaning with Power Query

Power BI’s Power Query Editor is where analysts fix data problems. Typical transformations include:

Removing duplicates and null values
Splitting and merging columns
Standardizing formats (dates, currency, text case)
Creating calculated columns for categorization

This step ensures that data is reliable, consistent, and analysis-ready before modeling begins.

2. Data Modeling: Building the Foundation for Analysis
Fact and Dimension Tables

Analysts structure cleaned data into:

Fact tables – contain measurable values (sales, revenue, quantities)
Dimension tables – contain descriptive attributes (date, product, customer, region) This separation simplifies calculations and improves performance.

Star Schema in Practice
Most Power BI models follow a star schema, where:

A central fact table connects to multiple dimension tables
Relationships are one-to-many
Filters flow from dimensions to facts A good model makes DAX formulas simpler and dashboards faster.

3. DAX: Turning Data into Meaning
What Is DAX?
Data Analysis Expressions (DAX) is the formula language used in Power BI to create:

Measures (dynamic calculations)
Calculated columns
Time-intelligence logic DAX allows analysts to move beyond static totals to context-aware insights.

Key DAX Concepts Analysts Use:

Measures vs Calculated Columns
Measures respond to filters and slicers, making them ideal for dashboards.
Filter Context & Row Context.
Determines how and when calculations are evaluated.
Time Intelligence
Enables Year-to-Date (YTD), Month-over-Month (MoM), and Year-over-Year (YoY) analysis. Example use cases:
Total Sales by selected region
Revenue growth compared to last year
Average order value per customer segment Without DAX, dashboards would be static and far less insightful.

4. Dashboards: From Numbers to Decisions
Designing for Action
Effective dashboards are not about showing everything but they focus on what matters. Analysts:

Highlight KPIs (Revenue, Growth, Profit Margin)
Use charts that match the question being asked
Apply filters and slicers for interactivity
Storytelling with Data

Good dashboards answer questions such as:

What is happening?
Why is it happening?
What should we do next?

By combining visuals, DAX measures, and clean models, analysts guide decision-makers toward clear actions, not just observations.

5.Performance and Accuracy Matter
Poor modeling or inefficient DAX can cause:

Slow report loading
Incorrect totals
Confusing visuals
Experienced analysts optimize by:
Reducing unnecessary columns
Using measures instead of calculated columns where possible
Writing efficient DAX expressions This ensures dashboards remain fast, scalable, and trustworthy.

Conclusion
Translating messy data into actionable insights is both a technical and analytical skill. Using Power BI, analysts clean and shape raw data, design strong data models, apply powerful DAX calculations and present insights through intuitive dashboards. The result is not just reports but decision-ready intelligence that helps organizations act with confidence.

Schemas and Data Modelling in Power BI

Samuel Wachira — Mon, 02 Feb 2026 17:45:16 +0000

Introduction

Data modelling is one of the most critical aspects of building effective Power BI solutions. A well-designed data model ensures fast report performance, accurate calculations and meaningful insights for decision-makers.
Power BI relies heavily on how data is structured, relate and optimized before any visuals are created.
We will explore schemas and data modelling in Power BI; focusing on star schema, snowflake schema, fact and dimension tables, relationships and why good modelling is essential for performance and accurate reporting.

Data Modelling in Power BI

Data modelling refers to the process of organizing data into tables, defining relationships between them and structuring the data in a way that supports efficient analysis. In Power BI, the data model directly affects:

Query performance
DAX calculation accuracy
Simplicity of report design
Scalability of reports as data grows

1. Fact and Dimension Tables

a) Fact Tables

A fact table stores quantitative, measurable data that businesses want to analyze. These values are often numeric and can be aggregated.

Characteristics of fact tables:

Contain metrics (e.g. Sales Amount, Quantity, Revenue)
Usually very large
Contain foreign keys linking to dimension tables
Represent business events (sales, transactions, clicks)

Example:
FactSales

SaleID
DateKey
ProductKey
CustomerKey
SalesAmount
Quantity

b) Dimension Tables

A dimension table provides descriptive context for facts. These tables answer questions like who, what, where, and when.

Characteristics of dimension tables:

Contain descriptive attributes
Smaller than fact tables
Used for filtering, grouping, and slicing data
Have primary keys referenced by fact tables

Example:
DimProduct

ProductKey
ProductName
Category
Brand

2. Star Schema

A star schema is a data modelling structure where a central fact table is connected directly to multiple dimension tables, forming a star-like layout.

Structure

One central fact table
Multiple dimension tables
One-to-many relationships from dimensions to fact

Advantages

High performance: Optimized for Power BI’s VertiPaq engine.
Simple relationships: Easier to understand and maintain.
Accurate DAX calculations: Fewer ambiguous filter paths.
Better user experience: Business users can easily navigate fields.

Example

DimDate      DimCustomer     DimProduct
    \             |              /
              FactSales

Why Power BI Prefers Star Schema

Reduces model complexity
Minimizes relationship issues
Improves query execution speed

3. Snowflake Schema

A snowflake schema is a variation of the star schema where dimension tables are normalized into multiple related tables.

Structure

Fact table connects to dimension tables
Dimension tables further connect to sub-dimension tables

Example

FactSales
   |
DimProduct
   |
DimCategory

Advantages

Reduced data redundancy
Better storage efficiency in some databases

Disadvantages

Slower performance due to extra joins
More complex DAX calculations
Harder for report users to understand
Increased risk of incorrect filtering

Power BI Recommendation

Snowflake schemas are not ideal in Power BI. It is usually best to denormalize snowflake dimensions into flat dimension tables and convert them into a star schema.

4. Relationships in Power BI

Types of Relationships

Power BI supports several relationship types:

One-to-Many (1:*) – Most common and recommended
Many-to-Many (:) – Use cautiously
One-to-One (1:1) – Rare

Relationship Direction

Single-direction filtering (recommended)
Both-direction filtering (use only when necessary)

Poor relationship design can cause:

Incorrect totals
Ambiguous filter paths
Performance degradation

Why Good Data Modelling Is Critical

1. Performance Optimization

A clean star schema:

Reduces memory usage
Speeds up report loading
Improves interaction responsiveness

2. Accurate Reporting

Proper relationships ensure:

Correct aggregations
Accurate filters and slicers
Reliable DAX calculations

3. Simpler DAX

Well-structured models:

Reduce complex DAX logic
Prevent calculation errors
Improve maintainability

4. Scalability

Good models can handle:

Growing datasets
Additional dimensions
New business requirements without redesign

5. Better User Experience

Business users can:

Easily understand fields
Build reports without confusion
Trust the numbers presented

Best Practices for Power BI Data Modelling

Use star schema whenever possible.
Keep fact tables numeric and transactional.
Flatten dimension tables.
Avoid many-to-many relationships unless necessary
Use single-direction filtering
Hide technical keys from report view
Rename fields with business-friendly names

Conclusion

Schemas and data modelling form the foundation of effective Power BI solutions. The star schema supported by clearly defined fact and dimension tables and well-managed relationships, delivers optimal performance, accurate reporting and maintainable models. While snowflake schemas may be suitable in traditional databases.
Power BI performs best with simplified, denormalized star models. Investing time in good data modelling is essential for building scalable, reliable, and high-performing Power BI reports.

Introduction to Linux for Data Engineers

Samuel Wachira — Mon, 26 Jan 2026 19:20:04 +0000

1. Why Linux is Important for Data Engineers

Most data engineering work happens on servers and cloud platforms and almost all of them run Linux. Whether you are:

Deploying databases
Running ETL pipelines
Managing cloud virtual machines
Using tools like Hadoop, Spark, Airflow or Docker

You will interact with a Linux terminal.

Linux is important for data engineers because:

It is stable and efficient for servers
It gives powerful command-line tools for automation
Most data tools are built for Linux first

I.e.

If you work with data infrastructure, you will eventually work with Linux.

2. Understanding the Linux Terminal

The terminal is a text-based interface where you type commands to interact with the system.

When you open a terminal, you might see something like:

samwel@ubuntu-server:~$

This means:

samwel → your username
ubuntu-server → computer name
~ → home directory
$ → ready for command input

3. Basic Linux Commands

📁 Check current directory

pwd

Output:

/home/samwel

📂 List files

ls

Output:

data.csv  scripts  logs

📁 Create a new folder

mkdir projects

📄 Create an empty file

touch pipeline.py

📖 View file contents

cat data.csv

🗑️ Remove a file

rm old_data.csv

🌍 Download data from the web

wget https://example.com/data.csv

🔗 Connect to a remote server

ssh user@192.165.1.10

This is common in data engineering when working with cloud servers.

4. Editing Files in Linux: Nano vs Vi

Data engineers often edit:

Configuration files
Python scripts
SQL files

Two popular terminal editors are Nano and Vi.

5. Using Nano

Open or create a file:

nano script.py

Terminal view:

 GNU nano 6.2              script.py

 print("Hello Data Engineering!")

^X Exit   ^O Save   ^K Cut   ^U Paste

Actions:

Press CTRL + O → Save
Press ENTER to confirm
Press CTRL + X → Exit

Nano is simple and perfect for beginners.

6. Using Vi

Vi is faster but has modes.

Open a file:

vi script.py

Vi Modes:

Mode	Purpose
Normal	Navigation
Insert	Typing text
Command	Saving and quitting

➤ Enter Insert Mode

Press:

Now type:

print("Hello from Vi Editor")

➤ Save and Exit

Press:

ESC

Then type:

:wq

Press ENTER.

Meaning:

:w → write (save)
:q → quit

➤ Exit without saving

:q!

7. Why These Skills Matter for Data Engineers

Editing configuration files on servers
Writing Python ETL scripts remotely
Managing cron jobs for scheduled pipelines
Fixing errors directly in cloud terminals
Deploying database services

Mastering Linux editing tools saves time and prevents mistakes.

8. Summary

Concept	Key Point
Linux	Core operating system for data infrastructure
Terminal	Command-based system control
Basic Commands	Navigate, create, delete, download files
Nano	Easy editor for beginners
Vi	Advanced editor used on servers
Practical Use	Editing scripts and configs directly on servers

Final Thoughts

Linux may look scary at first, but once you practice basic commands and text editing, it becomes natural. For data engineers, Linux is is a daily working environment.

Git & GitHub for Beginners: A Simple Guide to Version Control

Samuel Wachira — Sun, 18 Jan 2026 11:09:39 +0000

If you are learning programming, sooner or later you will hear about Git and GitHub. At first, they may sound confusing but once you understand the basics, they become essential tools in every developer’s workflow.

In this article, you will learn:

What Git is and why version control matters
How to push code to GitHub
How to pull code from GitHub
How to track changes using Git

Let’s go step by step.

What is Git?

Git is a version control system.
It helps you track changes in your code over time.

Think of Git like a time machine for your project:

You can save versions of your code
Go back to previous versions if something breaks
See who changed what and when
Work with other developers without overwriting each other’s work Git runs locally on your computer.

Why Version Control is Important

Imagine this situation:

You are working on a project.
You make changes.
Suddenly, your code stops working.
You wish you could go back to yesterday’s working version.

Without version control:

You would have to manually copy folders.
You might lose working code.
Collaboration becomes messy.

With Git:

Every saved version is stored safely
You can experiment without fear
Teams can work together smoothly

That is why version control is essential in real-world development.

What is GitHub?

GitHub is an online platform that stores Git repositories.

Git - tool on your computer
GitHub - cloud storage for your Git projects

It allows:

Backup of your projects online
Sharing code with others
Collaboration on open-source projects

Installing Git

Download Git from:
https://git-scm.com/

After installation, verify:

git --version

Basic Git Setup

Before using Git, set your username and email:

git config --global user.name "Your Name"
git config --global user.email "youremail@example.com"

How to Track Changes Using Git

Step 1: Initialize Git in your project

Inside your project folder:

git init

This creates a hidden .git folder — your local repository.

Step 2: Check file status

git status

This shows:

Which files are new
Which files were modified
Which files are ready to commit

Step 3: Add files to staging

To track a file:

git add filename

Or add everything:

git add .

Step 4: Commit changes

A commit saves a snapshot of your project.

git commit -m "Added homepage layout"

Each commit has:

A unique ID
A message describing the change

Step 5: View commit history

git log

How to Push Code to GitHub

Step 1: Create a repository on GitHub

Go to https://github.com
Click New Repository
Give it a name
Click Create Repository

Step 2: Connect local Git to GitHub

Copy the repository URL from GitHub, then run:

git remote add origin https://github.com/yourusername/your-repo.git

Step 3: Push your code

git branch -M main
git push -u origin main

Now your project is uploaded to GitHub 🎉

How to Pull Code from GitHub

If you want to download updates from GitHub to your computer:

git pull origin main

This fetches the latest changes and merges them into your local project.

Bonus: Cloning a GitHub Repository

If a project already exists on GitHub, you can copy it to your computer:

git clone https://github.com/username/repository.git

Common Git Workflow

Make changes to code
git status
git add .
git commit -m "message"
git push

Repeat 🚀

Final Thoughts

Git and GitHub may seem complex at first, but once you practice the basic commands, they become second nature.
They help you:

Keep your code safe
Work confidently
Collaborate professionally If you are serious about software development, mastering Git is a must.

Quick Command Summary

git init
git status
git add .
git commit -m "message"
git push
git pull
git clone
git log