Biggest Misconceptions About Working as a Data Analyst

-- A real analyst query: "Why did signups drop last week?"
-- Not a dashboard query. A diagnostic query, which is most of the job.

WITH
-- 1. Weekly signups by channel, last 8 weeks
weekly_signups AS (
  SELECT
    DATE_TRUNC(signup_date, WEEK(MONDAY)) AS week,
    channel,
    COUNT(*) AS signups
  FROM users
  WHERE signup_date >= DATE_SUB(CURRENT_DATE(), INTERVAL 8 WEEK)
  GROUP BY 1, 2
),

-- 2. Compare last week to the rolling average of the previous 4 weeks
comparison AS (
  SELECT
    week,
    channel,
    signups,
    AVG(signups) OVER (
      PARTITION BY channel
      ORDER BY week
      ROWS BETWEEN 4 PRECEDING AND 1 PRECEDING
    ) AS prev_4wk_avg
  FROM weekly_signups
)

-- 3. Show the drop, by channel, for the most recent week
SELECT
  channel,
  signups AS last_week,
  ROUND(prev_4wk_avg, 1) AS prev_4wk_avg,
  ROUND(
    (signups - prev_4wk_avg) * 100.0 / NULLIF(prev_4wk_avg, 0),
    1
  ) AS pct_change
FROM comparison
WHERE week = (SELECT MAX(week) FROM weekly_signups)
ORDER BY pct_change ASC;

-- What a good analyst does with this:
-- - The output shows which channel dropped the most.
-- - The analyst then asks: "Did the ad campaign for that channel
--   pause? Did the landing page change? Did tracking break?"
-- - The query is the easy part. The follow-up questions are the job.
--
-- The misconception: "Analysts make dashboards."
-- The reality: Analysts diagnose. Dashboards are how they share
-- results, not how they find answers.

# data_quality_check.py — a step most beginners skip and most
# interviewers expect you to know.

import pandas as pd
from datetime import datetime, timedelta

def trust_check(df: pd.DataFrame, table_name: str) -> dict:
    """
    Run basic data quality checks before trusting any analysis.
    These are the checks a good analyst runs instinctively.
    """
    checks = {}

    # 1. Row count sanity — did we get a suspiciously small number?
    checks["row_count"] = len(df)
    checks["row_count_ok"] = len(df) > 100

    # 2. Duplicate primary key check
    if "id" in df.columns:
        dupes = df["id"].duplicated().sum()
        checks["duplicate_ids"] = int(dupes)
        checks["duplicate_ids_ok"] = dupes == 0

    # 3. Freshness — how old is the latest record?
    if "created_at" in df.columns:
        latest = pd.to_datetime(df["created_at"]).max()
        hours_old = (datetime.utcnow() - latest.to_pydatetime()).total_seconds() / 3600
        checks["data_age_hours"] = round(hours_old, 1)
        checks["data_age_ok"] = hours_old < 24

    # 4. Null check on critical columns
    critical = [c for c in ["user_id", "amount", "status"] if c in df.columns]
    for col in critical:
        nulls = df[col].isna().sum()
        checks[f"null_{col}"] = int(nulls)
        checks[f"null_{col}_ok"] = nulls == 0

    # 5. Numeric range check
    if "amount" in df.columns:
        neg = (df["amount"] < 0).sum()
        checks["negative_amounts"] = int(neg)
        checks["negative_amounts_ok"] = neg == 0

    # Summarize
    failures = [k for k, v in checks.items()
                if k.endswith("_ok") and not v]
    checks["passed"] = len(failures) == 0
    checks["failures"] = failures

    print(f"\n=== {table_name} ===")
    for k, v in checks.items():
        if not k.endswith("_ok"):
            print(f"  {k}: {v}")
    print(f"  PASSED: {checks['passed']}")
    if failures:
        print(f"  FAILED CHECKS: {failures}")

    return checks

# Example
# df = pd.read_csv("orders.csv")
# trust_check(df, "orders")

# Why this matters:
# - An analyst who does not check data quality will confidently
#   present wrong numbers — and eventually get caught.
# - Senior analysts run these checks by reflex before they trust
#   any query result.
# - Many "the data is wrong" complaints from stakeholders are
#   actually "the pipeline was stale" or "there were duplicate rows".
#
# The misconception: "Analysts just query data."
# The reality: Analysts verify data before they trust it.

# stakeholder_summary.md — the most underrated analyst skill
# This is what separates analysts who are respected from those
# whose reports get ignored.

# Weekly Signup Drop — Summary

## TL;DR
Signups dropped 18% last week (from a 4-week average of 4,200
to 3,450). 90% of the drop came from paid social, driven by a
paused Meta campaign.

## What happened
- Total signups: 3,450 (vs 4,200 avg, -18%)
- Paid social: 640 (vs 1,800 avg, -64%)
- Organic search: 1,820 (flat vs average)
- Referrals: 590 (up 12% vs average)
- Email: 400 (flat)

## Why
Meta campaign was paused on Tuesday for budget reasons.
The team that paused it did not know it was the primary
acquisition channel last month.

## Recommendation
1. Resume the Meta campaign with the original budget
2. Set up an alert when any active campaign is paused
3. Consider adding organic and referral as secondary channels

## What this analysis is NOT
- This is a 1-week snapshot. The 4-week view shows a normal
  trend once the campaign is restored.
- I did not investigate the drop in email signups (down 3%)
  because it is within noise.

## Questions for the team
- Was the pause intentional or a budget error?
- Should I build a recurring "signup health" dashboard?

---
Prepared by: [Your name]
Data as of: [Date] 09:00 IST

# Why this matters:
# - The analysis is only valuable if it lands clearly.
# - TL;DR upfront means busy stakeholders read it.
# - "What this is NOT" builds trust — you are honest about scope.
# - "Questions for the team" invites collaboration, not blame.
#
# The misconception: "Analysts should just send the data."
# The reality: Analysts who write clear summaries get promoted.
# Analysts who send screenshots of queries get ignored.