DEV Community: Sajjad Rahman

📘 Master Note: The Hidden Mechanics of PCA & ICA

Sajjad Rahman — Sat, 04 Apr 2026 09:17:13 +0000

Understanding Whitening, SVD, and the Math that Powers Dimensionality Reduction.

Part 1: The Big Picture (Intuition)

Before diving into complex algorithms like ICA, we need to understand the "behind-the-scenes" heroes that prepare and decompose our data.

1. Whitening: The Essential Pre-step for ICA

Whitening prepares your data so that all variables are uncorrelated and have equal variance.

The Goal: Transform the data into a "decorrelated, equal-variance" form.
💡 The Intuition: Imagine your data looks like a stretched, tilted "egg" (oval cloud).
- After PCA: The egg is rotated straight.
- After Whitening: The egg becomes a perfect sphere.
Why bother? ICA looks for independent signals. If data is already "spherical," ICA doesn't get distracted by the width or tilt of the data; it focuses entirely on finding non-Gaussian independence.

2. SVD: The Practical Engine of PCA

SVD is a mathematical powerhouse that decomposes any matrix $X$ into three parts:

\Sigma V^T

$U$: Directions in data space.
$\Sigma$: The strengths (importance) of each direction.
$V$: The directions of the features (The Principal Components).

Part 2: The Mathematical Engine

How do we actually move from raw data to a "white" sphere or a PCA result?

1. The Whitening Transformation

If $X$ is your original centered data, we use the Eigenvalues ($D$) and Eigenvectors ($E$) to transform it:

X_{white} = E D^{-1/2} E^T X

The logic behind the math:

$E^T$: Rotates the data (PCA).
$D^{-1/2}$: The "Magic Step." It scales every axis by its inverse standard deviation. It shrinks long axes and stretches short ones until they are equal.

2. The SVD ↔ PCA Connection

You can reach Principal Components via two paths, but they lead to the same destination:

Path A (Classical PCA): Find Eigenvectors of the Covariance Matrix: $\Lambda V^T$
Path B (Modern SVD): Decompose $X$ directly: $\Sigma V^T$

The "Aha!" Moment:
The $V$ in SVD is identical to the $V$ (Eigenvectors) in PCA. The Singular Values ($\sigma$) are the square roots of the Eigenvalues ($\lambda$):

\lambda_i = \frac{\sigma_i^2}{n}

Part 3: Performance & Comparisons

Why use SVD instead of Classical PCA?

In real-world data science, SVD is the industry standard for computing PCA.

Feature	Covariance (Classical)	SVD (Modern)
Memory	Requires $XX^T$ (can be massive)	Works directly on $X$
Precision	Squaring numbers loses small details	Keeps high numerical precision
Stability	Prone to rounding errors	Highly stable and robust

🧠 Final Logic Map (Summary)

Step 1: Use SVD to find the "skeleton" (Principal Components) of your data efficiently.
Step 2: Apply Whitening to turn your data cloud into a perfect sphere.
Step 3: Run ICA on that sphere to find hidden, independent signals.

🔥 Quick Memory:

Whitening: "Make it a sphere before ICA."

SVD: "The efficient engine that makes PCA work in the real world."

📘 The Science of Un-Mixing Data (PCA & ICA)

Sajjad Rahman — Sat, 04 Apr 2026 09:09:50 +0000

Part 1: The Math Toolbox (Prerequisites)

Before we can understand PCA and ICA, we need to understand the tools they use. Think of these as the "rules of the game" for handling data.

🔹 Basic Concepts

The Matrix (The Table): Data is organized into a matrix, which is just a giant grid of numbers. The columns usually represent different types of measurements (like different microphones or cameras), and the rows represent each specific moment in time we recorded.
The Vector (The Arrow): A single row or column from that table is called a vector. Mathematically, a vector is like an arrow pointing to a specific spot in a multi-dimensional space.
Inner Product (The Shadow): This is a way to multiply two vectors together. It tells us how much one vector "overlaps" with another. We use this to project our data onto new axes to see it from a better angle.
Basis Vectors (The Directions): These are the "original" directions we use to measure things, like the X and Y axes on a graph.

🔹 Statistical Concepts

Covariance (Redundancy): This measures how much two measurements "change together". If Measurement A always goes up when Measurement B goes up, they are redundant (highly correlated), meaning we don't really need both.

👉 Covariance Equation (Added, not replacing anything):

\text{cov}(A,B) = \frac{1}{n} \sum a_i b_i

Gaussian Distribution (The Bell Curve): This is a smooth, bell-shaped curve that represents "randomness" or "noise". The Central Limit Theorem says that if you mix many different signals together, the result will always look like a Gaussian bell curve.
Kurtosis (The Peakedness): This is a math score that measures how "sharp" or "peaked" a distribution of numbers is. A high kurtosis means the data has a sharp point, while a Gaussian curve has a kurtosis of zero.

Part 2: PCA (Principal Component Analysis)

The Goal

The Goal: To simplify a giant pile of data by finding the "best angle" to look at it.

How it Works

How it works: PCA looks at the Covariance Matrix of the data to find where the measurements are repeating each other.
Eigenvectors and Eigenvalues: PCA calculates special directions called eigenvectors. The "largest" eigenvector points in the direction where the most "action" (variance) is happening.

Core Equation (Added)

\cdot E

(D): data matrix
(E): eigenvectors of covariance
(P): principal components

👉 Also:

Covariance becomes diagonal after PCA

Key Properties

Dimensionality Reduction: By ignoring the tiny eigenvectors (which usually represent noise) and keeping only the big ones, we can make a huge data set much smaller without losing the important stuff.
The Rule of Orthogonality: In PCA, the new axes we find must always be orthogonal—which is a fancy way of saying they must be at 90-degree right angles to each other.

Algorithm Steps (Added Section)

PCA Steps

Center data (mean = 0)
Compute covariance matrix
Find eigenvectors
Project data

Why PCA Can Fail (Added Section)

👉 PCA fails when:

Data is non-linear
Or variance ≠ true structure

Example:

Ferris wheel → PCA cannot find circular motion

💡 Add this line:

PCA only captures linear structure, ICA can handle more complex separation.

Part 3: ICA (Independent Component Analysis)

The Goal

The Goal: To solve the "Cocktail Party Problem"—taking a messy mixture of signals and separating them into their original, clear sources.

How it Works

Blind Source Separation: ICA is used when we have mixtures (like two microphones recording two people) but we don't know exactly how they were mixed.
The Weight Matrix ($W$): ICA tries to find a mathematical "unmixing" tool called a weight matrix. When we multiply our messy data by this matrix, the original signals should pop out.

Core Equation (Added)

\cdot W

(X): mixed signals
(W): unmixing matrix
(Y): independent sources

👉 This is THE most important ICA equation

Key Concepts

The Search for Independence: ICA is stricter than PCA. It doesn't just want the data to be "not repeating"; it wants the signals to be statistically independent, meaning what happens in one signal tells you absolutely nothing about the other.

Non-Gaussianity (The Secret Trick): Because mixed-up signals look like smooth bell curves, ICA rotates the data until it finds the directions with maximum kurtosis (the most peaked shapes). A sharp peak usually means you've found a pure, unmixed source.

👉 Improved understanding:

Mixtures → Gaussian (Central Limit Theorem)
Sources → non-Gaussian (peaked)

💡 Key idea:

ICA works because mixing makes data Gaussian, so unmixing looks for non-Gaussian signals

Flexibility: Unlike PCA, the axes in ICA do not have to be at right angles. They can point in any direction needed to find the sources.

Algorithm Steps (Added Section)

ICA Steps

Center + whiten data
Initialize weights
Maximize non-Gaussianity
Iterate until convergence

Part 4: PCA vs ICA (Added Comparison Table)

Feature	PCA	ICA
Goal	Max variance	Independence
Output	Uncorrelated	Independent
Axes	Orthogonal	Not required
Uses	Compression	Signal separation
Assumption	Gaussian OK	Non-Gaussian needed

👉 Lecture explicitly says:

PCA → decorrelation
ICA → independence (stronger)

Part 5: Why do we use these?

These tools are used in many cool ways:

Fetal Heart Monitoring: Separating a baby's tiny heartbeat from the mother's much louder heartbeat.
EEG (Brain Waves): Removing "trash" signals like eye blinks or heartbeats from recordings of brain activity.
fMRI (Brain Imaging): Finding which specific parts of the brain are working together during a task.
Computer Vision: Understanding how our eyes and brain recognize edges and shapes in the world around us.

Stanford is Teaching the World to Code for Free!

Sajjad Rahman — Wed, 25 Mar 2026 12:57:35 +0000

Learn Python from Stanford ** 🚀

This isn't just a video course; it is a structured journey where you learn to build logic step-by-step with Chris and Mehran. If you want to stop watching tutorials and start actually coding, here is why you should join Stanford’s Code in Place:

What Makes This Course Unique?

The Karel Phase: You don't start with scary syntax. Instead, you command "Karel," a tiny robot, to master logic, loops, and problem-solving foundations.
Python Mastery: The curriculum moves smoothly from basic Print and Input to advanced topics like control flow and graphics.
Creative Freedom: You get to build your own projects, like a "Console" or the "Game of Nimm," giving you the confidence to create from scratch.
Data & Beyond: You will master real-world techniques involving Lists, Dictionaries, and Graphics.

The Best Part? The Community!

You aren't learning alone. You are supported by a massive core team and amazing section leaders who help you at every step of the way.

Join the Movement!

If you’re ready to take your first real step into programming, apply today. Use the link below to start your application:

👉 Apply Now: https://codeinplace.stanford.edu/public/join/cip6?r=ngqms6

Let’s learn and build together!

Understanding cmd /c and cmd /k

Sajjad Rahman — Wed, 07 Jan 2026 17:33:48 +0000

When I started learning Command Prompt, I was very confused about cmd /c and cmd /k. Even after running the commands, everything looked the same, so I thought nothing was executed. If you feel the same, this post is for you.

First, understand this important point

You are already inside a Command Prompt when you see something like:

I:\ethical-test>

This is your parent CMD.

What actually happens when you run `cmd /k dir`

Command:

cmd /k dir

What it does step by step:

Your current CMD starts a new CMD (child CMD)
The new CMD executes the dir command
Because of /k, the new CMD stays open
Since the path and prompt look the same, it appears unchanged
In reality, you are now inside the child CMD

You can prove this by typing:

exit

This will take you back to the parent CMD.

What happens when you run `cmd /c echo hello`

Command:

cmd /c echo hello

Steps:

A new CMD opens
It runs echo hello
Prints hello
Immediately closes the new CMD
Control returns to the parent CMD

That’s why you only see the output and nothing else.

Why this feels confusing

You are running CMD inside CMD
Windows does not show any visual difference
Same path, same prompt, same window
Execution happens very fast

So it looks like nothing changed, but it actually did.

Simple rule to remember

cmd → creates a new Command Prompt
/k → run command and keep CMD open
/c → run command and close CMD immediately

Final takeaway

cmd /c and cmd /k do work correctly.
The confusion happens because beginners usually run them inside an already opened CMD, so the difference is not visually obvious.

If you understand this, most CMD-related confusion disappears.

Windows CMD – File & Directory Management

Sajjad Rahman — Wed, 07 Jan 2026 16:42:37 +0000

Windows CMD – File & Directory Management

1️⃣ Directory Basics (`dir`)

Show files and folders

dir

Important entries

. → current directory
.. → parent directory
<DIR> → folder
File size shown in bytes

2️⃣ Creating Files with `echo`

Create a file with text

echo "sajjad" > samina.txt

Read file content

type samina.txt

Output

"sajjad"

⚠ Why quotes appear?

Because quotes are literal characters inside echo.

✔ To avoid quotes:

echo sajjad > samina.txt

3️⃣ Creating an Empty (Blank) File – IMPORTANT CONCEPT

Command used

echo 2>err.txt

❓ Why is `2` used here?

This is error stream redirection.

Stream	Meaning
`0`	Standard Input
`1`	Standard Output
`2`	Standard Error

What actually happens?

echo produces no error
Error stream (2) is empty
Empty stream redirected → file created with 0 bytes

✔ This is a CMD trick to create an empty file.

Better & common methods

type nul > file.txt

echo. > file.txt

4️⃣ Deleting Files (`del`)

del na.txt

Check after deletion

type na.txt

Output

The system cannot find the file specified.

✔ File deleted successfully

5️⃣ Renaming Files (`rename`)

rename err.txt error.txt

✔ File name changes only, content remains same

6️⃣ Creating & Moving Directories

Create directory

mkdir samsaj

Move file into directory

move samina.txt samsaj

Change directory

cd samsaj

Go back

cd ..

7️⃣ Path Symbols Explained

Symbol	Meaning
`.`	Current directory
`..`	Parent directory
`\`	Windows path separator

Example:

move samina.txt .\samsaj

8️⃣ Copying Files (`copy`)

copy samina.txt sajjad.txt

✔ Creates duplicate file with same content

9️⃣ Removing Directories (`rmdir`) – VERY IMPORTANT

Delete empty directory

rmdir sam

❌ If directory is NOT empty

The directory is not empty.

✔ Correct way to delete directory with files

rmdir /S sam

/S → deletes all files + subdirectories
Confirmation required

❌ Wrong commands (do not work):

rmdir -S sam
rmdir \S sam

🔟 Comparing Files (`fc`)

fc sajjad.txt samina.txt

Output meaning

Shows line-by-line differences
Useful for file integrity checking

1️⃣1️⃣ Symbolic Links (Soft Links) – `mklink`

⚠ CMD must be Run as Administrator

Create symbolic link

mklink linkfile file3.txt

Verify

dir

Output

<SYMLINK> linkfile [file3.txt]

✔ Both files point to same data
✔ Reading/writing link affects original file

1️⃣2️⃣ Searching Files with `dir`

Search specific file recursively

dir /s torjan.txt

Search all `.txt` files

dir /s *.txt

1️⃣3️⃣ Finding Files using `forfiles`

Command

forfiles /P I:\ /S /M torjan.txt /C "cmd /c echo @PATH"

Flags explained

Flag	Meaning
`/P`	Starting directory
`/S`	Recursive search
`/M`	Filename or pattern
`/C`	Command to run
`@PATH`	Full file path

❗ Access denied errors?

Normal behavior — system protected folders ($RECYCLE.BIN, System Volume Information)

✔ File still found successfully.

1️⃣4️⃣ Finding Text Inside Files – `find`

❌ Wrong usage

find "pass" I:

✔ Correct usage

find "pass" filename.txt

Example:

find "pass" I:\ethical-test\samsaj\s299\s299.txt

Output

pass : s299
pass : s265

⚠ find is case-sensitive and basic

1️⃣5️⃣ Advanced Text Search – `findstr` (Recommended)

Search word

findstr "pass" s299.txt

Output

pass : s299
pass : s265
sam pass samina password
sajjad password pass

Why `findstr` is better?

✔ Case-insensitive (by default)
✔ Supports patterns
✔ Searches multiple lines cleanly

✅ Key Takeaways (Revision Summary)

echo > file → creates file with content
echo 2> file → creates empty file via error redirection
type → read file
del → delete file
rename → rename file
mkdir / rmdir → directory management
/S is mandatory to delete non-empty folders
fc → compare files
mklink → symbolic link (admin required)
dir /s → recursive file search
forfiles → powerful file finder + executor
findstr → best for searching text inside files

Windows File System Navigation & System Information

Sajjad Rahman — Mon, 05 Jan 2026 09:47:25 +0000

📘 Windows File System Navigation & System Information

(Beginner-Friendly Notes for Ethical Hacking / Windows Basics)

1️⃣ Windows Command Line Basics (CMD)

🔹 Command Prompt (cmd.exe)

Windows command-line interface
Used to navigate files, run commands, and gather system info
Commands are NOT case-sensitive

  cd desktop
  cd Desktop
  cd DESKTOP

✔️ All work the same, even though actual folder name is Desktop

2️⃣ Changing Directories (`cd` Command)

🔹 Move to Another Folder

cd Desktop

➡️ Moves into the Desktop directory

🔹 Go Back One Level (Parent Directory)

cd ..

🔹 Go to Root Directory

cd /

cd \

📌 Example:

C:\Users\F C\Desktop> cd /
C:\>

✔️ You are now in the root directory

3️⃣ Understanding Root Directory (`C:\`)

Root directory = starting point of the Windows file system
Example:

C:\

Common Root Folders

Folder	Purpose
`Windows`	OS files
`Program Files`	64-bit apps
`Program Files (x86)`	32-bit apps
`Users`	User accounts
`ProgramData`	Shared app data (hidden)

4️⃣ Listing Files & Folders (`dir` Command)

🔹 Basic Listing

dir

📌 Shows:

Files
Folders (<DIR>)
File size
Date & time

✔️ dir is a built-in command in cmd.exe

🔹 Directory Symbols

Symbol	Meaning
`.`	Current directory
`..`	Parent directory

5️⃣ Showing Hidden Files (`dir /a`)

🔹 Command

dir /a

📌 /a = show ALL files, including:

Hidden
System
Junctions
Symbolic links

Example Output Explained

<SYMLINKD>  All Users -> C:\ProgramData
<JUNCTION> Default User -> C:\Users\Default

✔️ These are links, not real folders

6️⃣ Windows Users Directory (`C:\Users`)

Structure

C:\Users
 ├── Public
 ├── F C
 ├── Default

🔹 Public Folder

Shared by all users
Any user can access files inside

🔹 User Folder (`F C`)

Created at first login
Contains:
- Desktop
- Documents
- Downloads
- AppData

🔹 Multiple Users in Windows

Windows supports multiple users
Each user has:
- Separate files
- Separate settings
- Separate Temp files
```
C:\Users\<username>\AppData\Local\Temp
```

📌 New users can be created from:

Control Panel
Settings → Accounts
Or via admin commands

7️⃣ AppData Folder (Important for Hackers)

📍 Path:

C:\Users\F C\AppData

Folder	Purpose
Local	App cache, temp data
Roaming	Syncable user data
LocalLow	Low-privilege apps

📌 Hidden by default

8️⃣ System Information (`systeminfo`)

🔹 Basic Command

systeminfo

What It Shows

OS version
Build number
Installed hotfixes
Hardware info
Network info
Boot time

✔️ Very useful for enumeration

🔹 Invalid Syntax Example (Corrected)

❌ Wrong:

systeminfo -S

✔️ Correct:

systeminfo /S system_name

🔹 Help Menu

systeminfo /?

Shows all valid options:

/S → Remote system
/U → Username
/P → Password
/FO → Output format (TABLE / LIST / CSV)

9️⃣ Environment Variables

🔹 Linux vs Windows Syntax

OS	Syntax
Linux	`$USER`
Windows	`%USERNAME%`

❌ Wrong:

echo $username

✔️ Correct:

echo %username%

Output

F C

🔹 View All Variables

set

🔹 Custom Variable Example

set samina="sajjad"
echo %samina%

📌 Variables set like this:

Are temporary
Reset after closing CMD

🔟 External System Tools (Sysinternals)

🔹 Why Needed?

Some commands like psinfo:

❌ Not built-in
✔️ Must be downloaded

🔹 Sysinternals Suite

Official Microsoft tools
Used for:
- System enumeration
- Process analysis
- Memory inspection

📥 Download:

https://learn.microsoft.com/en-us/sysinternals/downloads

🔹 Example: `psinfo`

Shows:

Uptime
Kernel version
CPU info
RAM
Video driver

✔️ Useful for post-exploitation enumeration

1️⃣1️⃣ Key Takeaways (Quick Revision)

cd → change directory
cd / → root directory
dir → list files
dir /a → show hidden files
%USERNAME% → Windows variable syntax
systeminfo → OS & hardware info
Sysinternals → advanced enumeration tools
Each Windows user has:
- Separate profile
- Separate temp files
- Separate AppData

DP-600 Fabric Analytics Engineer – Structured Study Notes

Sajjad Rahman — Sat, 06 Dec 2025 16:23:49 +0000

DP-600 Fabric Analytics Engineer – Structured Study Notes

(Governance, Admin, Lifecycle, Data Prep, Semantic Models)

0. Big Picture – What DP-600 Expects From You

The DP-600 exam is about designing, building, governing, and optimizing analytics solutions in Microsoft Fabric.

At a high level you must be able to:

Maintain a data analytics solution
– Governance, security, admin, lifecycle, impact analysis
Prepare data
– Ingest, transform, store in Lakehouse/Warehouse/KQL DB, apply patterns like incremental and CDC
Implement and manage semantic models
– Modeling, storage modes, DAX basics, RLS/OLS, performance

This note focuses on all the topics you listed and ties them together with exam-style thinking.

1. Maintain a Data Analytics Solution

(Governance, Admin, Lifecycle)

This area covers:

Security & governance (access, RLS/CLS/OLS, sensitivity labels, endorsement)
Admin: workspaces, capacities, roles
Development lifecycle: Git, PBIP, deployment pipelines, XMLA
Monitoring & impact analysis (lineage)

1.1 Security & Access Control in Fabric

Security is layered. Think about:

Workspace-level roles
Item-level permissions
Data-level security (RLS/CLS/OLS)
File-level security
Sensitivity labels
Endorsement

1.1.a Workspace-Level Access

Each workspace has roles:

Admin
- Full control over the workspace
- Can change settings, add/remove users, delete items
- Used by platform owners / team leads
Member / Contributor
- Can create and edit items (Lakehouse, Dataflow, Reports, Pipelines, Notebooks)
- Cannot change workspace-level admin settings (like capacity)
Viewer
- Read-only access: can view reports, dashboards, semantic models, etc.
- Cannot create, edit, or publish new items

Common exam scenario:
“A user can open a report but cannot edit it or create a new dataflow in the same workspace. What is the likely cause?”
→ The user is a Viewer and needs at least Contributor/Member.

1.1.b Item-Level Permissions & Build

Even inside a workspace, every item has its own permissions:

Lakehouse
Warehouse
Semantic model (dataset)
Report
Notebook
Dataflow

A user might be Contributor on the workspace but still:

Cannot use a semantic model to build new reports
Cannot Analyze in Excel

The key concept is Build permission on the semantic model.

Build permission is required to:

Create new reports from a semantic model
Use Analyze in Excel
Use the semantic model from another workspace (when cross-workspace is allowed)
Allow composite models based on that dataset

Exam pattern:
“User can view a report but cannot use ‘Analyze in Excel’ or create a new report from the dataset.”
→ They are missing Build permission on the semantic model.

1.1.c RLS, CLS, OLS & File-Level Security

Security doesn’t stop at item level; it also applies to data inside the model.

Row-Level Security (RLS)

Restricts which rows a user can see.
Example:
- User in “Bangladesh” role only sees rows where Country = 'BD'.
Implemented in the semantic model (Power BI dataset / Fabric semantic model).

Column-Level Security (CLS)

Controls which columns a user can see.
Example:
- Hide Salary, SSN, PhoneNumber from certain roles.

Object-Level Security (OLS)

Hides entire tables or columns from users or roles.
Example:
- A Finance table is completely hidden from Sales users.

File-Level Security (OneLake / Files)

In Fabric:

Lakehouse has:
- Tables → usually accessed via SQL endpoint & semantic model
- Files → raw storage in OneLake filesystem

You can secure Files separately:

A user might:
- Query tables via semantic model
- But not be allowed to browse the Lakehouse Files section
That requires filesystem / OneLake permissions, which are separate.

Exam pattern:
“User can query a Lakehouse table via the SQL endpoint but cannot open the Files area in the Lakehouse.”
→ They are missing file-system permission on OneLake.

1.1.d Sensitivity Labels (Purview Integration)

Sensitivity labels classify and protect data. Common examples:

Public
General
Confidential
Highly Confidential – No Export

Once applied to semantic models, reports, etc., labels can:

Block Export to Excel / CSV
Block Publish to web
Restrict external sharing (especially with encrypted labels)

Important admin settings include:

Allow users to apply sensitivity labels
– Without this, labels aren’t available in Fabric.
Automatically apply sensitivity labels to downstream content
– A label applied to a semantic model can propagate to reports, dashboards, etc.
Allow Microsoft Purview to secure AI interactions
– Controls whether Copilot/AI can interact with labeled data under Purview governance.

Exam pattern:
“After applying a label to a report, users can view it but can no longer export the data. Why?”
→ The label (e.g., Highly Confidential – No Export) is configured to block export.

1.1.e Endorsement: Promoted & Certified

Endorsement helps users know which data they can trust.

Promoted
- Indicates team-level / local confidence
- Suggestion: “This is useful, but not centrally governed.”
Certified
- Indicates organization-level endorsement
- Represents single source of truth
- Generally restricted to a set of data stewards / admins

Endorsed items typically show in:

Data hub
OneLake data explorer
Search and discovery areas

Exam pattern:
“The central BI team wants certain semantic models to be recognized as single sources of truth across the organization. What should they use?”
→ Use Certification with appropriate governance.

1.2 Admin & Governance: Tenant, Capacity, Workspace

A lot of DP-600 questions are about “which setting to change?”.

The mental model:

Tenant = organization-wide policies
Capacity = compute configuration (F64, F128, Premium)
Workspace = team/project scope

Tenant

Controls global features like:

Whether Fabric is enabled at all
Whether users can create Fabric items
Export policies (Excel/CSV, PBIX download)
Guest users and external sharing
Sensitivity labels and Purview/AI integration
Trial activation (“Users can try Fabric paid features”)

Think: “This affects everyone / every workspace” → Tenant.

Capacity

Controls the compute resources and workloads:

Type of capacity: Fabric F-SKU, Power BI Premium, Embedded, etc.
Region and SKU size (F64, F128, etc.)
Workload settings:
- Spark / Data Engineering
- Dataflows
- Pipelines
- DirectLake / cache behavior
Ability to pause and resume capacity
Concurrency limits and memory settings

Common issues:

Dataflows stuck in queue → capacity under pressure / workload disabled

Notebooks fail to start → Spark capacity exhausted

DirectLake becomes slow → capacity overloaded, cache eviction

Workspace

The workspace ties everything together:

Assigned to a capacity (shared vs Fabric/Premium)
Used by teams to store:
- Lakehouses
- Warehouses
- Dataflows
- Pipelines
- Semantic models
- Reports

Key points:

Shared capacity workspaces:
- Can host Power BI content (reports, datasets, dashboards)
- Cannot host Fabric items like Lakehouse, Warehouse, Dataflow Gen2, Notebooks, Pipelines, DirectLake
Fabric/Premium capacity workspaces:
- Can use the full Fabric experiences.

Exam pattern:
“A workspace does not show the option to create a Lakehouse or Dataflow Gen2, but users can still create reports.”
→ The workspace is on Shared capacity or tenant has disabled Users can create Fabric items.

1.3 Analytics Development Lifecycle (CI/CD, Versioning)

This part is about acting like a real analytics engineer, not just building in the UI.

Key areas:

Version control with Git
PBIX vs PBIP/PBIR
Deployment pipelines (Dev → Test → Prod)
XMLA endpoint
Impact analysis / lineage

1.3.a Version Control with Git

Fabric supports Git integration for workspaces, so you can:

Connect a Fabric workspace to a Git repository
Store:
- Reports as PBIP / PBIR
- Notebooks as .ipynb or scripts
- SQL scripts
- Pipeline definitions as code

Benefits:

Team collaboration
Pull request (PR)-based code review
History & rollback
Integration into DevOps/CI/CD pipelines

Exam-view: DP-600 expects you to know why Git integration is useful, not every click.

1.3.b PBIX vs PBIP / PBIR

PBIX
- Binary file
- Traditional Power BI format
- Harder to source control (large monolithic file)
PBIP / PBIR
- Text-based project structure
- Separates metadata, model, and report layout into files/folders
- Much easier for Git and automated deployments

For DP-600, you must understand:
PBIP/PBIR = Git-friendly representation of Power BI content.

1.3.c Deployment Pipelines

Deployment pipelines support stage-based promotion of content:

Typical stages:
- Development → Test → Production

You can deploy:

Semantic models (datasets)
Reports
Dashboards
Some Fabric items (or via scripts/automation)

Key ideas:

Rules / parameters per stage:
- Different data source connections per environment (Dev DB vs Prod DB)
Ensuring changes are tested in Test before going to Production
Automatic or manual deployment flows

Exam scenario:
“You must promote changes from Dev to Prod while pointing to different databases. What feature should you use?”
→ Deployment pipelines with rules for data source bindings.

1.3.d XMLA Endpoint (for Semantic Models)

XMLA endpoint allows enterprise management of semantic models using external tools like:

Tabular Editor
SQL Server Management Studio (SSMS)
Scripts for deployment and partition management

Typical actions:

Partitioning large tables
Incremental refresh control
Advanced calculation groups
Scripting deployments (e.g., ALM Toolkit, DevOps pipelines)

For DP-600, you need conceptual understanding:
XMLA endpoint = enterprise-grade control and automation for Fabric/Power BI semantic models.

1.3.e Impact Analysis & Lineage

Impact analysis means understanding:

If I change this object, what breaks?

Fabric offers:

Lineage view:
- Shows flow: Data source → Dataflow → Lakehouse/Warehouse → Semantic model → Reports

Use cases:

Before changing a table schema
Before deleting a Dataflow or Lakehouse
Before renaming columns or tables

Exam pattern:
“You plan to change a Lakehouse table schema and want to ensure you understand which semantic models and reports will be affected. What should you use?”
→ Use lineage view or impact analysis tools in Fabric.

2. Prepare Data (Largest Weight in Exam)

This is the “heart” of DP-600:

Ingest data
Transform data
Store/serve data in Lakehouse / Warehouse / KQL DB
Design data processing patterns (incremental, CDC, real-time)
Enforce data quality and business rules

2.1 Ingest Data into Fabric

Main tools:

Data Factory (Fabric Data Factory experience)
Dataflow Gen2
Spark Notebooks
Shortcuts (zero-copy)

a) Data Factory

Fabric Data Factory is the orchestration & ingestion engine:

Copy Activity:
- Move data from source to destination (e.g., SQL → Lakehouse, Blob → Warehouse)
Pipeline templates:
- Prebuilt patterns (e.g., copy new files daily, ingest from SaaS, etc.)
Supports hundreds of connectors:
- SQL Server, Azure SQL, ADLS, Blob, Salesforce, etc.

Use Data Factory when:

You need pure data movement (ELT)
You orchestrate multiple steps and sources
You want scheduled ingestion pipelines

b) Dataflow Gen2

Dataflow Gen2 is Power Query Online in Fabric:

Perform transformations (cleaning, shaping) using Power Query
Define ETL logic in a friendly GUI
Output to:
- Lakehouse tables
- Warehouse tables
- KQL Databases

Typical use cases:

Business-friendly transformation definitions
Creating conformed dimension tables (e.g., DimCustomer)
Reusable data preparation logic

c) Spark Notebooks

Spark notebooks are for big data engineering:

Language options:
- PySpark, Scala, Spark SQL
Use cases:
- Large-scale joins and transforms
- Processing semi-structured or unstructured data
- Machine learning and advanced analytics
Write results into:
- Delta tables in the Lakehouse
- Files (Parquet, CSV, etc.)

d) Shortcuts (Zero-Copy)

Shortcuts let you:

Reference data in external storage (ADLS Gen2, S3, other OneLake accounts)
Without copying data into your Lakehouse

Think of a shortcut as:

A pointer to external data, not a copy.

Use for:

Central governance (single copy of data)
Multi-domain or multi-tenant architectures
Simplifying multi-region data access

2.2 Transform Data

Three main transformation engines:

Dataflow Gen2 (Power Query)
Spark Notebooks
T-SQL in Warehouse / SQL Endpoint

1) Dataflow Gen2

Good for:

Business-friendly logic
Medium-size data
Tabular transformations
Slowly changing dimensions (when combined with logic)

Examples:

Clean column names, change data types
Merge (join) multiple sources
Filter out errors
Create calculated columns (e.g., MonthNumber = Date.Month([OrderDate]))

2) Spark Notebooks

Good for:

Very large datasets
Complex transformations where M/Power Query is limiting
Streaming + batch
AI/ML workflows

You can:

Use PySpark to message large tables
Optimize with Delta features (OPTIMIZE, VACUUM)

3) T-SQL (Warehouse / SQL Endpoint)

Good for:

Teams with strong SQL skills
ELT patterns (Load raw → Clean → Transform using SQL)
Dimensional modeling inside Warehouse (Dim/Fact tables)
Creating views and stored procedures

You can:

Write SQL scripts
Use them in pipelines as SQL script activities
Build business logic in the Warehouse itself

Exam angle:
You must choose the right engine for each scenario:

Business user ETL? → Dataflow Gen2

Heavy big data & ML? → Spark notebooks

Standard enterprise SQL team? → T-SQL in Warehouse

2.3 Lakehouse vs Warehouse (Plus KQL DB)

Lakehouse

Combines:
- Files (raw storage)
- Tables (Delta format)
Ideal for:
- Medallion architecture:
- Bronze (raw)
- Silver (cleaned)
- Gold (business)
- Big data, semi-structured files, logs
Works best with:
- Spark notebooks
- Dataflow Gen2
- DirectLake-based semantic models

Warehouse

SQL-first experience:
- Tables, views, stored procedures
Ideal for:
- Structured, relational modeling
- Enterprise reporting, financial analytics
- Teams strong in SQL
Serves:
- Semantic models
- Reports directly via SQL engine

Typical exam scenario:

“Customer 360 view, finance, heavily structured reporting, strong SQL skills → choose Warehouse.”

“High-volume logs, clickstream, semi-structured events → choose Lakehouse + Spark.”

KQL Database (Kusto Query Language)

Optimized for log and time-series analytics
Used for:
- Real-time telemetry
- Observability data
- Operational analytics

2.4 Patterns: Incremental, CDC, Real-Time

Incremental Load

Process only new or changed data.
Benefits:
- Performance
- Cost
- Reduced load windows

Examples:

Dataflow Gen2 with incremental refresh policy (by date column)
SQL-based approaches using LastModifiedDate watermark

Change Data Capture (CDC) / Change Feed

Tracks row-level changes from a source (insert, update, delete)
Good for:
- Keeping Warehouse or Lakehouse in sync with OLTP systems
- Near-real-time updates

Real-Time / Streaming

Fabric also offers Real-Time Intelligence components like:
- Eventstreams
- KQL DB
- Real-time dashboards

Use case:

IoT streams
Website event tracking
Monitoring metrics with low latency

3. Implement and Manage Semantic Models

This is the Power BI + Fabric modeling side:

Storage modes
Modeling fundamentals
DAX basics
Security in the model (RLS/OLS)
Performance & optimization

3.1 Storage Modes: Import, DirectQuery, DirectLake, Composite

Import

Data is stored inside the model in memory.
Very fast query performance.
Requires scheduled or manual refresh.
Good for small–medium datasets and users who can tolerate some latency in freshness.

DirectQuery

No data stored in the model; all queries go to the source (SQL, etc.)
Good for real-time or near-real-time when data must stay at source.
Slower and more limited in modeling features; depends heavily on source performance.

DirectLake

Fabric-only mode.
Queries Delta tables in OneLake directly, with caching.
Combines advantages of Import (fast) and DirectQuery (near-real-time) for Fabric-based data.
Requires Fabric/Premium capacity and proper Lakehouse/Warehouse setup.

Composite Models

Mixes Import + DirectQuery + DirectLake in one model.
Very flexible but more complex to manage.

Exam scenario example:
“You must query a large Fabric Lakehouse with low latency and avoid scheduled refresh, and you have Fabric capacity. Which storage mode is recommended?”
→ DirectLake.

3.2 Modeling Fundamentals

Star schema is the gold standard:

Fact tables
- Large, numeric, transactional data
- E.g., FactSales, FactOrders
Dimension tables
- Smaller, descriptive, business entities
- E.g., DimCustomer, DimProduct, DimDate

Benefits:

Simpler queries
Better performance
More intuitive modeling

Relationships:

Mostly one-to-many (Dimension → Fact)
Use single direction filtering (Dimension filters Fact) unless there’s a strong reason otherwise.
Many-to-many relationships: use carefully; they can create ambiguous filter paths.

Best practices:

Use surrogate keys (integers) for relationships
Keep dimension tables wide but not huge
Avoid snowflake if performance is critical (flatten dimensions where reasonable)

3.3 DAX & Calculations

You don’t need to be a DAX guru for DP-600, but you should understand:

Calculated columns vs Measures:
- Calculated columns:
- Computed at data refresh time
- Stored in the model
- Row context
- Measures:
- Computed at query time
- Based on filter context
Row context vs Filter context:
- Row context → operations that work “row by row”
- Filter context → the filters that apply to the measure (via slicers, filters, etc.)
Basic time intelligence:
- TOTALYTD, SAMEPERIODLASTYEAR, DATEADD, etc.

3.4 Security in Semantic Models

Again, security at the model level:

RLS (Row-Level Security):
- Table filter expressions per role
- Example: [Country] = "Bangladesh" for certain users
OLS (Object-Level Security):
- Hide specific tables/columns from roles

Important:

RLS/OLS apply regardless of storage mode (Import/DirectQuery/DirectLake), with some advanced nuances.
Even if a user has Build, they still only see rows allowed by RLS.

3.5 Performance & Optimization

Large or complex models can slow down. Common optimization strategies:

Use star schema instead of snowflake
Avoid many-to-many relationships and bi-directional filters unless necessary
Use aggregations
Avoid overly complex DAX measures that iterate row-by-row over large tables
Use proper types & summarization to reduce memory usage
Use XMLA endpoint and Tabular Editor for:
- Partitioning fact tables
- Incremental refresh tuning
- Calculation groups

Exam-style question:
“A large semantic model is slow. What are effective techniques to improve performance?”
→ Star schema, aggregations, optimizing relationships, partitioning, and simplifying DAX.

4. Practical Study Plan (How to Use This Note)

Since you already have some hands-on with Fabric:

Step 1 – Fabric Objects & Admin

Understand:
- Lakehouse, Warehouse, Dataflow Gen2, Pipelines, Notebooks, Semantic models, KQL DB
Learn:
- Tenant vs Capacity vs Workspace
- Critical settings: “Users can create Fabric items”, guest access, export settings, labels, DirectLake requirements

Step 2 – Prepare Data (Hands-on + Theory)

Build a small scenario:
- Ingest CSV → Dataflow Gen2 → Lakehouse
- Transform with Dataflow (custom column, type changes)
- Optionally, use a Pipeline to orchestrate Dataflow + Notebook
Explore:
- Lakehouse Tables vs Files, Delta basics
- Shortcuts to some external storage (if possible)

Step 3 – Semantic Model & Reporting

Create a semantic model from the Lakehouse:
- Try Import and DirectLake
Build:
- A star-schema style model
- Some simple DAX measures (Total Sales, YTD, Last Year comparison)
Configure:
- RLS roles (e.g., region-based)

Step 4 – Governance & Lifecycle

Review:
- Workspace roles
- Item permissions & Build permission
- Sensitivity labels (set up a simple label and see its effects)
Understand:
- Git integration & PBIP concept
- Deployment pipelines Dev → Test → Prod
- Lineage view and impact analysis

DP-600: Advanced Prescriptive & Predictive Analytics MCQ Practice (Part-01)

Sajjad Rahman — Tue, 02 Dec 2025 09:46:10 +0000

There are 4 types of analytics in data world:

1) Descriptive Analytics → What happened?

It summarizes past data
Example: “Sales increased 15% last month”

Used visuals: tables, cards, bar charts

2) Diagnostic Analytics → Why did it happen?

It explains the reason behind the result
Example: “Sales increased because ads performed well”

Tools: Decomposition tree, Key Influencers

3) Predictive Analytics → What will happen?

It forecasts the future
Example: “We predict a 20% drop in churn next month”

Tools: ML models, forecasting, AutoML

4) Prescriptive Analytics → What should we do?

It suggests the best action based on predictions
Example:
- “Offer a discount to high-risk customers”
- “Increase ad budget for Segment A”
- “Send follow-up emails to low-engagement users”

💡 Prescriptive = ML + recommended action

Descriptive — What happened?
Purpose: summarize past data. Tools: cards, tables, bar/line charts.
Example exam cues: “show totals”, “last month’s sales”.

Diagnostic — Why did it happen?
Purpose: explain root cause. Tools: Key Influencers, Decomposition Tree, drillthrough.
Example cues: “identify drivers”, “explain drop in revenue”.

Predictive — What will happen?
Purpose: forecast future events using ML. Tools: AutoML, forecasting, classification/regression models.
Example cues: “predict”, “probability”, “forecast”.

Prescriptive — What should we do?
Purpose: recommend actions (next-best-action / optimization). Tools: recommendation engines, optimization models, ML + action mapping.
Example cues: “recommend”, “suggest action”, “optimize”, “next best offer”.

Exam rule of thumb: If the question asks what action to take, think prescriptive → ML + action.

What is prescriptive analytics?
Prescriptive analytics is the step beyond predicting. It answers: “Given what we know and what’s likely to happen — what should we do now?”
Core elements:_ An ML or optimization model_ that produces predictions or scores.

Decision logic that maps predictions to actions (rules, optimization objective, cost/benefit).

Integration into reports or systems to display or enact the recommended actions.

Typical output: a column or visual that says “Offer 20% discount” or “Route to specialist” — not just “churn probability = 0.85”.

*Embedding an Azure Machine Learning model into Power BI: how it works *

Train model (Azure ML, Fabric AutoML, Python/R).
Deploy model as a web service (REST endpoint).
Call endpoint from a dataflow / Power Query / Fabric pipeline or call it outside and bring scored data in.
Use outputs in Power BI as calculated columns or visuals.
Map predictions to actions with DAX, Power Query logic, or an operationalization layer (e.g., if churn_prob > 0.8 → “Offer 30% off”).
Present recommendations in report visuals (tables, cards, conditional formatting).

Why this is preferred:

Dynamic (updates with new data)
Automated and scalable
Can incorporate business rules and thresholds

Static text boxes & manual updates — when they appear (and why they’re wrong for prescriptive)
Static text boxes: useful for titles, descriptions, instructions—never for dynamic recommendations.

Manual updates: feasible for tiny teams, but not production, not scalable, and usually wrong on exams when compared with ML/automation options.

Exam shortcut: Options including “static text”, “manual monthly updates”, or “historical visuals only” are almost always incorrect if the question asks for suggestions/recommendations/next actions.

When to use forward-looking suggestions vs historical-only
Use forward-looking (predictive/prescriptive) when: the question mentions recommend, suggest, next best action, optimize, forecast.

Use historical-only (descriptive/diagnostic) when: the question asks report, summarize, view past trends, explain reasons.

Be strict: “suggest” = prescriptive → prefers an ML-based, automated approach in DP-600 questions.

Question (demo): You need to add a feature to a Power BI report that suggests targeted marketing actions based on customer segment performance. Which technique integrates prescriptive analytics effectively?
Options:

A. Embedding an Azure Machine Learning model within the report to analyze segments and suggest actions.
B. Using static text boxes to provide generic marketing advice.
C. Manually updating the report each month with new recommendations.
D. Relying solely on historical data visualizations without forward-looking suggestions.

Step 1 — identify keywords: “suggests targeted marketing actions” → suggest = prescriptive; “targeted” = personalization; “based on performance” = data-driven.

Step 2 — map to analytics type: That’s prescriptive (what action to take).

Step 3 — choose solution: Only A (embedding Azure ML) supplies automated, personalized, data-driven recommendations.

Why others wrong: B is static; C is manual and not scalable; D is descriptive only.

Answer: A. Embedding an Azure ML model.

Exam tip: Always ask yourself “does this option produce an actionable output per user/segment that changes dynamically?” If yes — ML/endpoint/automation is right.

“What happened?” → Descriptive
“Why did it happen?” → Diagnostic
“What will happen?” → Predictive
“What should we do?” → Prescriptive

If question asks for recommendations / next best action / optimization, pick options mentioning ML / AutoML / Azure ML / optimization / recommendation engine.

If an option includes static text, manual process, monthly update, it’s almost always wrong for predictive/prescriptive needs.

For diagnostic questions, favor Key Influencers or Decomposition Tree.

For predictive questions, favor AutoML / time-series forecasting / classification/regression.

*Implementation mapping * — common patterns you should know

Churn management: Predictive model → score customers → map to “Offer discount / Call / No action”.
Recommendation engine (retail): Collaborative filtering or content-based recommenders → store top N recommendations per user → display in Power BI.
Inventory optimization: Forecast demand (time series) → run optimization for reorder quantities → provide reordering actions.
Predictive maintenance: Predict failure probability → if > threshold → schedule maintenance action.
Fraud detection: Predict risk per transaction → rules map to block / monitor / allow.

⭐ What is "Embedding an Azure Machine Learning Model"?

Embedding means connecting Power BI to a deployed Azure ML model so it can:

Score data
Predict outcomes
Output recommended actions
Generate prescriptive insights

How it works (simple flow):

Build ML model
Deploy it as a web service (API endpoint)
Call that model from Power BI
The model outputs a recommendation like:

“Recommend Email Campaign B for Customer X”
“Upsell Product Y to Segment Z”

This is dynamic, scalable, and automated.

⭐ What is a "Static Text Box"?

A static text box is simply text typed manually inside a Power BI report.

Example texts:

“Increase marketing spend”
“Improve engagement”

❌ It is not connected to data
❌ It cannot change dynamically
❌ It is not analytics

Used only for:

titles
explanations
notes
labels

Never used for prescriptive analytics.

⭐ What is "Manual Updating"?

You manually type new recommendations every month like:

“This month focus on Segment B”

Problems:

not scalable
error-prone
slow
not data-driven
changes do not react to real-time data

❌ This is not analytics
❌ Completely ignored in AI/ML questions

Only useful for:

temporary reports
low-impact dashboards
small teams

Exam trick:
Manual work is always the WRONG answer in DP-600 for anything AI/ML/autonomous.

⭐ When do we need "Forward-Looking Suggestions"?

Forward-looking = predictive + prescriptive

Used when:

you must take action
business impact depends on future outcome
you want to optimize decisions

Examples:

churn prevention
retention strategies
budget optimization
marketing targeting
fraud prevention

Exam Tip
If question says:

“suggest”
“action”
“recommend”
“next best step”
“optimize”

➡️ Answer is ALWAYS ML model.

⭐ When do we rely only on historical data?

When the question focuses on:

understanding past performance
monitoring KPIs
root cause analysis
business reporting

Not for making decisions.

Historical-only = descriptive or diagnostic

Exam clue:
If options contain things like “historical only,” it will ALWAYS be the wrong answer for prescriptive/predictive scenarios.

🔥 PART 2 — Question Breakdown (Step by Step)

❓ Original Question

You need a feature that suggests targeted marketing actions based on customer segment performance.

Step 1 — Identify keywords

🟩 “suggests actions” → prescriptive
🟩 “marketing actions” → decision-making
🟩 “based on segment performance” → ML/AI scoring

➡️ So the correct option must include:

ML model
automated recommendations
dynamic logic

🔥 OPTION-BY-OPTION BREAKDOWN

A. Embedding an Azure Machine Learning model

✔️ ML Model → Dynamic
✔️ Can generate recommendations
✔️ Prescriptive
✔️ Auto decision-making
✔️ Scalable
➡️ Correct

B. Using static text boxes

❌ Not data-driven
❌ Not dynamic
❌ Only generic advice
❌ Cannot target segments
➡️ Wrong

C. Manually updating the report

❌ Not scalable
❌ Not analytics
❌ Prone to errors
❌ Exam always rejects manual work
➡️ Wrong

D. Relying solely on historical data

❌ Only descriptive/diagnostic
❌ No suggestion capability
❌ No future insight
➡️ Wrong

⭐ Tips & Tricks for DP-600 MCQs (VERY IMPORTANT)

Here is the cheat sheet to instantly identify correct answers:

✔️ If question mentions recommendations, answer = ML model

Keywords:

next best action
suggest
recommend
optimize
prescriptive

✔️ If question mentions future, answer = AutoML, ML, forecasting

Keywords:

prediction
forecast
future trend
probability

✔️ If question mentions understanding the past, answer = visuals

Keywords:

historical
summarize
monitor
trend analysis

✔️ If option contains manual, static, text box, it's ALWAYS wrong

🔥 PART 3 — Notes (Documentation Style, Clear Examples)

📘 Prescriptive Analytics in Fabric / Power BI

Prescriptive analytics uses machine learning or decision algorithms to recommend actions.

Tools Used:

Azure ML models
Fabric ML models
AutoML
Python/R notebooks
ML scoring in dataflows

Example:

Dataset: Customer segments
Model Output:

Segment A → Recommend email offer
Segment B → Recommend discount
Segment C → No action

Power BI shows recommendation column dynamically.

🔥 PART 4 — 10 Similar Questions (With Answers + Explanations)

Q1

You want Power BI to select the best offer for each customer. How do you implement this?

A. Use an Azure ML recommendation model
B. Add a table showing purchase history
C. Write static text suggestions
D. Update the report manually each week

Answer: A

Q2

You need a feature that tells sales teams whom to call first based on predicted closing probability.

A. Deploy a predictive model with scoring rules
B. Use a bar chart by region
C. Place a slicer for sales rep
D. Show the last quarter’s performance

Answer: A

Q3

You want to reduce churn by recommending retention actions.

A. Build a churn ML model + action mapping
B. Show all historical churn in a chart
C. Add commentary in a static textbox
D. Update recommendations manually

Answer: A

Q4

A report must decide whether to reorder inventory based on predicted demand.

A. Use a demand forecasting model
B. Show a line chart of stock
C. Add a table with past orders
D. Provide generic reorder advice

Answer: A

Q5

Marketing wants a "next best campaign" suggestion dashboard.

A. Integrate an ML model that outputs recommended campaigns
B. Use a KPI visual
C. Display last year engagement
D. Add comments explaining campaign types

Answer: A

Q6

You want insights on why sales dropped last quarter.

A. Use decomposition tree (diagnostic)
B. Use ML recommendation model
C. Add manual comments
D. Use a line chart only

Answer: A

Q7

You need a fully automated system that suggests actions daily.

A. ML model + automation
B. Static text updated monthly
C. Manual tags
D. Historical-only dashboards

Answer: A

Q8

Which feature predicts future sales?

A. AutoML or forecasting
B. Static text
C. Manual trend writing
D. Card visual

Answer: A

Q9

Which is NOT prescriptive analytics?

A. Optimization model
B. Next best action
C. Static business advice in text box
D. Recommendation engine

Answer: C

Q10

Which delivers dynamic insights?

A. ML model
B. Static text
C. Manual report editing
D. Hard-coded comments

Answer: A

Question 1 of 10

You need to add a feature to a Power BI report that recommends the best retention action for customers predicted to churn. Which method implements prescriptive analytics correctly?

A. Integrating an Azure ML churn model that outputs recommended actions for each customer.
B. Adding a static text box with general retention advice.
C. Showing a historical churn trend without predictions.
D. Updating the report manually every month with retention suggestions.

✅ Correct Answer: A. Integrating an Azure ML churn model that outputs recommended actions for each customer.

This implements prescriptive analytics because the ML model can predict who is likely to churn and then recommend specific actions (e.g., discount, call, email). It is automated, data-driven, and scalable.

❌ B. Static text box

Static text is generic and NOT connected to data. It cannot provide personalized retention advice → NOT prescriptive.

❌ C. Historical trend

Historical churn charts are descriptive, not prescriptive. They explain the past but cannot suggest actions.

❌ D. Manual updates

Manual work is not scalable, prone to errors, and NOT analytics-driven.

Question 2 of 10

A sales dashboard must suggest which leads the team should prioritize each day. Which approach delivers true prescriptive analytics?

A. Using an ML scoring model to rank leads by probability of closing.
B. Showing a line chart of last month’s sales.
C. Adding a generic “Follow up with leads” text box.
D. Having analysts manually rank leads weekly.

✅ Correct Answer: A. Using an ML scoring model to rank leads.

ML scoring dynamically identifies high-value leads and automates prioritization → prescriptive.

❌ B. Historical chart

Only descriptive, no decision-making.

❌ C. Generic text advice

Not personalized, not dynamic.

❌ D. Manual ranking

Not scalable, not data-driven.

Question 3 of 10

A retail analytics report should recommend whether each product should be reordered or discontinued based on demand forecasts. What should you implement?

A. A demand forecasting ML model that outputs a recommended stock action.
B. A table that lists last year’s product sales.
C. A static note saying “Monitor inventory frequently.”
D. Monthly manual updates from supply chain staff.

✅ Correct Answer: A. Demand forecasting ML model

It provides future prediction + recommended action, which is exactly prescriptive analytics.

❌ B

Only historical → descriptive.

❌ C

Static → no analytics.

❌ D

Manual → not scalable, not intelligent.

Question 4 of 10

You want Power BI to automatically decide the best promotional offer for each customer segment. Which solution is correct?

A. Deploying a recommendation ML model and integrating it into the report.
B. Adding a bar chart showing which promotions performed best last year.
C. Writing generic promotional tips in a text box.
D. Updating the promotion recommendations manually.

✅ Correct: A

This uses ML to determine the best action, which is the core of prescriptive analytics.

❌ B

Descriptive only.

❌ C

Static & not dynamic.

❌ D

Manual → wrong for DP-600.

Question 5 of 10

A financial analytics report must advise departments on how to reduce expenses. How should this be implemented?

A. Using an ML optimization model that outputs recommended cost-saving actions.
B. Displaying historical spending trends.
C. Adding a static text box with general budgeting tips.
D. Manually adding cost-saving suggestions each quarter.

✅ Correct: A

Optimization models + ML = true prescriptive analytics.

❌ B

Only describes past spending.

❌ C

Static → no intelligence.

❌ D

Manual → not scalable.

Question 6 of 10

Your customer engagement dashboard must recommend the “next best action” for users with low engagement. What method should be used?

A. Build and integrate a next-best-action ML model.
B. Show a table of users with their engagement score.
C. Add a text box describing how to improve engagement.
D. Let analysts manually email suggestions to teams weekly.

✅ Correct: A

Prescriptive analytics = ML-based recommendations.

❌ B

Descriptive.

❌ C

Static generic advice.

❌ D

Manual process → wrong.

Question 7 of 10

A manufacturing report must suggest machine maintenance actions before a failure occurs. Which approach is correct?

A. Use a predictive maintenance model connected to Power BI to suggest preventive actions.
B. Show last month’s machine downtime data.
C. Use a static text explaining maintenance guidelines.
D. Rely on manual monthly updates from technicians.

✅ Correct: A

This is prescriptive: prediction → recommended action.

❌ B

Historical only.

❌ C

Static text.

❌ D

Manual → not prescriptive.

Question 8 of 10

A subscription business wants the report to recommend actions for customers predicted not to renew. What method should be used?

A. Use an ML renewal prediction model and map scores to recommended retention actions.
B. Add a chart showing renewal rates last year.
C. Write static renewal advice.
D. Update the file manually each month.

✅ Correct: A

Prediction + Action = prescriptive.

❌ B

Descriptive.

❌ C

Static.

❌ D

Not scalable.

Question 9 of 10

Your dashboard must automatically suggest the best discount for each product based on profitability and forecasted demand. Which solution is correct?

A. Integrate an ML model that calculates optimal discount levels.
B. Show last year’s discount performance.
C. Add a generic text box explaining discount strategies.
D. Let managers manually pick discount levels.

✅ Correct: A

ML-driven optimal action → prescriptive.

❌ B

Historical.

❌ C

Static.

❌ D

Manual → wrong.

Question 10 of 10

A Power BI report must recommend which suppliers to prioritize based on reliability predictions. What should be implemented?

A. An ML model that predicts supplier reliability and outputs recommended choices.
B. A matrix of historical supplier performance.
C. A text box summarizing procurement guidelines.
D. Manual supplier ranking updated monthly.

✅ Correct: A

Predict → recommend → prescriptive.

❌ B

Descriptive only.

❌ C

Static info.

❌ D

Manual = always wrong for prescriptive questions.

🔐 Understanding Governance in Microsoft Fabric

Sajjad Rahman — Tue, 02 Dec 2025 05:08:33 +0000

Governance is one of those terms that often sounds heavy—something meant only for administrators, auditors, or compliance teams.
But in reality, governance is the backbone of every modern data system, and developers interact with it more than they realize.

In Microsoft Fabric, governance ensures that your OneLake data ecosystem remains secure, organized, and usable for every team—without slowing down development velocity.

This article breaks down governance in the simplest way possible, using both real-world analogies and Fabric-centric explanations.

🔐 What Is Governance?

At its core:

Governance = Rules + Control + Responsible Operations

It refers to the processes, rules, and controls that ensure data, systems, and organizational workflows operate securely and correctly.

Governance guarantees that:

Data is protected
Access is controlled
Quality is maintained
Usage is monitored
Systems behave as intended

It is not about restricting people—
👉 It is about creating a disciplined ecosystem where everything works smoothly and safely.

🎒 A Simple Story: School as a Governance System

Imagine a well-managed school.

The school defines:

Class schedules
Teacher responsibilities
Seating arrangements
Exam policies
Behavior rules

Every student and teacher follows these rules.
This organized structure ensures the school operates smoothly.

That entire rule-based management process is Governance.

Similarly, in Microsoft Fabric, governance ensures the data environment operates with clarity, control, and accountability.

🧊 A Real-World Analogy Developers Love:

Your Family Refrigerator = OneLake Governance

Let’s picture your household refrigerator as your OneLake storage.

❌ Without governance:

Anyone takes anything without permission
No one tracks what’s added
Items expire silently
Duplicate items waste space
No clarity about what belongs to whom

Result?
👉 Chaos, confusion, and inefficiency.

✔ With governance:

The family sets simple rules:

Who can take what
Kids cannot take medicine → Permissions
Date labels on items
You know what’s fresh → Metadata & Sensitivity
Shelves are organized by category
Top shelf for vegetables, lower shelf for fruits → Data organization
Expired food is removed
→ Quality control
Everyone knows who added what
→ Activity logs & tracking
The fridge is cleaned regularly
→ Policy enforcement & maintenance

This simple set of rules creates order.
👉 And this is exactly how governance brings structure to OneLake in Microsoft Fabric.

🏗 Governance in Microsoft Fabric: What It Actually Means

Microsoft Fabric embeds governance across its entire data lifecycle—collection, storage, analysis, sharing, and monitoring.

Key responsibilities include:

✔ Access & Permissions

Who can view, edit, share, or delete data.

✔ Sensitivity Labels

Identifying how confidential a dataset is.

✔ Metadata Management

Tracking data origin, owner, schema, and update history.

✔ Data Quality & Refresh Policies

Ensuring data stays accurate and up to date.

✔ Audit Logs & Monitoring

Recording every action—who accessed what, when, and how.

✔ Policy Enforcement

Applying organizational rules consistently.

Fabric’s governance flows through:

OneLake
Admin Portal
OneLake Catalog
Fabric Governance APIs and SDKs

Together, they create a unified, centrally managed data environment.

📘 Mapping the Fridge Analogy to Fabric

Household Fridge Concept	Fabric Feature
Who can take items	Access Control / Permissions
Date labels	Metadata & Sensitivity Labels
Shelves organized	OneLake Data Layout
Checking expiration	Data Quality & Refresh
Who added items	Audit Logs
Regular cleaning	Governance Policy Enforcement

This analogy helps teams visualize how everyday rules translate into technical governance rules.

🧭 The Simplest One-Line Definition

Governance is the disciplined process of securing, organizing, and responsibly managing your data and systems.

In Fabric, this ensures:

Data remains trustworthy
Users remain accountable
Workflows remain controlled
The entire platform remains future-proof

Core Microsoft Fabric Concepts

Sajjad Rahman — Sat, 29 Nov 2025 06:59:28 +0000

Core Microsoft Fabric Concepts

1. Tenant

A Fabric tenant is a dedicated, organization-wide container provided by Microsoft Fabric.
It is the highest-level structure in the Microsoft Fabric hierarchy. A tenant is tied directly to Microsoft Entra ID (formerly Azure Active Directory), meaning all authentication, user identities, groups, and permissions are managed through Entra.

Key characteristics:

An organization normally has a single tenant, under which all Fabric resources exist.
The Fabric tenant maps to the root of OneLake.
- This means all data stored in the organization’s Fabric environment ultimately resides in a unified OneLake namespace.
The tenant is responsible for hosting and managing all Fabric items, capacities, domains, and workspaces.
It provides a boundary for:
- Security
- Governance
- Data residency
- Licensing
- Administrative control

The tenant sits at the top of the entire Fabric hierarchical structure, controlling how resources are managed for the whole enterprise.

2. Capacity

A capacity in Microsoft Fabric is a dedicated set of compute and storage resources available for use at any given time.
These resources are what allow organizations to run workloads such as:

Data pipelines
SQL queries
Notebooks
Semantic model refreshes
Real-time analytics

Important details:

A tenant may have one or multiple capacities assigned.
Capacity determines how many and how large the workloads can be performed simultaneously.
Each workload consumes a certain portion of capacity depending on its complexity.
Capacity is governed by SKUs (pricing tiers) offered by Microsoft, each with its own limits.
During peak loads, if capacity is exhausted, tasks may slow down or queue.
Capacity defines the ability of Fabric to:
- Run models
- Process data
- Refresh reports
- Produce output like dashboards and datasets

Fabric also supports trial capacities, enabling organizations to explore capabilities before committing to a paid tier.

3. Domain

A domain is a logical grouping of workspaces that helps organizations structure their content according to functional or business needs.
Domains provide an organizational layer that makes it easier to manage access, governance, and ownership.

Detailed characteristics:

Domains help categorize workspaces in ways that align with how teams work.
They make it easier to ensure the right people have the correct access.
Governance rules (policies, permissions, lifecycle management) can be applied at the domain level.
Domains can be created based on:
- Business departments (e.g., Sales, Finance, HR)
- Organizational divisions
- Geographical regions
- Strategic initiatives

Example:

A company may have:
- A Sales domain for sales analytics
- Marketing domain for campaign performance
- Finance domain for budgeting and forecasting

Domains essentially help structure workspaces in a way that is manageable and scalable.

4. Workspace

A workspace is a collection of items (datasets, pipelines, notebooks, models, etc.) brought together within a single tenant.
It acts as a management container where users collaborate on related projects.

More detailed explanation:

Workspaces are the primary environment where users create, store, and manage Fabric items.
They leverage the capacity assigned to them when users run workloads.
Workspaces provide role-based access control, defining which users can:
- Edit
- View
- Manage
- Share
They provide isolation and organization for independent teams or projects.
Workspaces support different types of items, such as:
- Data warehouses
- Lakehouses
- Data pipelines
- Semantic models
- Reports
- Notebooks
- Dashboards

Example use-case:

A workspace for the Sales Team might include:
- A data warehouse containing sales transaction data
- Notebooks for data exploration
- Pipelines to ingest CRM data
- Semantic models for BI reporting
- Power BI reports for leadership

Each workspace becomes a productive environment that groups all relevant assets for a specific business function.

5. Fabric Items

Fabric items are the building blocks of the Microsoft Fabric platform.
They are the individual assets or objects that users can create and manage within Fabric workspaces.

Examples of Fabric items include:

Data warehouses: enterprise-level SQL warehouses
Lakehouses: storage for big data and unstructured/structured files
Pipelines: data ingestion, ETL, orchestration
Semantic models: models used for analytics and reporting
Reports: Power BI visualizations
Notebooks: code-based data exploration (Python, Spark, etc.)
Real-time analytics items: KQL databases, event streams
ML models: Machine learning models

In short, each Fabric item represents a functional component of the analytics and data engineering ecosystem.

6. Why Understanding These Concepts Matters

Understanding tenant, capacity, domain, workspace, and Fabric items is essential because:

It enables effective governance and secure data management.
It helps admins allocate capacities and manage workloads efficiently.
It clarifies how data flows and how resources are organized.
It enables proper access control across teams.
It ensures successful architecture planning and deployment of analytics solutions.

💡 Power BI Storage Mode — সহজ বাংলায় পূর্ণ ধারণা

Sajjad Rahman — Thu, 06 Nov 2025 09:21:59 +0000

Power BI নিয়ে কাজ করতে গেলে আমরা প্রায়ই একটা প্রশ্ন শুনি —
👉 “ডেটা Power BI তে কোথায় থাকে?”
👉 “Import, DirectQuery, Dual — এগুলোর মানে কী?”

আজ আমরা একদম সহজভাবে বুঝে নেবো Power BI-এর Storage Mode আসলে কী, আর কখন কোনটা ব্যবহার করা উচিত।

🧠 Power BI Storage Mode কী?

Storage Mode মানে হচ্ছে — Power BI তোমার ডেটা কোথায় রাখবে এবং কীভাবে সেই ডেটা ব্যবহার করবে। Power BI তিনভাবে ডেটা হ্যান্ডেল করতে পারে 👇

1️⃣ Import Mode
2️⃣ DirectQuery Mode
3️⃣ Dual (Composite) Mode

1️⃣ Import Mode – সবচেয়ে সাধারণ পদ্ধতি

এই মোডে Power BI তোমার ডেটার একটা কপি নিয়ে নিজের ভেতরে সেভ করে রাখে।
মানে — ডেটা Power BI ফাইলের ভেতরেই সংরক্ষিত হয়।

🔹 সুবিধা

দ্রুত কাজ করে, কারণ ডেটা আগে থেকেই লোড করা থাকে।
অফলাইনে কাজ করা যায়।
Refresh Schedule দিয়ে সময়মতো আপডেট করা যায়।

🔹 অসুবিধা

প্রতিবার নতুন ডেটা দেখতে চাইলে Refresh দিতে হয়।

📘 উদাহরণ:
তুমি Excel বা SQL থেকে ডেটা Import করলে Power BI সেই ডেটার একটা কপি নিজের ফাইলে রেখে দেয়।

2️⃣ DirectQuery Mode – লাইভ ডেটার জন্য

এই মোডে Power BI কোনো কপি রাখে না।
প্রতিবার তুমি যখন রিপোর্ট চালাও, Power BI সরাসরি সার্ভারে গিয়ে ডেটা টেনে আনে।

🔹 সুবিধা

সবসময় সর্বশেষ (Live) ডেটা দেখা যায়।
কোনো ডেটা লোকালি সেভ হয় না, তাই সিকিউরিটি ভালো।
বড় ডেটাবেস (যেমন SQL Server, Fabric, PostgreSQL) এর জন্য উপযুক্ত।

🔹 অসুবিধা

রিপোর্ট একটু ধীরে চলে, কারণ প্রতিবার সার্ভার থেকে ডেটা আনতে হয়।

📘 উদাহরণ:
তুমি যদি Sales ডাটাবেসে সংযুক্ত হয়ে রিপোর্ট বানাও এবং চাও রিপোর্টে লাইভ ডেটা দেখাতে — তাহলে DirectQuery ব্যবহার করবে।

3️⃣ Dual (Composite) Mode – দুই জগতের মিশ্রণ

এই মোডে কিছু টেবিল Import করা হয়, আর কিছু টেবিল DirectQuery থাকে।
Power BI নিজে ঠিক করে কোন ডেটা লোকাল থেকে নেবে, কোনটা সার্ভার থেকে।

🔹 সুবিধা

পারফরম্যান্স ভালো থাকে।
লাইভ ও লোকাল ডেটা দুইই ব্যবহার করা যায়।

🔹 অসুবিধা

কনফিগার করা একটু জটিল হতে পারে।

📘 উদাহরণ:
তুমি “Customer Info” টেবিলটা Import করে রেখেছো (ছোট ডেটা),
আর “Sales Transactions” টেবিলটা DirectQuery তে রেখেছো (বড় ডেটা)।

⚙️ কোথায় পাওয়া যাবে এই অপশন?

Power BI Desktop-এ →
Model View → কোনো টেবিল সিলেক্ট করো → Properties Pane → Storage Mode

সেখানে তুমি Import, DirectQuery, বা Dual থেকে যেকোনোটা বেছে নিতে পারবে।

🧾 সারাংশ এক নজরে

Mode	কাজের ধরন	সুবিধা	অসুবিধা
Import	ডেটা Power BI তে কপি হয়	দ্রুত, অফলাইন কাজ চলে	সবসময় আপডেট না
DirectQuery	সার্ভার থেকে লাইভ ডেটা নেয়	রিয়েল-টাইম ডেটা, সিকিউর	একটু ধীরে চলে
Dual	Import + DirectQuery মিশ্রণ	ফ্লেক্সিবল, পারফরম্যান্স ভালো	সেটআপ জটিল

Reference: https://learn.microsoft.com/en-us/training/modules/get-data/7-azure-analysis-services?studentamb_289646

Join Fabric Data Days – Learn, Compete & Get Certified for FREE!

Sajjad Rahman — Wed, 05 Nov 2025 15:21:29 +0000

We all dream of achieving big things — leveling up our careers, getting certified, and proving our skills. But sometimes certifications are costly, and we have to keep waiting for discounts or vouchers. But not this time.

Right now, Microsoft Fabric is offering 100% FREE certification vouchers for DP-600 and DP-700 as part of Fabric Data Days. 🚀

This is your chance. Your moment. Nothing is stopping you now — except not taking the step. Make some time. Learn. Participate. And fulfill your dream of becoming certified — without paying anything.

This event includes:

✅ Live training sessions
✅ Student and professional Dataviz competitions
✅ Study groups & hands-on challenges
✅ Certification preparation sessions
✅ Opportunity to earn FREE Microsoft Fabric certification badges!

DP-600 (Fabric Analytics Engineer) – Focuses on building end-to-end analytics solutions in Microsoft Fabric.
DP-700 (Fabric Data Engineer) – Focuses on designing, building, and managing data pipelines and lakehouse environments in Fabric.

📅 Started November 4th
💻 Available On-Demand if you miss live sessions
🌍 Multiple languages (English, Portuguese, Spanish & more!)

⭐ Why You Should Join

Learn Microsoft Fabric from industry experts
Boost your resume with in-demand skills
Connect with a global data community
Access FREE exam preparation for DP-700 and DP-600
Show your talent in Dataviz contests 🏆

🔗 Register & Follow the Live Schedule:

VISIT FOR DP 600

DEV Community: Sajjad Rahman

📘 Master Note: The Hidden Mechanics of PCA & ICA

Part 1: The Big Picture (Intuition)

1. Whitening: The Essential Pre-step for ICA

2. SVD: The Practical Engine of PCA

Part 2: The Mathematical Engine

1. The Whitening Transformation

2. The SVD ↔ PCA Connection

Part 3: Performance & Comparisons

Why use SVD instead of Classical PCA?

🧠 Final Logic Map (Summary)

🔥 Quick Memory:

📘 The Science of Un-Mixing Data (PCA & ICA)

Part 1: The Math Toolbox (Prerequisites)

🔹 Basic Concepts

🔹 Statistical Concepts

Part 2: PCA (Principal Component Analysis)

The Goal

How it Works

Core Equation (Added)

Key Properties

Algorithm Steps (Added Section)

PCA Steps

Why PCA Can Fail (Added Section)

Part 3: ICA (Independent Component Analysis)

The Goal

How it Works

Core Equation (Added)

Key Concepts

Algorithm Steps (Added Section)

ICA Steps

Part 4: PCA vs ICA (Added Comparison Table)

Part 5: Why do we use these?

Stanford is Teaching the World to Code for Free!

Learn Python from Stanford ** 🚀

What Makes This Course Unique?

The Best Part? The Community!

Join the Movement!

Understanding cmd /c and cmd /k

First, understand this important point

What actually happens when you run cmd /k dir

What happens when you run cmd /c echo hello

Why this feels confusing

Simple rule to remember

Final takeaway

Windows CMD – File & Directory Management

1️⃣ Directory Basics (dir)

Show files and folders

2️⃣ Creating Files with echo

Create a file with text

Read file content

⚠ Why quotes appear?

3️⃣ Creating an Empty (Blank) File – IMPORTANT CONCEPT

Command used

❓ Why is 2 used here?

What actually happens?

Better & common methods

4️⃣ Deleting Files (del)

Check after deletion

5️⃣ Renaming Files (rename)

6️⃣ Creating & Moving Directories

Create directory

Move file into directory

Change directory

Go back

7️⃣ Path Symbols Explained

8️⃣ Copying Files (copy)

9️⃣ Removing Directories (rmdir) – VERY IMPORTANT

Delete empty directory

❌ If directory is NOT empty

✔ Correct way to delete directory with files

🔟 Comparing Files (fc)

Output meaning

1️⃣1️⃣ Symbolic Links (Soft Links) – mklink

Create symbolic link

Verify

1️⃣2️⃣ Searching Files with dir

Search specific file recursively

Search all .txt files

1️⃣3️⃣ Finding Files using forfiles

What actually happens when you run `cmd /k dir`

What happens when you run `cmd /c echo hello`

1️⃣ Directory Basics (`dir`)

2️⃣ Creating Files with `echo`

❓ Why is `2` used here?

4️⃣ Deleting Files (`del`)

5️⃣ Renaming Files (`rename`)

8️⃣ Copying Files (`copy`)

9️⃣ Removing Directories (`rmdir`) – VERY IMPORTANT

🔟 Comparing Files (`fc`)

1️⃣1️⃣ Symbolic Links (Soft Links) – `mklink`

1️⃣2️⃣ Searching Files with `dir`

Search all `.txt` files

1️⃣3️⃣ Finding Files using `forfiles`

1️⃣4️⃣ Finding Text Inside Files – `find`

1️⃣5️⃣ Advanced Text Search – `findstr` (Recommended)

Why `findstr` is better?

2️⃣ Changing Directories (`cd` Command)

3️⃣ Understanding Root Directory (`C:\`)

4️⃣ Listing Files & Folders (`dir` Command)

5️⃣ Showing Hidden Files (`dir /a`)

6️⃣ Windows Users Directory (`C:\Users`)

🔹 User Folder (`F C`)

8️⃣ System Information (`systeminfo`)

🔹 Example: `psinfo`