GITHUB COMPLETE GUIDE FOR DATA ANALYSTS
Turn Your Data Projects Into a Professional Portfolio
GitHub is more than a place to store code.
For a data analyst, it can become a portfolio that demonstrates how you:
Understand business problems
Organize data projects
Write SQL queries
Analyze data with Python
Build dashboards
Document your process
Communicate insights
Make recommendations
A resume tells recruiters which tools you know.
GitHub shows how you use those tools to solve problems.
The complete GitHub portfolio workflow is:
Create → Organize → Document → Upload → Improve → Publish → Share
1. What Is GitHub?
GitHub is an online platform for storing, managing, documenting, and sharing projects.
It is built around Git, a version-control system that tracks changes made to files over time.
Data analysts can use GitHub to share:
SQL queries
Python scripts
Jupyter notebooks
Excel projects
Power BI dashboards
Tableau projects
Data-cleaning workflows
Exploratory data analysis
Statistical analysis
Project documentation
Dashboard screenshots
Business insights
Recommendations
GitHub helps other people review both your final output and the process you followed to create it.
Create a free GitHub account:
Official GitHub documentation:
2. Understand Git and GitHub
Git and GitHub are related, but they are not the same.
Git
Git is a version-control system installed on your computer.
It tracks changes made to files inside a project.
Git helps you:
Save project history
Review previous versions
Work on separate branches
Restore earlier work
Collaborate without overwriting files
GitHub
GitHub is an online platform that hosts Git repositories.
GitHub helps you:
Store projects online
Share repositories
Build a public portfolio
Collaborate with others
Review project history
Manage issues and tasks
Publish documentation
Host a simple portfolio website
Simple rule:
Git tracks changes. GitHub stores and shares the project online.
3. Why Data Analysts Should Use GitHub
A strong GitHub profile can show evidence of your analytical abilities.
It can demonstrate:
Technical knowledge
Project organization
Business understanding
Analytical thinking
Written communication
Documentation ability
Consistent learning
Attention to detail
Recruiters and hiring managers can review:
The questions you answered
The tools you selected
The queries you wrote
The calculations you created
The charts you produced
The insights you discovered
The recommendations you made
A strong project should show more than code.
It should explain:
What was the problem?
What data was available?
How was the data prepared?
What analysis was performed?
What was discovered?
What action could be considered?
4. Create a Professional GitHub Profile
Your profile should help someone understand your target role and strongest skills within a few seconds.
Add a Professional Profile Photo
Use a clear photograph or a simple professional image.
Avoid:
Blurry photos
Distracting backgrounds
Unrelated logos
Low-quality images
Use the same or a similar profile image across GitHub, LinkedIn, and your portfolio website when practical.
Write a Clear Name and Bio
A good bio should include:
Target role
Core skills
Area of interest
Example:
Aspiring Data Analyst | SQL | Excel | Power BI | Python
Another example:
Data Analyst building projects in SQL, Tableau, Python and business intelligence
Avoid unclear bios such as:
Student | Learner | Dreamer
These descriptions do not explain what type of work you can perform.
Add Relevant Links
You can add links to:
LinkedIn
Personal website
Tableau Public
Power BI portfolio
Kaggle
Blog
Resume
Add Your Location
Adding a general city, region, or country can help people understand your location and time zone.
Do not publish a private residential address.
Review Your Public Email
Only display an email address that you are comfortable sharing publicly.
Consider using a professional email address created for career and portfolio communication.
5. Create a GitHub Profile README
A profile README appears near the top of your GitHub profile.
It can explain:
Who you are
Which role you are targeting
Which tools you use
What you are currently learning
Which projects you have built
How people can contact you
How to Create It
Create a new public repository with exactly the same name as your GitHub username.
For example, if your username is:
alex-data
create a repository named:
alex-data
Initialize it with a README.md file.
GitHub can then display that README on your profile.
Official guide:
Profile README Template
# Hi, I’m Alex
I am an aspiring data analyst focused on turning raw data into practical business insights.
## Skills
- SQL
- Excel
- Power BI
- Tableau
- Python
- Pandas
- Data visualization
- Business analysis
## Featured Projects
### E-Commerce Sales Analysis
Analyzed sales, profit, products and customer performance using SQL and Power BI.
### Customer Churn Analysis
Used Python to identify patterns associated with customer churn.
### HR Attrition Dashboard
Built an interactive Tableau dashboard to explore employee attrition.
## Currently Learning
- Advanced SQL
- DAX
- Statistics
- Data modeling
## Connect With Me
- LinkedIn: Add your link
- Tableau Public: Add your link
- Email: Add your professional email
Keep the Profile README Focused
Avoid adding:
Dozens of badges
Too many animated images
Unrelated quotes
Every tool you have ever opened
Skill claims that your projects do not support
Large sections that distract from your work
Your projects should remain the main evidence of your skills.
6. Understand GitHub Repositories
A repository is a folder that stores one complete project.
A repository can contain:
Data files
SQL scripts
Python notebooks
Dashboard files
Images
Documentation
Project history
Configuration files
Use One Repository Per Project
Create a separate repository for each major project.
Examples:
ecommerce-sales-analysis
customer-churn-analysis
hr-attrition-dashboard
marketing-campaign-performance
sql-retail-case-study
Avoid unclear names such as:
project1
final-project
new-project
analysis-final-final
test-repository
A recruiter should understand the project topic from its repository name.
Public vs Private Repositories
Public Repository
A public repository can be viewed by other people.
Use public repositories for:
Portfolio projects
Open datasets
Learning exercises
Documentation
Public collaboration
Private Repository
A private repository can only be accessed by authorized users.
Use private repositories for:
Client work
Company information
Confidential datasets
Personal records
Unfinished sensitive projects
Never make private business data public simply to build a portfolio.
7. Create Your First Repository
Method 1: Create It on GitHub
Sign in to GitHub
Select New repository
Enter a clear repository name
Add a short description
Choose public or private
Add a README
Add a .gitignore when required
Select a licence when appropriate
Create the repository
Official repository guide:
Example Repository Description
SQL and Power BI analysis of e-commerce sales, products, customers and regional profitability.
Avoid descriptions such as:
My data project
Method 2: Use GitHub Desktop
GitHub Desktop provides a graphical interface for working with Git and GitHub.
It can be easier for beginners who are not yet comfortable using the command line.
Download GitHub Desktop:
https://desktop.github.com/download/
Method 3: Use Git From the Command Line
You can create a local Git repository and connect it to GitHub.
Example:
git init
git add .
git commit -m "Create initial project structure"
git branch -M main
git remote add origin YOUR_REPOSITORY_URL
git push -u origin main
Replace YOUR_REPOSITORY_URL with the URL of your repository.
8. Use a Clear Repository Structure
A clean folder structure makes a project easier to review.
Recommended General Structure
project-name/
│
├── data/
│ ├── raw/
│ ├── cleaned/
│ └── data_dictionary.md
│
├── sql/
│ ├── data_cleaning.sql
│ ├── exploratory_analysis.sql
│ └── business_queries.sql
│
├── notebooks/
│ ├── data_cleaning.ipynb
│ └── exploratory_analysis.ipynb
│
├── scripts/
│ └── analysis.py
│
├── dashboard/
│ ├── dashboard_file
│ └── dashboard_notes.md
│
├── images/
│ ├── dashboard-overview.png
│ └── data-model.png
│
├── README.md
├── requirements.txt
├── .gitignore
└── LICENSE
Not every project needs every folder.
Only include folders that serve a purpose.
9. SQL Project Folder Structure
A SQL project can use the following structure:
sql-sales-analysis/
│
├── data/
│ ├── sample_data.csv
│ └── data_dictionary.md
│
├── schema/
│ ├── create_tables.sql
│ └── insert_sample_data.sql
│
├── queries/
│ ├── 01_data_validation.sql
│ ├── 02_sales_analysis.sql
│ ├── 03_customer_analysis.sql
│ └── 04_product_analysis.sql
│
├── images/
│ ├── schema.png
│ └── results-preview.png
│
└── README.md
Include in a SQL Project
Database schema
Table descriptions
Business questions
SQL dialect
Data-cleaning queries
Joins
Aggregations
CTEs
Window functions
Final queries
Result screenshots
Key insights
SQL File Example
-- Question:
-- Which product categories generated the most revenue?
SELECT
p.category,
SUM(o.quantity * o.unit_price) AS total_revenue
FROM orders AS o
JOIN products AS p
ON o.product_id = p.product_id
GROUP BY
p.category
ORDER BY
total_revenue DESC;
Use comments to explain business logic that is not immediately clear.
10. Python Project Folder Structure
A Python analytics project can use:
customer-churn-analysis/
│
├── data/
│ ├── raw/
│ └── cleaned/
│
├── notebooks/
│ ├── 01_data_cleaning.ipynb
│ ├── 02_exploratory_analysis.ipynb
│ └── 03_churn_analysis.ipynb
│
├── src/
│ ├── cleaning.py
│ └── visualization.py
│
├── images/
│ ├── churn-by-contract.png
│ └── churn-by-tenure.png
│
├── requirements.txt
├── README.md
└── .gitignore
Include in a Python Project
Import statements
Data validation
Cleaning process
Missing-value handling
Duplicate checks
Exploratory data analysis
Charts
Written observations
Statistical assumptions
Key insights
Limitations
Recommendations
Requirements File Example
pandas
numpy
matplotlib
openpyxl
jupyter
For more reproducibility, include package versions after testing the project.
Example:
pandas==2.3.0
numpy==2.2.0
matplotlib==3.10.0
11. Power BI Project Structure
A Power BI project repository can use:
power-bi-sales-dashboard/
│
├── data/
│ ├── sales_sample.xlsx
│ └── data_dictionary.md
│
├── dashboard/
│ └── sales-dashboard.pbix
│
├── documentation/
│ ├── dax-measures.md
│ ├── power-query-steps.md
│ └── data-model.md
│
├── images/
│ ├── executive-overview.png
│ ├── product-analysis.png
│ └── data-model.png
│
└── README.md
Include in a Power BI Project
PBIX file when practical
Dashboard screenshots
Dataset source
Data model diagram
Power Query steps
DAX measures
KPI definitions
Business questions
Key insights
Limitations
Recommendations
A recruiter may not have Power BI Desktop installed.
Always include screenshots and written explanations.
DAX Documentation Example
## Total Revenue
```DAX
Total Revenue =
SUM(Sales[Revenue])
Calculates total revenue within the current report filter context.
---
# 12. Tableau Project Structure
A Tableau project can use:
```text
tableau-customer-analysis/
│
├── data/
│ └── customer_data.csv
│
├── workbook/
│ └── customer-analysis.twbx
│
├── calculations/
│ └── calculated-fields.md
│
├── images/
│ ├── dashboard-overview.png
│ └── customer-segments.png
│
├── links/
│ └── tableau-public-link.md
│
└── README.md
Include in a Tableau Project
Tableau workbook
Tableau Public link
Dashboard screenshots
Calculated fields
Table calculations
LOD expressions
Data source
Business questions
Key findings
Recommendations
A public Tableau link makes the project easier to explore interactively.
13. Excel Project Structure
An Excel analysis repository can use:
excel-finance-analysis/
│
├── data/
│ └── finance_data.xlsx
│
├── workbook/
│ └── finance-dashboard.xlsx
│
├── documentation/
│ ├── formulas.md
│ ├── cleaning-process.md
│ └── pivot-table-notes.md
│
├── images/
│ ├── dashboard.png
│ └── monthly-analysis.png
│
└── README.md
Include in an Excel Project
Excel workbook
Data source
Dashboard screenshots
Formula explanations
Pivot-table process
Power Query steps
KPI definitions
Insights
Recommendations
Do not upload a spreadsheet without explaining what it contains.
14. Write a Strong README
The README is usually the first project file someone reads.
It should explain the project without forcing the reader to open every file.
A strong README should answer:
What is the project?
Why does it matter?
Which data was used?
Which tools were used?
How was the analysis performed?
What was discovered?
What should the business consider doing?
How can someone review or reproduce the work?
Official README documentation:
15. Complete Data Project README Template
# E-Commerce Sales Analysis
## Project Overview
This project analyzes e-commerce sales data to understand revenue, profitability, customer behaviour, product performance and regional trends.
## Business Problem
The company has experienced revenue growth, but management does not know whether that growth is producing sustainable profit.
The analysis investigates:
- Which products generate the most revenue?
- Which products have low or negative profit?
- Which regions are underperforming?
- How do discounts affect profitability?
- Which customers contribute the most value?
- How is performance changing over time?
## Dataset
Source: Add the dataset link
Main fields:
- Order ID
- Order Date
- Customer ID
- Product
- Category
- Quantity
- Sales
- Cost
- Profit
- Discount
- Region
## Tools Used
- SQL
- Python
- Power BI
- Excel
- GitHub
## Project Structure
- `data/` contains the project dataset
- `sql/` contains SQL queries
- `notebooks/` contains Python analysis
- `dashboard/` contains dashboard files
- `images/` contains screenshots
## Data Preparation
The following steps were completed:
- Removed duplicate records
- Reviewed missing values
- Corrected data types
- Standardized category names
- Validated order dates
- Checked revenue and profit calculations
- Created a date table
- Documented assumptions
## Analysis
The analysis covered:
- Monthly revenue trends
- Profitability by product
- Regional performance
- Customer value
- Discount impact
- Product ranking
## Key Insights
1. Technology generated the highest revenue.
2. Several high-revenue products produced low profit.
3. The West region had strong sales but lower margins.
4. A small customer group generated a large share of revenue.
5. Higher discount bands were associated with weaker profitability.
## Recommendations
- Review discounts on low-margin products
- Prioritize high-value customer retention
- Investigate costs in underperforming regions
- Track revenue and margin together
- Create product-level profitability targets
## Dashboard Preview
Add dashboard image here.
## How to Use This Project
1. Download or clone the repository
2. Open the dataset
3. Run the SQL queries or Python notebook
4. Open the dashboard file
5. Review the README and documented assumptions
## Limitations
- The dataset does not include product acquisition cost
- Customer demographics are limited
- The analysis identifies patterns, not proven causes
- Some recommendations require additional operational data
## Author
Add your name, LinkedIn and portfolio links.
16. Write Better Business Problems
Weak project description:
I analyzed sales data.
Better project description:
I analyzed sales and profitability to identify which products, customers and regions were driving growth and which areas were reducing margins.
A strong business problem should include:
Business context
Stakeholder
Problem
Objective
Questions
Expected output
Example
Stakeholder
Sales and finance managers.
Problem
Revenue is growing, but profit margin is declining.
Objective
Identify the products, regions, customers, and discount patterns contributing to the decline.
Final Output
An interactive dashboard and written recommendations.
17. Document the Dataset
Every project should explain its dataset.
Include:
Dataset name
Dataset source
Download link
Licence or usage conditions
Time period
Number of tables
Important fields
Missing information
Modifications made
Known limitations
Data Dictionary Example
Field
Description
Type
Order ID
Unique order identifier
Text
Order Date
Date the order was created
Date
Customer ID
Unique customer identifier
Text
Product ID
Unique product identifier
Text
Quantity
Units purchased
Integer
Sales
Revenue generated
Decimal
Profit
Revenue minus recorded cost
Decimal
Region
Sales region
Text
Create a file such as:
data_dictionary.md
This makes your project easier to understand.
18. Show Your Technical Process
Do not upload only the final dashboard.
Show how you reached the result.
For SQL Projects
Include:
Table schemas
Data-validation queries
Cleaning queries
Joins
CTEs
Subqueries
Window functions
Business calculations
Final outputs
For Python Projects
Include:
Imports
Data inspection
Missing-value analysis
Duplicate checks
Data cleaning
Exploratory analysis
Charts
Written observations
Final conclusions
For Power BI Projects
Include:
Power Query steps
Model diagram
Relationships
Date table
DAX measures
Dashboard pages
Security assumptions
For Tableau Projects
Include:
Data source
Relationships or joins
Calculated fields
Table calculations
LOD expressions
Dashboard actions
Tableau Public link
For Excel Projects
Include:
Cleaning process
Formulas
Pivot tables
Power Query steps
Charts
Dashboard screenshots
19. Add Dashboard Screenshots
Recruiters may not have the software required to open your dashboard file.
Add screenshots showing:
Full dashboard
KPI section
Important charts
Filters or slicers
Data model
Key findings
Store them inside:
images/
Add an Image to a README
Use meaningful filenames.
Good:
executive-sales-dashboard.png
customer-segment-analysis.png
power-bi-data-model.png
Avoid:
image1.png
screenshot-final.png
capture2.png
Protect Sensitive Information
Before uploading screenshots, check for:
Customer names
Email addresses
Phone numbers
Employee IDs
Internal URLs
Database names
Confidential KPIs
Company credentials
20. Use Markdown to Format Documentation
GitHub uses Markdown for README files and other documentation.
Official Markdown guide:
Heading
# Main Title
## Section
### Subsection
Bold Text
**Important text**
Bullet List
- SQL
- Python
- Power BI
Numbered List
1. Import data
2. Clean records
3. Analyze performance
4. Build dashboard
Link
[View Dashboard](https://example.com)
Image
Inline Code
Use the `GROUP BY` clause to summarize records.
Code Block
```sql
SELECT *
FROM orders;
```
Table
| Metric | Value |
|---|---:|
| Revenue | 500,000 |
| Profit | 80,000 |
21. Understand Commits
A commit records a meaningful change in the project.
Examples of changes worth committing:
Create project structure
Add dataset documentation
Clean missing values
Add customer queries
Build dashboard page
Add project screenshots
Update README
Correct calculation
Good Commit Messages
Add customer retention queries
Create sales dashboard overview
Document data-cleaning assumptions
Fix duplicate order calculation
Add dashboard screenshots
Update README with key insights
Weak Commit Messages
Update
Changes
Final
Done
Files
New version
A good commit message explains what changed.
Basic Commit Commands
git status
git add .
git commit -m "Add customer segmentation analysis"
git push
Commit in Logical Stages
Avoid creating one large commit containing the entire finished project.
A clear history could be:
Create initial project structure
Add raw dataset and data dictionary
Clean missing customer values
Add SQL revenue analysis
Add product ranking queries
Build dashboard overview
Add README and recommendations
22. Understand Branches
A branch is a separate line of work inside a repository.
Branches let you make changes without immediately affecting the main project.
Common branch names:
add-customer-analysis
improve-readme
fix-profit-calculation
create-dashboard-page
Basic Branch Workflow
git checkout -b improve-readme
Make your changes.
Then:
git add .
git commit -m "Improve project documentation"
git push -u origin improve-readme
Branches are useful when:
Testing a new analysis
Fixing a calculation
Redesigning a dashboard
Collaborating with another person
Making a change that needs review
Official branch documentation:
23. Understand Pull Requests
A pull request proposes changes from one branch to another.
It allows people to:
Review changes
Discuss the approach
Suggest improvements
Approve work
Merge the update
A simple workflow is:
Create branch
→ Make changes
→ Commit changes
→ Push branch
→ Open pull request
→ Review
→ Merge
For a personal portfolio, pull requests are not required for every small change.
However, using them occasionally can demonstrate that you understand collaborative GitHub workflows.
Official guide:
24. Use a .gitignore File
A .gitignore file tells Git which files or directories should not be tracked.
Use it for:
Credentials
Environment files
Temporary files
Cache folders
Virtual environments
Private data
Operating-system files
Generated files
Data Analytics .gitignore Example
# Credentials and secrets
.env
*.key
secrets/
# Private data
data/private/
data/confidential/
# Python
__pycache__/
*.pyc
.venv/
venv/
# Jupyter
.ipynb_checkpoints/
# Operating system
.DS_Store
Thumbs.db
# Editor settings
.vscode/
.idea/
# Temporary exports
temp/
exports/
Important:
Adding a file to .gitignore does not remove it when Git is already tracking it.
Official documentation:
https://docs.github.com/en/get-started/getting-started-with-git/ignoring-files
Official templates:
https://github.com/github/gitignore
25. Never Upload Secrets
Do not upload:
Passwords
API keys
Database credentials
Access tokens
Private certificates
Cloud credentials
Connection strings
Confidential URLs
Store secret values in an environment file such as:
.env
Then add .env to .gitignore.
Example Python pattern:
import os
database_password = os.getenv("DATABASE_PASSWORD")
If a credential is accidentally pushed:
Revoke or rotate it immediately
Remove it from the current project
Review repository history
Follow the service provider’s security instructions
Deleting a secret from the latest file does not automatically remove it from previous Git history.
26. Handle Large Files Carefully
Data projects can contain large files such as:
CSV datasets
Excel workbooks
PBIX files
Tableau packaged workbooks
Images
Model files
Database exports
Large files can make a repository difficult to clone and maintain.
Better options include:
Use a smaller sample dataset
Link to the original dataset
Store only cleaned samples
Compress appropriate files
Use cloud storage
Use Git Large File Storage
Document how to download the complete data
GitHub large-file guide:
Git LFS guide:
Git LFS Example
git lfs install
git lfs track "*.pbix"
git add .gitattributes
git add dashboard.pbix
git commit -m "Add Power BI dashboard using Git LFS"
Only use Git LFS after reviewing its current storage and transfer conditions.
27. Add a Licence
A licence explains how other people may use, modify, or distribute your project.
Without a clear licence, people should not assume they have permission to reuse your work.
Common licences include:
MIT
Apache 2.0
GNU GPL
Creative Commons licences for suitable non-code materials
Choose a licence that matches your intended usage.
Do not add a licence to data you do not own unless the dataset’s terms permit it.
Official guide:
Licence selection guide:
28. Pin Your Best Projects
Pinned repositories appear prominently on your profile.
Pin projects that demonstrate different abilities.
A strong set could include:
SQL business case study
Power BI dashboard
Python exploratory analysis
Tableau dashboard
Excel reporting project
End-to-end analytics project
Prioritize:
Complete projects
Clear README files
Strong screenshots
Business-focused analysis
Different tools
Different analytical skills
Do not pin unfinished repositories with unclear documentation.
Official profile guide:
https://docs.github.com/en/account-and-profile/tutorials/personalize-your-profile
29. Build a Balanced Data Portfolio
A strong portfolio should demonstrate more than one tool.
Project 1: SQL Sales Analysis
Show:
Joins
Aggregations
CTEs
Window functions
Business questions
Query documentation
Project 2: Power BI Dashboard
Show:
Power Query
Data modeling
DAX
KPIs
Interactive visuals
Business recommendations
Project 3: Python Exploratory Analysis
Show:
Pandas
Data cleaning
Exploratory analysis
Charts
Written observations
Reproducibility
Project 4: Tableau Dashboard
Show:
Calculated fields
Table calculations
LOD expressions
Dashboard actions
Data storytelling
Project 5: Excel Business Report
Show:
Formulas
Pivot tables
Power Query
Charts
Dashboard design
Project 6: End-to-End Project
Combine:
SQL
Python
Dashboard tool
GitHub documentation
Business recommendations
Quality matters more than quantity.
Five complete, clearly documented projects are usually more useful than twenty unfinished repositories.
30. Data Analyst Project Ideas
1. E-Commerce Sales Analysis
Analyze:
Revenue
Profit
Products
Customers
Regions
Discounts
Monthly performance
2. Customer Churn Analysis
Analyze:
Contract type
Customer tenure
Service usage
Charges
Complaints
Churn patterns
3. HR Attrition Analysis
Analyze:
Department
Salary
Tenure
Overtime
Job role
Attrition rate
Do not present correlation as proof of causation.
4. Marketing Campaign Analysis
Analyze:
Campaign spend
Impressions
Clicks
Leads
Conversions
Cost per acquisition
Return on advertising spend
5. Financial Performance Analysis
Analyze:
Revenue
Expenses
Profit
Budget variance
Cash flow
Monthly growth
6. Customer Support Analysis
Analyze:
Ticket volume
Resolution time
Response time
Escalations
Satisfaction
Agent performance
7. Product Funnel Analysis
Analyze:
Visits
Sign-ups
Activation
Conversion
Retention
Drop-off
8. Supply-Chain Analysis
Analyze:
Inventory
Delivery time
Supplier performance
Stockouts
Shipping cost
Order fulfilment
31. Free Practice Datasets
Kaggle
Datasets covering business, finance, healthcare, marketing, sports, and technology.
https://www.kaggle.com/datasets
Maven Analytics Data Playground
Portfolio-friendly datasets for analysis projects.
https://mavenanalytics.io/data-playground
Data.gov
Public datasets from the United States government.
World Bank Open Data
Economic, demographic, and development datasets.
Google Dataset Search
Search for datasets available across the web.
https://datasetsearch.research.google.com/
Microsoft Power BI Samples
Official Power BI sample datasets and reports.
https://learn.microsoft.com/en-us/power-bi/create-reports/sample-datasets
Tableau Public Learning Resources
Sample data and Tableau learning material.
https://public.tableau.com/app/learn
Before using a dataset, review:
Licence
Attribution requirements
Privacy restrictions
Usage limitations
Missing information
Data quality
32. Free GitHub Learning Resources
GitHub Documentation
Official product documentation.
GitHub Hello World
Learn repositories, branches, commits, and pull requests.
https://docs.github.com/en/get-started/start-your-journey/hello-world
GitHub Skills
Interactive courses for learning GitHub workflows.
GitHub Learn
Curated learning resources and training options.
Microsoft Learn for GitHub
Free modules and learning paths.
https://learn.microsoft.com/en-us/training/github/
GitHub Desktop
A graphical application for managing repositories.
https://desktop.github.com/download/
Git Documentation
Official Git reference and learning material.
Pro Git Book
A free book explaining Git from beginner to advanced level.
https://git-scm.com/book/en/v2
Markdown Documentation
Learn how to format README files.
Repository Quickstart
Learn how to create and manage a repository.
GitHub Flow
Learn the branch, commit, pull-request, and merge workflow.
https://docs.github.com/en/get-started/using-github/github-flo
33. Create a Portfolio Website With GitHub Pages
GitHub Pages can publish a static website directly from a repository.
You can use it to create:
Personal portfolio
Resume website
Project directory
Blog
Analytics case-study site
Official introduction:
https://docs.github.com/en/pages/getting-started-with-github-pages/what-is-github-pages
Quickstart:
https://docs.github.com/en/pages/quickstart
Basic Portfolio Sections
Home
About
Skills
Projects
Resume
Contact
Project Card Example
E-Commerce Sales Dashboard
Tools:
SQL, Power BI, Excel
Analyzed revenue, profitability, customer behaviour and regional performance.
Links:
View Project
View Dashboard
View Repository
A GitHub Pages website is optional.
A well-organized GitHub profile with strong pinned projects can already function as a useful portfolio.
34. A 30-Day GitHub Learning Roadmap
Week 1: GitHub Foundations
Day 1
Create a GitHub account
Add profile photo
Write name and bio
Add LinkedIn link
Day 2
Learn repositories
Create your first repository
Add a README
Day 3
Learn basic Markdown
Format headings, links, images, and code
Day 4
Install GitHub Desktop or Git
Clone a repository
Day 5
Create and edit files
Make your first commit
Day 6
Push changes to GitHub
Review project history
Day 7
Create your profile README
Week 2: Project Organization
Day 8
Create a data project folder structure
Day 9
Add a dataset and data dictionary
Day 10
Add SQL scripts or a Python notebook
Day 11
Add screenshots
Day 12
Write the business problem
Day 13
Write the analysis process
Day 14
Document insights and recommendations
Week 3: Git Workflow
Day 15
Learn branches
Day 16
Create a project branch
Day 17
Commit changes to the branch
Day 18
Open a pull request
Day 19
Review and merge the pull request
Day 20
Create a .gitignore file
Day 21
Review security and sensitive-file handling
Week 4: Portfolio Development
Day 22
Complete one SQL project
Day 23
Improve its README
Day 24
Add a dashboard project
Day 25
Add dashboard screenshots and formulas
Day 26
Complete a Python or Excel project
Day 27
Pin your strongest repositories
Day 28
Review repository names and descriptions
Day 29
Add GitHub links to LinkedIn and your resume
Day 30
Review the full profile as a recruiter would
35. Common GitHub Portfolio Mistakes
Mistake 1: Uploading Files Without a README
Files without context are difficult to evaluate.
Explain the problem, process, and results.
Mistake 2: Using Unclear Repository Names
Avoid names such as:
project1
test
final
new-folder
Use descriptive names.
Mistake 3: Uploading Only a Dashboard File
Add:
Screenshots
KPI definitions
Calculations
Insights
Recommendations
Mistake 4: Copying Tutorial Projects
Tutorials can help you learn, but your portfolio should include your own analysis, questions, decisions, and documentation.
Always credit the original source.
Mistake 5: Uploading Private Data
Never upload confidential customer, employee, client, or company data.
Mistake 6: Keeping Messy Filenames
Avoid:
analysis-final-v2-new.ipynb
dashboard-last-final.pbix
query-copy-3.sql
Use:
customer-churn-analysis.ipynb
sales-dashboard.pbix
customer-retention.sql
Mistake 7: Including Broken Links
Test:
Dashboard links
Dataset links
Image paths
Notebook links
Portfolio links
Mistake 8: Adding Too Many Weak Projects
Prioritize fewer, stronger projects.
Mistake 9: Listing Insights Without Evidence
Connect each insight to a calculation, chart, or query.
Mistake 10: Making Unsupported Recommendations
Recommendations should follow from the analysis and clearly stated assumptions.
Mistake 11: Ignoring Reproducibility
Explain:
Required software
Package dependencies
File locations
Execution order
Database dialect
Mistake 12: Uploading Secrets
Check every file before committing.
36. GitHub Portfolio Checklist
Profile
Professional profile image added
Name and role are clear
Bio includes relevant skills
LinkedIn or website is linked
Profile README is complete
Best projects are pinned
Repository
Repository name is descriptive
Description explains the project
Public or private setting is correct
Folder structure is clean
Unnecessary files are removed
.gitignore is configured
Licence is reviewed
README
Project overview included
Business problem explained
Dataset documented
Tools listed
Process explained
Project structure described
Calculations documented
Insights included
Recommendations included
Limitations included
Screenshots added
Links tested
Technical Work
SQL is formatted
Python code is readable
Notebooks are organized
Charts have clear titles
Dashboard calculations are documented
Business metrics are defined
Edge cases are considered
Comments explain complex logic
Data Safety
No passwords uploaded
No API keys uploaded
No private customer data uploaded
No confidential company data uploaded
No personal identifiers exposed
Dataset licence reviewed
Screenshots reviewed
Final Review
Repository opens correctly
README displays correctly
Images load
Files use clear names
Commit history is understandable
Public links work
Project can be explained in an interview
Final Advice
Do not use GitHub only as online storage.
Use it to explain how you think.
For every project, show:
The business problem
The dataset
The questions
The cleaning process
The technical work
The calculations
The final output
The insights
The recommendations
The limitations
A strong data portfolio does not contain the most files.
It contains a small number of complete projects that clearly demonstrate how you turn raw data into useful business answers.
Follow me for more such insights
Instagram : https://www.instagram.com/dataelevate_engineer/
Linkedin : https://www.linkedin.com/in/abhisek-sahu-84a404b1/