Building a Job Market Insights Dashboard Using Bright Data’s Glassdoor Dataset

Understanding the current job market trends helps you make informed decisions, especially in this AI era where hiring trends shift fast. Companies and individuals who still rely on outdated data or gut feeling when making career or hiring decisions risk falling behind.

A job role in high demand today might become oversaturated next quarter. Salaries fluctuate based on location, industry, and skill demand, and without real-time insights, individuals and businesses will struggle to stay competitive.

What will you learn in this tutorial?

In this tutorial, we’ll walk through how to build a Job Market Insights Dashboard using Bright Data’s Glassdoor dataset. You’ll learn how to:

✅Access and process the dataset for job market analytics

✅Filter and visualize job trends by salary, title, and industry

✅Build an interactive dashboard that updates in real-time

By the end of this guide, you’ll have a fully functional job insights dashboard that will be valuable to you or your business.

The Problem with Traditional Job Market Analysis

To do this, I needed access to cleaned and up-to-date job market data. However, traditional job market research methods-–scraping job postings manually, relying on third-party reports, or conducting surveys — have some limitations:

❌ Data is often outdated by the time it’s published.

❌ Scraping job listings is unreliable, leading to blocked IPs and missing information

❌ Surveys and reports lack granularity, making it hard to analyze trends by role, location, or salary.

The solution I went for is to make use of Bright Data’s datasets, mainly because they provided access to real-time, structured, ready-to-use data from various websites without the hassle of maintenance or risks of getting blocked.

Buy Datasets - Marketplace & Custom Datasets

For this project, I used their Glassdoor dataset to build a job market insights dashboard.

Why Bright Data’s Glassdoor Dataset?

The reason is simple: It’s fast, scalable, and reliable.

I didn’t want to spend hours writing scripts to scrape job listings only to run into issues like IP bans, CAPTCHAs, or missing data. More importantly, Bright Data’s Glassdoor dataset provides 76.8 million+ job records, which is far more than I could ever collect manually.

With this dataset, I could skip the data collection process and go straight to analyzing job market trends.

What’s Inside the Dataset?

The dataset includes key fields that allow for deep job market analysis:

Job Listings & Salaries

• job_title — Identify trending job roles and compare demand across industries.
• job_location — Analyze job availability across different regions.
• pay_range_glassdoor_est & pay_median_glassdoor — Understand salary expectations by role and location.

Company Insights

• company_name, company_url_overview — Research hiring trends at specific companies.
• company_rating — Compare employer reputation and work culture.
• company_career_opportunities_rating, company_work/life_balance_rating — Evaluate job satisfaction factors.

Employee Sentiment & Reviews

• percentage_that_recommend_company_to_a_friend — See how employees perceive their companies.
• percentage_that_approve_of_ceo — Measure leadership approval ratings
• reviews_by_same_job_pros & reviews_by_same_job_cons — Gain insights into job-specific pros and cons.

Company Growth & Stability

• company_founded_year — Determine if companies are startups or established players.
• company_revenue, company_size — Assess company financial stability and workforce size.
• company_sector, company_industry — Group companies into industry-based market trends.

Hiring & Application Trends

• job_application_link — Track real-time job openings
• company_website — Validate employer details for job seekers and recruiters.

How to obtain the Glassdoor datasets

• Create a Bright Data account to access their dataset marketplace from the dashboard.
• 
• Search for Glassdoor job listings information and click on it.

• Click on “Proceed to purchase” to purchase and download your data. You can download it in CSV and JSON formats. You can also filter based on the type of data you want (e.g., Companies with a rating greater than 4, listings for software engineers).

In the next section, I’ll cover how I used this data to build a Job Market Insights Dashboard that provides real-time insights into salary trends, hiring demand, and workplace culture. 🚀

How to Build a Job Market Insights Dashboard (Step-by-Step)

This section walks you through building a Job Market Insights Dashboard using Streamlit, Pandas, Plotly, and Bright Data’s Glassdoor dataset.

Step 1: Setting up the environment

Before writing any code, set up your development environment by installing the required libraries.

1.1: Setting up the project:

In your terminal, run this command to create a new project directory:

mkdir job-market-insights && cd job-market-insights

1.2: Set up a virtual environment:

python -m venv venv

Activate the environment:

• Windows:

venv\Scripts\activate

• macOS/Linux:

source venv/bin/activate

1.3: Install dependencies

Run the command below to install the following packages:

pip install streamlit pandas plotly numpy wordcloud matplotlib

1.4: Define the project structure:

job-market-insights/
│── Glassdoor_job_listings_information.csv
│── app.py

Step 2: Load and process the Glassdoor dataset

The dataset is stored in a CSV file (Glassdoor_job_listings_information.csv). The load_data() function:

• Loads the dataset into a Pandas DataFrame
• Checks for missing columns and fills them with default values
• Extracts skills from job descriptions

import pandas as pd
import random
import datetime

def load_data():
    try:
        df = pd.read_csv('Glassdoor_job_listings_information.csv')

        # Ensure key columns exist
        required_columns = ['company_industry', 'pay_median_glassdoor', 'job_location']
        for col in required_columns:
            if col not in df.columns:
                df[col] = "Not Specified"

        # Generate random posting dates (last 365 days)
        end_date = datetime.datetime.now()
        start_date = end_date - datetime.timedelta(days=365)
        df['post_date'] = [start_date + datetime.timedelta(days=random.randint(0, 365)) for _ in range(len(df))]

        return df

    except Exception as e:
        print(f"Error loading data: {e}")
        return pd.DataFrame()

Step 3: Create the Streamlit dashboard

In your Python script (app.py), configure the Streamlit page layout:

import streamlit as st

st.set_page_config(
    page_title="Job Market Insights Dashboard",
    page_icon="📊",
    layout="wide"
)

st.markdown('<h1 style="text-align: center;">Job Market Insights Dashboard</h1>', unsafe_allow_html=True)
st.markdown('<h3 style="text-align: center; color: #4682B4;">Powered by Bright Data\'s Glassdoor Dataset</h3>', unsafe_allow_html=True)
st.write("Analyze job posting trends, salaries, and skills in demand across various industries.")
st.divider()

Step 4: Add sidebar filters for data exploration

To allow users to filter jobs by industry, title, location, company size, and salary range, use Streamlit’s sidebar widgets:

st.sidebar.header("Filters")

# Dropdown filters
selected_industry = st.sidebar.selectbox("Select Industry", ["All"] + df["company_industry"].unique().tolist())
selected_job_title = st.sidebar.selectbox("Select Job Title", ["All"] + df["job_title"].unique().tolist())
selected_location = st.sidebar.selectbox("Select Location", ["All"] + df["job_location"].unique().tolist())

# Salary filter
min_salary = int(df["pay_median_glassdoor"].min())
max_salary = int(df["pay_median_glassdoor"].max())
salary_range = st.sidebar.slider("Salary Range ($)", min_salary, max_salary, (min_salary, max_salary))

# Apply filters
filtered_df = df.copy()
if selected_industry != "All":
    filtered_df = filtered_df[filtered_df["company_industry"] == selected_industry]
if selected_job_title != "All":
    filtered_df = filtered_df[filtered_df["job_title"] == selected_job_title]
if selected_location != "All":
    filtered_df = filtered_df[filtered_df["job_location"] == selected_location]
filtered_df = filtered_df[(filtered_df["pay_median_glassdoor"] >= salary_range[0]) & (filtered_df["pay_median_glassdoor"] <= salary_range[1])]

Step 5: Display key metrics

To provide quick insights into the dataset, display key statistics using Streamlit’s st.metric() function:

col1, col2, col3 = st.columns(3)

with col1:
    st.metric("Total Job Postings", len(filtered_df))
with col2:
    st.metric("Average Salary", f"${int(filtered_df['pay_median_glassdoor'].mean()):,}")
with col3:
    st.metric("Most Common Job", filtered_df["job_title"].mode()[0] if not filtered_df.empty else "N/A")

Step 6: Visualizing job market trends

6.1: Salary distribution by job title

Use Plotly to generate bar charts for average salary per job title:

import plotly.express as px

if not filtered_df.empty:
    salary_chart = px.bar(
        filtered_df.groupby("job_title")["pay_median_glassdoor"].mean().reset_index(),
        x="job_title", y="pay_median_glassdoor",
        title="Average Salary by Job Title",
        labels={"job_title": "Job Title", "pay_median_glassdoor": "Average Salary ($)"},
        color="pay_median_glassdoor",
        color_continuous_scale="Blues"
    )
    st.plotly_chart(salary_chart, use_container_width=True)

6.2: Job postings over time

Use a line chart to show job posting trends over time:

filtered_df['month_year'] = pd.to_datetime(filtered_df['post_date']).dt.strftime('%Y-%m')
postings_by_time = filtered_df.groupby('month_year').size().reset_index(name='count')

fig = px.line(
    postings_by_time,
    x="month_year",
    y="count",
    title="Job Postings Over Time",
    labels={"month_year": "Month", "count": "Number of Job Postings"},
    markers=True,
)
st.plotly_chart(fig, use_container_width=True)

6.3: Most in-demand skills (Word Cloud)

Use WordCloud to visualize the most in-demand technical and soft skills extracted from job descriptions:

from wordcloud import WordCloud
import matplotlib.pyplot as plt

all_skills = ",".join(filtered_df["required_skills"].dropna())
wordcloud = WordCloud(width=800, height=400, background_color="white").generate(all_skills)

fig, ax = plt.subplots(figsize=(10, 5))
ax.imshow(wordcloud, interpolation="bilinear")
ax.axis("off")
st.pyplot(fig)

6.4 Top hiring companies

Use a bar chart to show the top companies hiring the most:

top_companies = filtered_df["company_name"].value_counts().reset_index().head(10)
top_companies.columns = ["company_name", "count"]

fig = px.bar(
    top_companies,
    x="company_name",
    y="count",
    title="Top Companies by Job Postings",
    labels={"company_name": "Company", "count": "Number of Job Postings"},
    color="count",
    color_continuous_scale="Viridis"
)
fig.update_layout(xaxis_tickangle=-45)
st.plotly_chart(fig, use_container_width=True)

Step 7: Display job listings table

Finally, display the filtered job listings in a table:

st.dataframe(filtered_df[["company_name", "job_title", "job_location", "pay_median_glassdoor"]].rename(
    columns={"company_name": "Company", "job_title": "Job Title", "job_location": "Location", "pay_median_glassdoor": "Salary ($)"}),
    hide_index=True,
    use_container_width=True
)

Step 8: Run the dashboard

Run the Streamlit app:

streamlit run app.py

Your Job Market Insights Dashboard is now live! 🎉

You can find the complete code for this tutorial on my GitHub.

Conclusion

Building a Job Market Insights Dashboard using Bright Data’s Glassdoor dataset has shown how powerful real-time data analytics can be for hiring trends, salary analysis, and skill demand.

Instead of relying on outdated reports, unreliable scraping, or guesswork, this approach provides a scalable and automated way to make informed hiring and career decisions.