How Power BI Helps You Land a Data Engineer Job Faster

CREATE TABLE dim_date (
    date_key   INT PRIMARY KEY,       -- 20261106
    full_date  DATE NOT NULL,
    year       INT, month INT, month_name VARCHAR(10),
    is_weekend BOOLEAN
);

CREATE TABLE dim_product (
    product_key INT PRIMARY KEY,
    sku         VARCHAR(20) UNIQUE,
    category    VARCHAR(50)
);

CREATE TABLE fct_order_lines (          -- grain: one row per order line
    order_id    BIGINT,
    line_no     INT,
    date_key    INT REFERENCES dim_date(date_key),
    product_key INT REFERENCES dim_product(product_key),
    qty         INT,
    net_amount  NUMERIC(12,2),
    PRIMARY KEY (order_id, line_no)
);

-- PostgreSQL: generate a continuous date dimension
INSERT INTO dim_date
SELECT TO_CHAR(d, 'YYYYMMDD')::INT,
       d::DATE,
       EXTRACT(YEAR FROM d)::INT,
       EXTRACT(MONTH FROM d)::INT,
       TO_CHAR(d, 'Mon'),
       EXTRACT(ISODOW FROM d) IN (6, 7)
FROM generate_series(DATE '2024-01-01', DATE '2027-12-31', INTERVAL '1 day') AS d;

// Power Query: parameters RangeStart and RangeEnd (DateTime)
// must exist for incremental refresh. Filter on them:
let
    Source   = Sql.Database("dw.example.local", "analytics"),
    Lines    = Source{[Schema = "dbo", Item = "fct_order_lines_v"]}[Data],
    Filtered = Table.SelectRows(Lines,
                 each [order_ts] >= RangeStart and [order_ts] < RangeEnd)
in
    Filtered
// Then set the incremental refresh policy on the table in Power BI Desktop.

Nightly schedule (example)
01:00  Ingestion jobs start
02:30  Transformations (dbt) complete
02:45  Data quality tests pass
03:00  Power BI dataset refresh (incremental)
07:00  Users open reports
If tests fail at 02:45, pause the refresh and alert users.

Total Sales = SUM ( fct_order_lines[net_amount] )

Units = SUM ( fct_order_lines[qty] )

Sales MoM % =
VAR prev = CALCULATE ( [Total Sales], DATEADD ( dim_date[full_date], -1, MONTH ) )
RETURN DIVIDE ( [Total Sales] - prev, prev )

# Retail Orders: Pipeline to Dashboard
Source: synthetic orders API (Python generator)
Pipeline: Airflow DAG -> raw tables -> dbt models
Model: fct_order_lines + dim_date + dim_product
       (grain: one row per order line)
Quality: dbt tests on keys and accepted values
BI: Power BI report (3 pages), incremental refresh on facts
Diagram: docs/architecture.png

Week 1: Power BI Desktop, connect to Postgres/warehouse,
        model view, relationships, mark date table
Week 2: Core DAX (SUM, CALCULATE, DIVIDE, DATEADD),
        star schema vs flat table performance test
Week 3: Incremental refresh parameters, publish,
        schedule refresh, document dependencies

Experiment: flat table vs star schema
1. Load the same data as one wide table
2. Load it as fact + dimensions
3. Compare file size and visual speed
4. Write 3 lines on what you observed
Great material for an interview answer.

- Built an Airflow + dbt pipeline feeding a star schema
  (documented grain) and a Power BI report with
  incremental refresh scheduled after data quality tests