Forem: DataLane

The Ultimate Guide to SQL Joins and Subqueries Explained

DataLane — Mon, 08 Sep 2025 05:36:51 +0000

If you’re following along with my SQL Series, welcome to Part 2 🎉 🎉

In the first part, we focused on the basics of retrieving and filtering data from a single table. Now, we’re taking the next big step: learning how to work with data spread across multiple tables.

We’ll break down the different types of joins, look at practical use cases, and then explore how subqueries can make your queries more flexible and easier to maintain.

What are SQL JOINS?

In relational databases, data is often stored across multiple normalized tables. For example, employees and departments might live in two separate tables. But in real-world business queries, you almost always need combined information.

A JOIN in SQL allows you to query data from two or more tables based on a related column between them (often a primary key and foreign key relationship).

Syntax:

SELECT column_list
FROM table1
JOIN table2
ON table1.common_column = table2.common_column;

When to Use JOINS

JOINS should be used when:

Your data is normalized into multiple tables (e.g., Customers, Orders, Products).
You want to generate comprehensive reports combining multiple entities (e.g., customer details + their purchases).
You need data validation, ensuring only matching records across tables are retrieved.
You’re building reports or dashboards where relationships between entities matter.

Different Types of SQL JOINs

Here are the main types of joins in SQL:

INNER JOIN → Returns records that have matching values in both tables
LEFT (OUTER) JOIN → Returns all records from the left table, and the matched records from the right table
RIGHT (OUTER) JOIN → Returns all records from the right table, and the matched records from the left table
FULL (OUTER) JOIN → Returns all records when there is a match in either left or right table
CROSS JOIN → represents the Cartesian product (all combinations).

Example Dataset:

For this guide, we’ll be working with a classic use case that most organizations deal with throughout.

We’ll use two main tables:

Employees
Departments

employee_id	name	department_id	salary	hire_date
1	Alice	101	70000	2019-01-15
2	Bob	102	55000	2020-03-12
3	Charlie	NULL	40000	2018-07-23
4	Diana	103	62000	2017-09-10
5	Ethan	101	72000	2021-06-19
6	Farah	104	58000	2022-02-14
7	George	NULL	45000	2016-11-05

department_id	department_name	location
101	HR	New York
102	IT	San Francisco
103	Marketing	Chicago
104	Finance	Boston
105	Operations	Dallas

Have a look at the tables and the data, were you able to catch any gaps? If not, don't worry I got you.

INNER JOIN

When we perform a simple JOIN our result only includes rows that match our ON condition.

👉 Example: Find all employees who are assigned to a valid department.

SELECT e.name, e.salary, d.department_name, d.location
FROM employees e
INNER JOIN departments d
ON e.department_id = d.department_id;

Output:

name	salary	department_name	location
Alice	70000	HR	New York
Bob	55000	IT	San Francisco
Diana	62000	Marketing	Chicago
Ethan	72000	HR	New York
Farah	58000	Finance	Boston

Note: INNER is the default, so JOIN is equivalent to INNER JOIN.

LEFT JOIN

Returns all rows from the left table (employees), even if they don’t have a matching row from the right table (department).

If no match exists, the right-side columns return NULL.

👉 Example: List all employees, including those without departments.

SELECT e.name, e.salary, d.department_name
FROM employees e
LEFT JOIN departments d
ON e.department_id = d.department_id;

Output:

name	salary	department_name
Alice	70000	HR
Bob	55000	IT
Charlie	40000	NULL
Diana	62000	Marketing
Ethan	72000	HR
Farah	58000	Finance
George	45000	NULL

RIGHT JOIN

A RIGHT JOIN returns all rows from the right table(department), plus matching rows from the left(employees).

If no match exists, the left-side columns return NULL.

👉 Example: List all departments, including those without employees.

SELECT e.name, d.department_name
FROM employees e
RIGHT JOIN departments d
ON e.department_id = d.department_id;

Output:

name	department_name
Alice	HR
Ethan	HR
Bob	IT
Diana	Marketing
Farah	Finance
NULL	Operations

FULL OUTER JOIN

Returns all records when there is a match in left (employees) or right (departments) table records.

Use FULL OUTER JOIN when you want a complete picture of employees and departments, including mismatches on both sides.

👉 Example: Show a complete view of employees and departments, including unmatched rows on both sides.

SELECT e.name, d.department_name
FROM employees e
FULL OUTER JOIN departments d
ON e.department_id = d.department_id;

Output:

name	department_name
Alice	HR
Ethan	HR
Bob	IT
Diana	Marketing
Farah	Finance
Charlie	NULL
George	NULL
NULL	Operations

Note: FULL OUTER JOIN and FULL JOIN are equivalent.

CROSS JOIN

Returns the Cartesian product of both tables (every employee with every department).

It is rarely used in business queries, but useful for generating test data or combinations.

👉 List all employee-department combinations.

SELECT e.name, d.department_name
FROM employees e
CROSS JOIN departments d;

Notice that cross joins don’t require an ON statement. You’re not really joining on any columns!

UNION

Sometimes we just want to stack one dataset on top of the other. Well, the UNION operator allows us to do that.

The UNION operator automatically removes duplicate rows from the result set.

Syntax:

SELECT *
FROM table1
UNION
SELECT *
FROM table2;

SQL has strict rules for appending data:

Tables must have the same number of columns.
The columns must have the same data types in the same order as the first table.

Primary Key vs Foreign Key

Relational databases are built on the idea of relationships between tables. These relationships are created using primary keys and foreign keys.

Primary Key:

A Primary Key is a column (or set of columns) that uniquely identifies each row in a table.
No two rows can have the same primary key value.
It cannot contain NULL

In the Departments table above, department_id is the primary key because each department must have a unique ID.

Foreign Key:

A Foreign Key is a column in one table that refers to the primary key in another table.
It creates the relationship between two tables.

In the Employees table, department_id is a foreign key referencing the Departments table.

Without primary and foreign keys, JOINS wouldn’t know how to link tables together.

Using WITH in SQL

Sometimes we want to combine two tables, but one of those tables isn’t available directly, instead, it’s the result of another calculation.

For example, HR might want to know:

👉 What is the average salary per department, and which employees belong to those departments?

This requires two steps:

First, calculate the average salary for each department.
Then, join this result with the Employees table so we can see which employees belong to those departments.

Step 1: Calculate average salary per department

SELECT department_id,
       AVG(salary) AS avg_salary
FROM employees
GROUP BY department_id;

Output:

department_id	avg_salary
101	71000
102	55000
103	62000
104	58000
NULL	42500

Step 2: Use WITH to build a reusable result

Instead of nesting the above query directly, we wrap it with a CTE:

WITH dept_avg AS (
    SELECT department_id,
           AVG(salary) AS avg_salary
    FROM employees
    GROUP BY department_id
)
SELECT e.name, e.salary, d.department_name, dept_avg.avg_salary
FROM employees e
JOIN departments d
  ON e.department_id = d.department_id
JOIN dept_avg
  ON e.department_id = dept_avg.department_id;

Output:

name	salary	department_name	avg_salary
Alice	70000	HR	71000
Ethan	72000	HR	71000
Bob	55000	IT	55000
Diana	62000	Marketing	62000
Farah	58000	Finance	58000

At this point in our SQL journey we know we can query a
database to retrieve desired results. However, what happens when we query a database but we really only need a subset of the results returned?

Let's explore the use of something called a subquery that gives us the same functionality as a join, but with much more readability.

Subqueries

As the name suggests, a subquery is an internal query nested inside of an external query. They can be nested inside of SELECT, INSERT, UPDATE, or DELETE statements.

Anytime a subquery is present, it gets executed before the external statement is run.

Syntax:

SELECT column1, column2, ...
FROM table1
WHERE column operator (SELECT column FROM table2 WHERE condition);

column1, column2, ...: A list of column names you want to retrieve.
table1: The main table from which you want to select data.
column: The column you want to compare or filter against in the main query.
operator: An operator such as =, >, <, IN, NOT IN, etc.
table2: The table from which you want to retrieve data for comparison.
condition: The condition that specifies which records to select from the subquery.

When to use: When you need to filter, calculate, or aggregate before applying conditions in your main query.

👉 Example: Find employees earning more than the average salary.

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

In this statement, the subquery SELECT statement would be executed first, resulting in a list of average salaries of the employees.

Comparison Operators

Subqueries are often combined with operators for filtering.

= → Equal to
> → Greater than
< → Less than
>= → Greater than or equal to
<= → Less than or equal to
<> or != → Not equal to

In and Not In Clauses

The more common ways to use subqueries is with the use of an IN or NOT IN clause

When an IN clause is used, results retrieved from the external query must appear within the subquery results.

Similarly, when a NOT IN clause is used, results retrieved from the external query must not appear within the subquery results.

Example (IN): Employees in HR or IT

SELECT name
FROM employees
WHERE department_id IN (101, 102);

Result: Alice, Bob, Ethan

Example (NOT IN): Employees not in HR or IT

SELECT name
FROM employees
WHERE department_id NOT IN (101, 102);

Result: Charlie, Diana, Farah, George

Exists and Not Exists

The EXISTS and NOT EXISTS clauses are used in SQL to test whether a subquery returns any rows.

EXISTS → Returns TRUE if the subquery produces at least one row.

NOT EXISTS → Returns TRUE if the subquery produces no rows.

Unlike IN / NOT IN, which collect a list of values from the subquery and then compare them, EXISTS simply checks for the presence of rows.

Example: Show all employees who are assigned to a department.

SELECT *
FROM employees e
WHERE EXISTS (
    SELECT *
    FROM departments d
    WHERE d.department_id = e.department_id
);

The subquery checks if a department exists with the same department_id as the employee.
If it finds one, EXISTS is true and the employee is included.
If not, that employee is skipped.

Example: Show employees who are not assigned to any department.

SELECT *
FROM employees e
WHERE NOT EXISTS (
    SELECT *
    FROM departments d
    WHERE d.department_id = e.department_id
);

For each employee, the subquery checks the departments table.
If no department matches the employee’s department_id, then NOT EXISTS returns true, and that employee appears in the result.

Wrapping Up

Congratulations on taking another step in the SQL journey. 🙌

In the next part of the series, we’ll build on this foundation to tackle even more advanced SQL concepts.

Until then, here’s a friendly reminder that you’ve leveled up:

SQL for Data Professionals: From Basics to Advanced Analytics

DataLane — Mon, 01 Sep 2025 10:09:12 +0000

SQL (Structured Query Language) remains the backbone of data retrieval and manipulation in the world of relational databases.

Whether you’re a data analyst, data engineer, or business intelligence professional, learning SQL unlocks the ability to explore data, uncover insights, and build analytics pipelines with ease.

In this article, part of our SQL Learning Series, you’ll go from SQL basics to advanced SQL techniques using real-world examples.

What is a Relational Database Management System (RDBMS)?

A relational database management system (RDBMS) is a program that allows you to create, update, and administer a relational database.

Relational databases store data in tables(rows and columns).

Relationships between tables are established using keys:

Primary Key (PK): Uniquely identifies each row in a table.
Foreign Key (FK): Refers to the primary key in another table to maintain relationships.

What the heck is SQL?

SQL stands for Structured Query Language.

It’s declarative, meaning you tell the database what you want, and it figures out how to get it.

Three core categories of SQL commands:

DDL (Data Definition Language) → Create or modify database objects like tables(CREATE, ALTER).
DML (Data Manipulation Language) → Insert, update, or delete data.
DQL (Data Query Language) → Retrieve data with SELECT queries.

These form the foundation for both data exploration and advanced analytics tasks.

Writing Your First SQL Queries

Let’s look at some beginner-friendly SQL commands:

CREATE TABLE friends (
  id INTEGER,
  name TEXT,
  birthday DATE,
)
INSERT INTO friends (id, name, birthday) 
VALUES (1, 'Ororo Munroe', '1940-05-30');

SELECT * 
FROM friends;

UPDATE friends
SET name = 'Storm'
WHERE id = 1;

ALTER TABLE friends
ADD COLUMN email TEXT;

UPDATE friends
SET email = storm@codecademy.com
WHERE id = 1;

DELETE FROM friends
WHERE id = 1;

SELECT * 
FROM friends;

Ah, don't worry, I'm going to explain it all like you're five:

CREATE TABLE is a clause that tells SQL you want to create a new table.
friends is the name of the table.
(id INTEGER, name TEXT, birthday DATE) is a list of parameters defining each column, or attribute in the table and its data type.
The INSERT statement inserts a new row into a table:
- (id, name, age) is a parameter identifying the columns that data will be inserted into.
- VALUES is a clause that indicates the data being inserted.
SELECT statements are used to fetch data from a database.
- * is a special wildcard character that allows you to select every column in a table without having to name each one individually.
The ALTER TABLE statement is used to add or modify table columns.
- ADD COLUMN is a clause that lets you add a new column to a table.
The UPDATE statement edits a row in a table.
- You can use the UPDATE statement when you want to change existing records.
- WHERE is a clause that indicates which row(s) to update with the new column value.
The DELETE FROM statement deletes one or more rows from a table.
- WHERE is a clause that lets you select which rows you want to delete.

Pro tip: SQL commands are not case-sensitive. select = SELECT.

Adding Constraints for Data Integrity

Constraints define rules for your data.

Example: The statement below sets constraints on the awards table.

CREATE TABLE awards (
   id INTEGER PRIMARY KEY,
   recipient TEXT NOT NULL,
   award_name TEXT DEFAULT 'Grammy'
);

PRIMARY KEY → Uniquely identifies each record.
NOT NULL → Prevents empty values.
DEFAULT → Sets a fallback value if none is provided.

This ensures data stays accurate and consistent.

Database Indexes: Speeding Things Up

Indexes are a powerful tool used in the background of a database to speed up querying. Simply put, an index is a pointer to data in a table.

How are indexes created?

In a database, data is stored in rows which are organized into tables. Each row has a unique key which distinguishes it from all other rows and those keys are stored in an index for quick retrieval.

When a new row with a unique key is added, the index updates automatically.

However, sometimes we need to quickly look up data that isn’t stored as a key—for example, finding customers by telephone number. Using a unique constraint isn’t suitable in such cases because multiple rows can share the same value. Instead, custom indexes can be created.

Creating an index:

CREATE INDEX <index_name>
ON <table_name> (column1, column2, ...)

This allows faster access to frequently queried columns even if they are not unique keys.

QUERIES

One of the core purposes of the SQL language is to retrieve information stored in a database. This is commonly referred to as querying.

We'll be using SQL commands to query a table of restaurants called 'quench' and generate insights out of it.

Start by getting a feel for the quench table:

SELECT *
FROM quench;

Find Distinct Neighborhoods

SELECT DISTINCT neighborhood
FROM quench;

DISTINCT removes duplicates, so each neighborhood appears only once.

Let’s say you’re craving Chinese food. To see all restaurants serving Chinese cuisine:

SELECT *
FROM quench
WHERE cuisine = 'Chinese';

The WHERE clause filters rows based on a condition.

Filter by Review Score

Want restaurants rated 4 or higher?

SELECT *
FROM quench
WHERE review >= 4;

Conditions can use comparison operators like =, >=, <, or <> (not equal).

If you want to find Italian restaurants with exactly three dollar signs:

SELECT *
FROM quench
WHERE cuisine = 'Italian'
   AND price = '$$$';

Both conditions must be true for rows to be included.

Search by Partial Name

Let's say you can’t remember the exact name of a restaurant you went to earlier but knows it contains the word ‘meatball’ in it.

How will you find it?

SELECT *
FROM quench
WHERE name LIKE '%meatball%';

LIKE is a special operator used with the WHERE clause to search for a specific pattern in a column.

%is a wildcard character that matches zero or more missing characters in the pattern.

Filter by Multiple Locations

Find all the close by spots in Midtown, Downtown or Chinatown.

SELECT name, cuisine, neighborhood
FROM quench
WHERE neighborhood = 'Midtown'
   OR neighborhood = 'Downtown'
   OR neighborhood = 'Chinatown';

Note: Operators like OR/AND can be used more than once.

We selected only name, cuisine, and neighborhood for a concise result set.

Find Missing Health Grades.

SELECT *
FROM quench
WHERE health IS NULL;

Note: IS NULL checks for empty or missing values.

Top 10 Restaurants by Reviews

SELECT *
FROM quench
ORDER BY review DESC
LIMIT 10;

ORDER BY sorts results.
DESC = descending order (highest first).
LIMIT restricts the number of rows returned.

Woah! That was a lot to digest—literally. Now I’m craving some actual food!

Aggregate Functions

When working with databases, you often need more than just raw data ;you need insights. That’s where SQL aggregate functions come in.

They allow you to perform calculations across multiple rows and return a single, meaningful result.

Some of the most commonly used aggregate functions include:

COUNT() : count the number of rows
SUM(): the sum of the values in a column
MAX()/ MIN(): the largest/smallest value
AVG(): the average of the values in a column
ROUND(): round the values in the column

In addition, you can use GROUP BY, ORDER BY, and HAVING clauses to organize and filter aggregated data effectively.

Example:

Imagine you own a chain of lemonade stands across different neighborhoods.

Every day, each stand sells some cups of lemonade. At the end of the month, you want answers to questions like:

How much lemonade did we sell each day?
Which days were really good (sold more than 100 cups)?
Which days made the most sales so we can study what went right?

In SQL terms:

Each stand’s daily sales = rows in our table
Total cups sold per day = aggregate function (SUM)
Filtering good days only = HAVING
Sorting best days on top = ORDER BY

Step 1: Group the Sales Per Day (GROUP BY)

First, let’s sum up cups sold per day:

SELECT date, SUM(cups_sold) AS total_cups
FROM sales
GROUP BY date;

Here’s what happens:

GROUP BY date → Puts all sales on the same day together
SUM(cups_sold) → Adds them up for each day

Step 2: Keep Only Good Days (HAVING)

Now we only want days with at least 100 cups sold:

SELECT 
    date,
    SUM(cups_sold) AS total_cups
FROM sales
GROUP BY date
HAVING SUM(cups_sold) >= 100;

HAVING is like a filter for groups.

WHERE filters rows before grouping, but HAVING filters after aggregates are calculated.

Step 3: Sort the Best Days (ORDER BY)

Finally, let’s sort days by total cups sold so the best days come first:

SELECT 
    date,
    SUM(cups_sold) AS total_cups
FROM sales
GROUP BY date
HAVING SUM(cups_sold) >= 100
ORDER BY total_cups DESC;

Wrapping Up

In this post, we started with simple queries to explore data, then moved on to aggregate functions and powerful clauses like GROUP BY, HAVING, and ORDER BY to summarize, filter, and sort results effectively.

Mastering these tools gives you the ability to:
Spot trends quickly
Summarize large datasets in seconds
Filter and organize information with precision

The next time you open a database, you’ll know exactly how to turn tables of numbers into actionable knowledge.

Building a Data Career: The Skills That Truly Matter

DataLane — Thu, 14 Aug 2025 06:17:20 +0000

The need for people to understand, prioritize, manage, and analyze data is not slowing down in any industry. From quick trend analyses to advanced predictive modeling, businesses rely on data to guide strategic decisions and uncover opportunities.

Data scientists and data analysts are on the front lines of this movement—gathering, cleaning, and interpreting information, then translating it into actionable insights for stakeholders.

In short:

What they do: Identify trends, patterns, and insights.

How they do it: Apply statistical methods, advanced modeling, and clear communication.

Let’s explore the skills that actually make a difference.

Ideal Qualities for Data Analytics Professionals

Succeeding in a data career takes more than technical skills. The best data professionals combine analytical thinking with strong communication, attention to context, and a mindset focused on impact.

Below are five essential qualities every data professional should develop:

1. Problem Solving

Solving problems is at the heart of any data role. Whether you're handling incomplete data, fixing analysis issues, or communicating insights effectively—always aim to quantify the impact of the problems you solve.

Example: At a food delivery startup, customer cancellations spiked suddenly. A data analyst explored the pattern and found the majority were happening during lunchtime in one city. By correlating with weather data, they discovered rain-related delays were causing the issue. The company added a "weather delay warning" in the app, which led to a 15% drop in cancellations during peak hours.

Pro Tip: Tie your analysis to action. Always ask, “What decision will this insight improve?”

2. Clear Communication

Professionals in data, business, and technology are expected to be fluent communicators.

Insights are only valuable if they can be understood. Whether it’s writing a report, presenting findings, or building a dashboard, good communication bridges the gap between data and decision-makers.

Example: After analyzing customer feedback, a data professional presented the key reasons for complaints to the product team using a visual dashboard. As a result, they focused on fixing the top three issues and reduced support tickets by 40%.

Pro Tip: Never assume people “get it.” Make insights visual, actionable, and context-rich.

3. Curiosity and a Willingness to Learn

The best data professionals don’t just take questions at face value, they ask “why” and dig deeper. They constantly seek to learn new tools, methods, and context as the field evolves.

Example: A junior data analyst at a fashion brand noticed a popular product had unexpectedly low sales in a few regions. Rather than just flagging it, they looked into regional website behavior and discovered that the product images weren’t loading correctly due to a CDN issue. Fixing the error led to a 20% increase in regional conversions.

Pro Tip: Don't just be a responder, be an investigator.

4. Understanding of the Business Context

Knowing what matters to your organization helps prioritize your work and make insights more useful. See beyond the data and understand how it connects to real-world decisions.

Example: A retail analyst who understood inventory costs recommended promoting slow-moving products based on data. This not only cleared out storage space but also increased monthly revenue.

Pro Tip: Learn your org’s KPIs—and align your insights to them.

5. Adaptability

Projects change. Data is messy. Stakeholder questions evolve. Flexibility and comfort with uncertainty are key traits for success.

Example: A financial analyst was tasked with forecasting next quarter's revenue. Midway through, the company announced a merger. Instead of restarting from scratch, they pivoted their model to include historical performance of similar mergers in the industry delivering a revised forecast on time, which helped shape early integration planning.

Pro Tip: See change not as a setback, but a signal to innovate.

Ethics, Privacy, and Bias: Core Responsibilities

Data ethics refers to well-founded standards of right and wrong that dictate how data is collected, shared, and used.

Personally Identifiable Information (PII)

Any data gathered from individuals or consumers is referred to as PII—information that can identify someone either directly or indirectly. This includes:

Telephone numbers
Names
Social security numbers
IP addresses
Medical records
Email addresses
Account numbers

Because PII is often linked to medical, financial, or employment data, it must be managed with great care.

Privacy Matters

Data privacy focuses on the access, use, and collection of personal data. Key strategies to ensure privacy include:

Access controls: Ensuring only authorized personnel access sensitive data
Data anonymization: Masking, hashing, or replacing personal information using fixed-length codes or altered values

Imagine a world where we all had access to each other’s personal data. That would compromise privacy and safety. Data anonymization helps protect individuals and preserve trust.

Avoid Creating or Reinforcing Bias

Bias in data is often unintentional but can lead to harmful outcomes. Keep in mind:

Data is gathered by humans and is affected by their backgrounds, beliefs, and experiences
Datasets may not represent the full population
Insights must be questioned before decisions are made

Being aware of bias is key to building inclusive, accurate, and ethical data solutions.

Know the Industry Standards

Each industry has its own standards for data handling and analysis:

Transportation: Focus on real-time data and route optimization
Healthcare: Prioritize accuracy, privacy, and patient outcomes
Finance: Emphasize security, compliance, and risk mitigation

Understanding these nuances ensures your insights are practical and impactful.

Current and Future Tools

A well-rounded data career is built on both foundational and emerging tools. Here’s a landscape snapshot:

Whether it’s SQL for querying, Python for modeling, or Tableau for storytelling- tools evolve, but your ability to learn remains your greatest asset.

How AI Fits Into a Data Career

AI is becoming a powerful asset in the data professional’s toolkit, enhancing efficiency, insight generation, and automation.

In Finance

Analyze transactions to detect fraud
Identify investment risks and opportunities
Generate market insights and recommendations

In Retail

Recommend products based on purchase history
Personalize the shopping experience
Forecast demand to optimize inventory and reduce costs

AI's Limitations

AI is a tool; not a replacement for human judgment. Here’s why:

Lacks context: AI makes decisions based on patterns in data; humans bring intuition and domain experience
Struggles with ambiguity: AI excels with well-defined problems, not complex, open-ended ones
Can't communicate nuance: AI can generate reports, but humans explain, persuade, and adapt communication to the audience
Not creative: Humans can imagine novel solutions and ask better questions, AI cannot

Always verify AI output and use it as an assistant, not a decision-maker.

Showcasing Your Work: Build a Public Portfolio

Great work speaks for itself, but only if people can see it. A strong portfolio proves your skills and builds credibility.

1. Tableau Dashboards

Create interactive dashboards and share your work visually.

2. Kaggle Notebooks

For technical deep-dives or competitions, Kaggle is a great place to share and grow.

3. GitHub Repositories

Use GitHub to publish your code, collaborate, and track your work over time.

4. Blogs

Blog posts demonstrate not just technical know-how, but communication, storytelling, and critical thinking.

A strong blog shows you're not only a good analyst, but a clear thinker and communicator.

Final Thoughts:

Creating great work is important. But sharing it is what builds visibility and opportunity.
Whether through dashboards, notebooks, GitHub, or writing, your portfolio is your professional proof.

Your next opportunity might just come from someone stumbling across your dashboard, notebook, or blog post.