Coder Legion - Recent posts tagged analyst

Titanic Survival Analysis — What the Data Reveals About Who Lived and Who Died

Thu, 11 Jun 2026 10:01:09 +0000

The Titanic disaster of 1912 is one of the most studied events in history. Over 1,500 people lost their lives when the ship sank in the North Atlantic. But when you look at the passenger data, a clear pattern emerges — survival was not random. Your chances of surviving depended heavily on who you were and where you sat on the ship.

In this project, I analyzed the Titanic passenger dataset to answer one central question: What factors determined whether a passenger survived?

This is my second data analysis project. My first project was an HR Employee Attrition Analysis — if you haven't read that one yet, check it out. For this project, I followed the same structured 5-phase approach and pushed myself to go deeper with the visualizations.

Full notebook on GitHub: github.com/sandipsubedi0/titanic-survival-analysis

Dataset Overview
Source: Kaggle — Titanic: Machine Learning from Disaster

Rows: 891 passengers

Columns: 12 features including Age, Sex, Pclass, Fare, Cabin, Embarked, and Survived

Tools used: Python, Pandas, NumPy, Matplotlib, Seaborn

Phase 1 — Setup and Data Loading
I started by importing the necessary libraries and loading the dataset using a relative file path. A simple but important habit — never use a hardcoded local path like C:\Users... in a shared notebook, because it will break on every other computer.

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
%matplotlib inline
sns.set_style("whitegrid")

data = pd.read_csv("Titanic-Dataset.csv")
data.head()

First look at the data: 891 rows, 12 columns. The dataset includes passenger demographics, ticket details, cabin information, and whether they survived.

Phase 2 — Data Exploration (Before Cleaning)
Before touching anything, I explored the raw data to understand what I was working with.

Missing values:

Column Missing Count Missing %
Cabin 687 77.1%
Age 177 19.9%
Embarked 2 0.2%
The missing values heatmap made this visually clear — Cabin had a massive gap running through the entire column.

I also ran data.describe() to check the numerical columns. A few things stood out immediately:

Age ranged from 0.42 to 80 years — the youngest passenger was less than 1 year old

Fare had a huge range — minimum 0, maximum 512 — signaling strong economic inequality among passengers

Only 38% of passengers survived (Survived mean = 0.38)

For value_counts(), I only checked meaningful categorical columns: Survived, Pclass, Sex, and Embarked. Columns like PassengerId, Name, and Ticket are unique identifiers — running analysis on them produces no useful insight.

Phase 3 — Data Cleaning
I made a working copy of the original data before applying any changes — always keep the raw data intact as a reference.

df = data.copy()

Three cleaning decisions:

Age — filled with median Age had 177 missing values (19.9%). I filled with the median, not the mean. Why? Age has outliers (very young children, elderly passengers) that pull the mean away from the typical passenger. The median is more robust.

df["Age"].fillna(df["Age"].median(), inplace=True)

Cabin — dropped entirely 77.1% of values were missing. That's too high to fill reliably — any filling method would be guesswork on that scale. Dropping it was the right call.

df.drop(columns=["Cabin"], inplace=True)

Embarked — filled with mode Only 2 values missing. With such a small gap, filling with the most common value (mode) is perfectly safe.

df["Embarked"].fillna(df["Embarked"].mode()[0], inplace=True)

Verification: After cleaning, df.isnull().sum() showed zero missing values across all columns. The after-cleaning heatmap confirmed this — completely blank, exactly what we want to see.

Phase 4 — Exploratory Data Analysis and Visualizations
This is where the real story begins. I built 7 charts, each designed to answer a specific question.

Chart 1 — Overall Survival Count

The first question: how many people actually survived?

Out of 891 passengers, 342 survived (38.4%) and 549 did not (61.6%). More than 6 in 10 people on the Titanic did not make it. That sets the baseline for everything that follows.

Chart 2 — Survival Rate by Gender
This is where the data gets striking.

Female survival rate: ~74%

Male survival rate: ~19%

Women were nearly 4x more likely to survive than men. This is the clearest pattern in the entire dataset. The "women and children first" evacuation protocol was not just a phrase — the data confirms it was actually followed.

I used a bar chart here (not a pie chart). Survival rates are separate values for two groups — they don't add to 100% of anything, so a pie chart would be misleading.

Chart 3 — Survival Rate by Passenger Class

Passenger class tells us where on the ship you were located — and how close you were to the lifeboats.

1st Class: ~63% survival rate

2nd Class: ~47% survival rate

3rd Class: ~24% survival rate

The survival gap between 1st and 3rd class is enormous. Third-class passengers were housed in the lower decks — further from the lifeboats and with less time to reach the top deck. Economic status directly influenced survival chances.

Chart 4 — Age Distribution of All Passengers

A histogram of all passenger ages shows a right-skewed distribution. Most passengers were between 20 and 40 years old. There were relatively few children and elderly passengers compared to working-age adults.

The youngest passenger recorded was under 1 year old. The oldest was 80.

Chart 5 — Age by Survival (Overlapping Histogram)
This is one of the most informative charts in the project. By plotting two histograms on the same axes — one for survivors, one for non-survivors — with alpha=0.6 on both so they're visible through each other, the overlap pattern becomes clear.

plt.hist(df[df["Survived"]==1]["Age"], alpha=0.6, label="Survived", bins=20)
plt.hist(df[df["Survived"]==0]["Age"], alpha=0.6, label="Did not survive", bins=20)
plt.legend()

Young children (under ~10) show a higher proportion of survivors relative to non-survivors — consistent with "children first." For adults aged 20–40, non-survivors heavily outnumber survivors, reflecting the large number of 3rd-class male passengers in that age group.

Chart 6 — Fare Distribution

The fare histogram reveals extreme economic inequality on board. The distribution is heavily right-skewed — the vast majority of passengers paid low fares (under £50), while a small number paid extremely high amounts (up to 512).

This roughly maps to passenger class: 3rd-class passengers paid low fares, 1st-class passengers paid high fares. And as we saw in Chart 3, class directly correlated with survival.

Chart 7 — Gender × Class Survival Heatmap

This is the most powerful chart in the project. Instead of looking at gender and class separately, I combined them into a single heatmap using a pivot table.

pivot = df.pivot_table(values="Survived", index="Sex", columns="Pclass", aggfunc="mean")
sns.heatmap(pivot, annot=True, fmt=".2f", cmap="Blues")

The results:

1st Class 2nd Class 3rd Class
Female ~0.97 ~0.92 ~0.50
Male ~0.37 ~0.16 ~0.14
1st-class females had a ~97% survival rate. They were almost certain to survive. 3rd-class males had a ~14% survival rate. They had almost no chance.

The difference between those two groups is 83 percentage points — from the same disaster, on the same ship, at the same time.

Phase 5 — Key Findings and Conclusion
Key Findings
Only 38% of passengers survived — the majority of people on board did not make it.

Gender was the strongest single factor — female passengers survived at ~74% vs ~19% for males, confirming the "women and children first" evacuation protocol was followed.

Passenger class determined access to lifeboats — 1st class survived at ~63%, 3rd class at only ~24%. Where you sat on the ship directly affected your survival.

The combined effect was extreme — 1st-class females had a ~97% survival rate while 3rd-class males had only ~14%. The gap between best and worst case is 83 percentage points.

Children showed higher survival rates — the overlapping age histogram showed young children were more likely to survive relative to adults.

Fare inequality mirrored class inequality — most passengers paid very little, a few paid enormous amounts, and higher fare strongly correlated with higher survival.

Conclusion
The Titanic data tells a clear story: survival was not random. Gender and passenger class were the two dominant factors, and when combined, they produced an extreme range of outcomes. A 1st-class female passenger had near-certain survival. A 3rd-class male passenger had almost no chance.

The "women and children first" protocol was real — the data proves it. But access to the upper decks, proximity to lifeboats, and crew assistance were all filtered through socioeconomic status. Wealthier passengers had structural advantages that translated directly into survival.

This project taught me how to move from raw data to real insight — not just running code, but understanding what the numbers actually mean about human lives.

What's Next
This is Project 2 of my data analyst portfolio. I'm continuing to build projects that cover real-world datasets and develop my skills in Python, Pandas, and visualization.

Connect with me:

GitHub: github.com/sandipsubedi0

LinkedIn: linkedin.com/in/sandip-subedi-5694b136a

Instagram: @sandipsubedi0

Thanks for reading. If you found this useful, share it with someone learning data analysis.

How to Publish and Share a Power BI Report Online

Thu, 14 May 2026 10:11:40 +0000

As we continue to explore Data Science and Analytics, this weeks deliverable was to work on an electronics sales dashboard in PowerBI and publish it online. This is a common request in data analytics so in this article we will walk through the full process of publishing a Power BI report to the web, from clicking "Publish" in Desktop to getting a shareable link that anyone can open in a browser.

The Project in Brief

Before jumping into publishing, here is a quick overview of what the report contains so you have context for the screenshots:

Dataset: 100 electronics retail transactions across 10 products, 9 cities (USA and Canada), and 3 sales representatives.

Data preparation: The raw Excel data was loaded into Power Query where it was cleaned, validated, and normalized. Canadian Dollar transactions were converted to USD at a rate of 0.74. A star schema was built with six dimension tables (Products, Customers, Cities, SalesReps, PaymentMethod, DateTable) linked to a central fact table.

DAX measures: Total Revenue, Total Profit, Total Orders, Average Profit Margin, Average Shipping Cost, and a calculated Date Table using the CALENDAR() function.

Dashboard pages:

Page 1 - Executive Dashboard: KPI cards, sales by product, revenue by category, sales rep distribution, payment method breakdown, and interactive slicers.

Page 2 - Product Analysis: Revenue and profit comparison by product, geographic maps, profit margin rankings.

Page 3 - Sales Reps and Customers: Customer rankings, sales rep performance combo chart, customer age distribution.

With the report complete in Power BI Desktop, the next step is getting it online.

Step 1: Publish from Power BI Desktop

Open your .pbix file in Power BI Desktop. In the top ribbon, go to Home and click the Publish button on the right side of the toolbar.

If you are not signed in, Power BI will prompt you to sign in with your Microsoft account. Use the account associated with your Power BI Service subscription.

Once signed in, a dialog box appears asking you to select a destination workspace.

You will see a list of available workspaces. If you have not created any custom workspaces, you will only see My workspace, which is the default personal workspace that comes with every Power BI account.

Select the workspace you want and click Select.

Power BI Desktop will upload the report. This usually takes a few seconds depending on the file size. When it finishes, you get a success confirmation.

Click the "Open in Power BI" link to jump directly to your report in the browser, or click Got it to stay in Desktop.

Step 2: Verify in Power BI Service

Head over to app.powerbi.com and navigate to the workspace where you published. You should see your report listed there.

Open the report and spend a few minutes checking everything:

Do all visuals render correctly?
Do the slicers filter across all charts as expected?
Do navigation buttons (if you added any) work?
Are the KPI numbers matching what you see in Desktop?

In the screenshot above, you can see the report is live in the Power BI Service. The left sidebar shows the Pages panel listing all four pages (Dashboard, Products, Sales Reps and Custom...). The report is fully interactive - slicers, tooltips, and filtering all work just like they do in Desktop.

Notice the toolbar at the top: File, Export, Share, Explore, Set alert, Monitor, and Edit. These are the options available to you as the report owner. The ones we care about for sharing are File, Export, and Share.

This is where it gets interesting, and also where you might run into some friction depending on your account type. There are several ways to share a Power BI report, each with different access requirements.

Publish to Web (Public Embed)

This is the simplest option for making your report accessible to anyone without requiring them to have a Power BI account.

Path: File > Embed report > Publish to web (public)

This generates two things:

A direct URL that opens the report in any browser
An iframe embed code that you can paste into a website, blog, or portfolio page

The direct link looks something like:

https://app.powerbi.com/view?r=eyJrIjoi...

The iframe code looks like:

<iframe
  title="Electronics Sales Dashboard"
  width="1140"
  height="541.25"
  src="https://app.powerbi.com/view?r=eyJrIjoi..."
  frameborder="0"
  allowFullScreen="true">
</iframe>

Anyone with the link can view and interact with the report. No sign-in required.

Step 4: Embed on a Website (If Publish to Web Worked)

If you got the embed code from "Publish to web", you can host your report on any website. Here are two common approaches:

Simple HTML Page

Create an index.html file:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Electronics Sales Dashboard</title>
    <style>
        body {
            margin: 0;
            font-family: Arial, sans-serif;
            background: #f5f5f5;
        }
        .header {
            background: #1B2A4A;
            color: white;
            padding: 20px 40px;
        }
        .header h1 {
            margin: 0;
            font-size: 24px;
        }
        .header p {
            margin: 8px 0 0;
            font-size: 14px;
            color: #B5D4F4;
        }
        .container {
            max-width: 1200px;
            margin: 24px auto;
            padding: 0 20px;
        }
        iframe {
            width: 100%;
            height: 600px;
            border: none;
            border-radius: 8px;
        }
    </style>
</head>
<body>
    <div class="header">
        <h1>Electronics Sales Dashboard</h1>
        <p>Power BI Report -- January 2026</p>
    </div>
    <div class="container">
        <iframe
          title="Electronics Sales Dashboard"
          src="YOUR_EMBED_URL_HERE"
          allowFullScreen="true">
        </iframe>
    </div>
</body>
</html>

Replace YOUR_EMBED_URL_HERE with the actual embed URL from Power BI.

Host on GitHub Pages

If your project is already in a GitHub repo, you can host the embed page for free using GitHub Pages:

Create a subfolder in your repo (e.g., electronics-sales/).
Put the index.html file inside it.
Push to GitHub.
Go to Settings > Pages in your repo.
Set the source to deploy from your main branch.
After a minute or two, your page will be live at https://yourusername.github.io/repo-name/electronics-sales/.

If your repo contains multiple projects, each subfolder with its own index.html becomes a separate page under the same base URL. You only need to enable GitHub Pages once per repo.

Summary

The publishing workflow in Power BI goes like this:

Build the report in Power BI Desktop.
Publish to a workspace in the Power BI Service.
Verify that everything works in the browser.
Share using one of the available methods (Publish to web, direct share, or export).
Embed on a website or GitHub Pages if you want a standalone hosted version.

I hope you enjoyed this guide. If you would like to learn more about the PowerBI project, the insights gained and the original data used, check out my GitHub repo that contains the project: Electronics Sale Dashboard