OneLake security data access role replication
This Python notebook provides a basic example for OneLake security data access roles replication between different environments. At the moment: OneLake security roles are only deployed through Fabric deployment pipelines, which only covers the roles defined, not the actual Entra ID user/group member assignments (just permission group assignments). On its latest version, fabric-cicd does not deploy OneLake security roles. How it works: Through the OneLake security REST APIs, we can take the existing role definition and assignments from a specific environment and replicate them to another entirely. The example relies on two specific methods: List Data Access Roles Create Or Update Data Access Roles This way, we can: Persist/modify the already assigned Entra ID users and/or groups to the existing roles from one lakehouse to another. Point the existing permission group assignments to the target (workspace + lakehouse). Credentials for the whole process are provided through NotebookUtils. ⚠️IMPORTANT The process, as it is, overwrites the existing roles and assignments at the target with the source's configuration. Any roles and/or assignments non declared at the source will be deleted. The identity running the process must have at least the Member role in the referenced workspaces. When running under a service principal, token management could require some adjustments, specially if the code does not run inside Fabric. You can find the notebook here, feel free to adapt the code as needed. For example, once tweaked, it could be used as an step inside an ADO/GitHub pipeline and deploy the existing OneLake roles defined over each lakehouse while replicating the roles established and updating the user/group assignments depending on the deployment environment, complementing fabric-cicd deployments. Another possible implementation can be done with Terraform. If interested in managing Fabric with Terraform, you can take a look at my GitHub repo. Hope you find it useful!
Semantic Link – Dataflow Gen1 to Gen2 Migration Assistant
Semantic Link – Dataflow Gen1 to Gen2 Migration Assistant is a reusable Fabric Notebook that helps developers safely modernize Power BI semantic models by detecting Dataflow Gen1 sources, mapping them to Dataflow Gen2 equivalents, updating the model BIM, creating a backup, rebinding the correct Fabric connection, refreshing the model, and validating the result. The tool follows a dry-run-first workflow to reduce manual edits, credential mistakes, and migration risk. Link Repooooooo!!: https://github.com/vicente2121/ChallengeSemantiklabs.git https%3A%2F%2Fgithub.com%2Fvicente2121%2FChallengeSemantiklabs%2Fblob%2Fac67250f4044e0db6d63b87a2fd84b36913e5089%2FSemantic%2520Link%2520%25E2%2580%2593%2520Dataflow%2520Gen1%2520to%2520Gen2%2520Migration%2520Assistant.ipynb
Semantic Link - Power BI Fixer
🔧 Power BI Fixer — The All-in-One Development Environment for Power BI in Fabric Author: Alexander Korn · Solution Engineer Data Platform @ Microsoft Repository: github.com/KornAlexander/semantic-link-labs (branch: feature/pbi-fixer-ui) Website: actionablereporting.com/pbi-fixer Built on: Semantic Link Labs by Michael Kovalsky 📋 Abstract The Power BI Fixer is an interactive development environment that runs natively inside Microsoft Fabric Notebooks. It combines Semantic Link, ipywidgets, and TOM (Tabular Object Model) to provide a comprehensive tool for scanning, exploring, fixing, and documenting Power BI reports and semantic models — all from a single notebook cell. The Problem It Solves Power BI developers face a fragmented workflow: Report issues (pie charts, missing data labels, page sizes) require manual visual-by-visual fixes in Power BI Desktop Model best practices (missing descriptions, floating point types, foreign key visibility) need Tabular Editor or manual scripting No single tool lets you scan a report AND its underlying model, see the results side-by-side, and fix everything in one workflow PBIR format adoption is slow because upgrade tooling is scattered The PBI Fixer addresses all of these by providing 12+ interactive tabs, 17 report fixers, 25+ semantic model fixers, and a unified scan-and-fix workflow — running entirely in a Fabric Notebook. ~17,000 lines of new Python code across 5 UI & tab modules (9,439 lines — incl. Fix All, Model Explorer, Report Explorer, Prototype, Translations, Model Diagram, About), 15 report fixers (3,038 lines), 4 report helpers (593 lines), and 33 semantic model fixers (3,797 lines) — all written from scratch for this project. 🎬 Demo Video Watch the full walkthrough: Power BI Fixer v2 Demo on YouTube https%3A%2F%2Fgithub.com%2FKornAlexander%2Fpbi_fixer%2Fblob%2Fmain%2F2026_SemanticLink_AlexanderKorn_PowerBIFixer.ipynbPower BI Access Audit
Have you ever tried to see who has access across your workspaces or datasets? Which rights do those people have? If you are taking care of multiple workspaces this can be tricky. Luckily, you can now follow me through this article, where I am going to explain how to get data for this "PBI Access Audit" easily with Notebooks. My notebook is based on PBI REST API, which is known for years. Unfortunately, it has not been that easy to use it without cloud services like Azure portal and resources like Azure Functions, Azure App, Azure Blob Storage etc. Now we can take advantage of all the ingredients in MS Fabric. Use case? As I mentioned earlier, we would like to know some basic understanding of "Who?" and "Where" has someone access. I will focus basically on MS Fabric Workspaces and Semantic Models, in theory we could get deep dive analysis on all Fabric items, but then this article would be 10x longer and I would repeat myself. Who is it for? For everybody who needs to maintain and keep an eye on workspace(s) and its data. It is especially helpful if you are doing administrator of a capacity, but you are not an Admin for the entire MS Fabric tenant. Why not tenant Admin? Admins can run very specific and powerful REST APIs, while others are limited and need to use solution such as the one I am going to explain. Prerequisites? 1. You should have access to at least one Microsoft Workspace with right to create and run notebooks. 2. You should have access to at least one Fabric Lakehouse with write permission. Let's start Open new Microsoft Notebook and connect your Fabric Lakehouse. In my case I am working with a LH called apiREST: Once you are connected, create a new code section. I personally created multiple sections for better readability, but you can merge it together - outcome will be the same. 1. Importing all crucial modules This will ensure that all pieces of code will run smoothly. import sempy.fabric as fabric import pandas as pd from pyspark.sql import SparkSession from pyspark.sql.types import StructType, StructField, StringType from pyspark.sql.functions import current_date, lit #Instantiate the client client = fabric.FabricRestClient() 2. Getting WORKSPACES It is crucial to get workspaces first, because we use IDs later. Be careful, that workspace id is the same as group id (based on Microsoft documentation). # Make API call url_workspace = "https://api.powerbi.com/v1.0/myorg/groups" response = client.get(url_workspace) # Normalize JSON response_workspaces = pd.json_normalize(response.json()['value']) # Define schema schema_workspaces = StructType([ StructField("id", StringType(), True), StructField("name", StringType(), True), StructField("isReadOnly", StringType(), True), StructField("isOnDedicatedCapacity", StringType(), True) ]) # Create Spark DataFrame df_workspaces = spark.createDataFrame(response_workspaces[["id", "name" , "isReadOnly", "isOnDedicatedCapacity"]], schema=schema_workspaces) display(df_workspaces) # Collect group IDs into a list group_ids = [row.id for row in df_workspaces.collect()] 3. Getting WORKSPACE USERS At this moment we are going to loop through all workspaces and get all users with their permissions. ############################################# # Defying function workspaces_users_api def workspaces_users_api(group_id): # Make API call url_group_users = f"https://api.powerbi.com/v1.0/myorg/groups/{group_id}/users" response_group_users = client.get(url_group_users) # Normalize JSON response_group_users = pd.json_normalize(response_group_users.json()['value']) # Define schema schema_workspaces_users = StructType( [StructField("displayName", StringType(), True), StructField("emailAddress", StringType(), True), StructField("groupUserAccessRight",StringType(), True), StructField("identifier", StringType(), True), StructField("principalType", StringType(), True)]) # Create Spark DataFrame df_group_users = spark.createDataFrame(response_group_users[["displayName", "emailAddress" , "groupUserAccessRight", "identifier", "principalType"]], schema=schema_workspaces_users) # Add additional columns to DataFrame df_group_users = df_group_users.withColumn("group_id", lit(group_id)) df_group_users = df_group_users.withColumn("todaysDate", current_date()) return df_group_users ############################################# # Iterate through group IDs and fetch WORKSPACE USERS combined_workspaces_users_df = None for group_id in group_ids: df_workspaces_users = workspaces_users_api(group_id) if df_workspaces_users: if combined_workspaces_users_df is None: combined_workspaces_users_df = df_workspaces_users # First DataFrame else: combined_workspaces_users_df = combined_workspaces_users_df.union(df_workspaces_users) # Append to the combined DataFrame # Display the combined DataFrame display(combined_workspaces_users_df) 4. Getting DATASETS In case we want to see access to individual semantic models, we need to get first list of those semantic models. Be aware, that dataset id is the same as semantic model id (based on Microsoft documentation). ############################################# # Defying function datasets_api def datasets_api(group_id): # Define expected columns expected_cols = ["id", "name", "createdDate", "configuredBy", "webUrl"] # Make API call with error handling url_datasets = f"https://api.powerbi.com/v1.0/myorg/groups/{group_id}/datasets" try: response_url_datasets = client.get(url_datasets) response_url_datasets.raise_for_status() # Raises HTTPError for bad responses except Exception as e: print(f"Error fetching datasets for group {group_id}: {e}") return None # Parse and clean response raw_data = response_url_datasets.json().get('value', []) cleaned_data = [item for item in raw_data if isinstance(item, dict) and item] if not cleaned_data: print(f"No valid datasets found for group {group_id}") return None # Normalize JSON response_datasets = pd.json_normalize(cleaned_data) # Define schema dynamically schema_datasets = StructType([StructField(col, StringType(), True) for col in expected_cols]) # Select only available columns available_cols = [col for col in expected_cols if col in response_datasets.columns] df_datasets = spark.createDataFrame(response_datasets[available_cols], schema=schema_datasets) # Add additional columns df_datasets = df_datasets.withColumn("group_id", lit(group_id)) df_datasets = df_datasets.withColumn("todaysDate", current_date()) return df_datasets ############################################# # Iterate through group IDs and fetch DATASETS combined_datasets_df = None for group_id in group_ids: df_datasets = datasets_api(group_id) if df_datasets: if combined_datasets_df is None: combined_datasets_df = df_datasets # First DataFrame else: combined_datasets_df = combined_datasets_df.union(df_datasets) # Append to the combined DataFrame # Display the combined DataFrame display(combined_datasets_df) # Extract group Dataset IDs as a list dataset_ids = [row.id for row in combined_datasets_df.collect()] 5. Getting DATASET USERS Finally we can get the final info about the people who have access to Semantic Models. Access to Semantic Models usually reflect access to PBI Reports as well (which is difficult to get without tenant admin rights). ############################################# # Defying dataset_users_api def dataset_users_api(group_id, dataset_id): # Define expected columns expected_cols = ["identifier", "datasetUserAccessRight", "principalType", "groupId", "datasetId"] # Make API call with error handling url_users = f"https://api.powerbi.com/v1.0/myorg/groups/{group_id}/datasets/{dataset_id}/users" try: response = client.get(url_users) response.raise_for_status() except Exception as e: print(f"Error fetching users for dataset {dataset_id} in group {group_id}: {e}") return None # Parse and clean response raw_data = response.json().get('value', []) cleaned_data = [item for item in raw_data if isinstance(item, dict) and item] if not cleaned_data: print(f"No valid users found for dataset {dataset_id} in group {group_id}") return None # Normalize JSON response_users = pd.json_normalize(cleaned_data) # Ensure metadata columns exist for col in ["groupId", "datasetId"]: if col not in response_users.columns: response_users[col] = None response_users["groupId"] = group_id response_users["datasetId"] = dataset_id # Define schema dynamically schema_users = StructType([StructField(col, StringType(), True) for col in expected_cols]) # Select only available columns available_cols = [col for col in expected_cols if col in response_users.columns] df_users = spark.createDataFrame(response_users[available_cols], schema=schema_users) # Add additional columns df_users = df_users.withColumn("todaysDate", current_date()) return df_users combined_users_df = None for group_id in group_ids: df_datasets = datasets_api(group_id) if df_datasets: dataset_ids = [row.id for row in df_datasets.collect()] for dataset_id in dataset_ids: df_users = dataset_users_api(group_id, dataset_id) if df_users: if combined_users_df is None: combined_users_df = df_users else: combined_users_df = combined_users_df.union(df_users) display(combined_users_df) 6. Creating Delta Tables Right now we have all data we need. We only need to store them in our Lakehouse. #Saving df_workspaces delta_table_path = "Tables/WorkspacesAPI" #fill in your delta table path df_workspaces.write.format("delta").mode("append").option("mergeSchema", "true").save(delta_table_path) #Saving df_workspaces_users delta_table_path = "Tables/WorkspacesUsersAPI" #fill in your delta table path combined_workspaces_users_df.write.format("delta").mode("append").option("mergeSchema", "true").save(delta_table_path) #Saving combined_datasets_df delta_table_path = "Tables/DatasetsAPI" #fill in your delta table path combined_datasets_df.write.format("delta").mode("append").option("mergeSchema", "true").save(delta_table_path) #Saving combined_datasets_df delta_table_path = "Tables/DatasetsUsersAPI" #fill in your delta table path combined_users_df.write.format("delta").mode("append").option("mergeSchema", "true").save(delta_table_path) If everything goes well, you should refresh your lakehouse and see new data tables with your data. At this moment you can easily create your Semantic Model with Delta Tables and connect your Power BI report. Model should be very easy and rather small. Final words My example is very simple but can be used for much more. Just check the REST API documentation and you can adjust my code for other purposes. https%3A%2F%2Fgithub.com%2FMigasuke%2FPBI-Access-Audit%2Fedit%2Fmain%2FAudit%2520File
Delta Lake Property Enforcer
DeltaPropEnforcer is a production-oriented Microsoft Fabric notebook designed to safely and consistently enforce Delta Lake table properties across a Lakehouse environment. It provides a controlled, idempotent approach to applying configuration standards at scale, with built-in dry-run support, guardrails to prevent unintended overwrites, and clear logging for transparency and auditability. The notebook is intended to help data platform and analytics teams reduce configuration drift, standardize operational settings, and manage Delta table behavior in a repeatable, governance-friendly way within Microsoft Fabric. Notebook: https://github.com/masonpiwonka/fabric-notebooks/blob/main/DeltaPropEnforcer.ipynb LinkedIn: Mason Piwonka | LinkedIn https%3A%2F%2Fgithub.com%2Fmasonpiwonka%2Ffabric-notebooks%2Fblob%2Fmain%2FDeltaPropEnforcer.ipynb
Nov2025_Subhadip_Pal_CitiesOfTomorrow
The data show a clear, actionable pattern: urban green cover and renewable energy adoption are the strongest correlates of higher urban sustainability. While transport access is beneficial, its effect is smaller than greening and clean energy adoption. Clustering the cities reveals three archetypes — sustainable leaders (high green & low carbon), mixed-profile cities (high green but unexpectedly high carbon), and at-risk cities with low green cover and elevated carbon — suggesting that different policy mixes (greening, emissions controls, transport investments) are appropriate for each group. https%3A%2F%2Fgithub.com%2FSubhadipPal16052000%2FNov2025_Subhadip_Pal_CitiesOfTomorrow-
Cities of Tomorrow – Urban Growth & Sustainability
Project Summary: Cities of Tomorrow – Urban Growth & Sustainability Overview As rapid urbanization reshapes the globe, cities face the dual challenge of supporting economic growth while maintaining environmental sustainability and livability. This project explores these dynamics by applying Data Science techniques—data cleaning, exploratory data analysis, and predictive modeling—to understand how modern cities evolve and what factors drive their sustainability. Using the provided Urban Planning Dataset along with optional global indicators, the project uncovers patterns in population density, green space availability, renewable energy usage, and sustainability performance across cities. The goal is to reveal insights that can help policymakers design more resilient, livable, and eco-friendly cities of the future. 1. Data Cleaning & Preparation Steps Performed Loaded the urban planning dataset and inspected shape, types, and missing values. Detected key columns using heuristic matching: Population Density Green Cover Percentage Renewable Energy Usage Urban Sustainability Score (used as the prediction target) Cleaned missing values using: Median imputation for numerical features Mode imputation for categorical features Removed identifier-like columns (city_name, id) from modeling. Prepared a clean, machine-learning-ready DataFrame with consistent types and no missing values. Outcome A fully preprocessed dataset suitable for EDA and modeling. 2. Exploratory Data Analysis (EDA) Correlation Analysis A numeric correlation matrix was generated to understand linear relationships. Key observations typically include: Higher green cover tends to correlate positively with sustainability Greater renewable energy usage also shows a positive relationship with sustainability High population density may correlate negatively with green cover These patterns highlight how environmental and demographic factors shape urban resilience. Scatter Plots Clear visual relationships were plotted: Population Density vs Green Cover Green Cover vs Sustainability Score Renewable Energy Usage vs Sustainability Score CO₂ Emissions vs Sustainability Score (if available) These helped verify whether relationships are linear, clustered, or affected by outliers. 3. Predictive Modeling Model Used Random Forest Regressor (n=200 trees) Chosen because: Handles non-linear relationships Robust to outliers Automatically captures interaction effects Works well when feature importance is required Target Variable urban_sustainability_score Model Training Split into 75% training / 25% testing Fit random forest on selected features (green cover, renewable usage, etc.) Model Performance Metrics R² Score: Measures how much variance the model explains MAE (Mean Absolute Error): Measures average prediction error in sustainability score units This gives a quantitative measure of how well city sustainability can be predicted from environmental and infrastructure-related indicators. Feature Importance Results The model ranks which features contribute most to sustainability. Typical top features include: Green Cover Percentage Renewable Energy Usage Infrastructure Score (if present) Population Density This helps identify what factors drive sustainable cities. 4. Data Storytelling & Insights Key Insights Cities with higher green cover consistently score better on sustainability metrics. Adoption of renewable energy sources is a strong indicator of long-term ecological resilience. Population density impacts green availability and carbon indicators, showing how urban design must balance growth and environmental health. Sustainability is multi-factorial—green space, clean energy, and efficient infrastructure together shape a city’s livability. Narrative Summary Urban sustainability is not the result of one single factor but a system of interconnected elements. The data shows that cities that invest early in green infrastructure and renewable energy build stronger foundations for future livability. Meanwhile, rapidly growing cities must mitigate density-driven stress through smart zoning and urban greening programs. 5. Project Deliverables Notebook: Nov2025_TirthBhanushali_CitiesOfTomorrow.ipynb Contains: Data loading & cleaning EDA visualizations Predictive modeling Markdown storytelling https%3A%2F%2Fgithub.com%2Fbhanushalitirth26-cell%2FCities-of-Tomorrow%2Fblob%2Fmain%2FNov2025_TirthBhanushali_CitiesOfTomorrow.ipynbOptimize Power BI Report with Model Best Practice Analyzer and Vertipaq Analyzer using Semantic Link
Every Power BI Developer pays attention to the underlying performance of their dashboard beyond just churning out reports. This is why adhering to best practices rules should no longer feel like a task, irrespective of your level of experience with Power BI. Semantic Link Labs is here to get the job done. If you are reading about Semantic Link Labs for the first time, you can read my demo introductory article here. This is a Python library developed by Michael Kovalsky that makes this process easier with just a few lines of code in Microsoft Fabric Notebook. Our Use Case: David, A Power BI developer at the AMA enterprise, got several complaints from colleagues that the Sales and Return dashboards take too long to load and sometimes time out. David thought of many reasons why this could have happened, but he wants to start by using the Model Best Practice Analyser Method and Vertipaq Analyzer to investigate the issue. Before this day, David knew he could use an external tool like Tabular Editor for this task. But he recently found out about a new Python library called Semantic Link Lab using Microsoft Fabric Notebook that can help him figure out this issue with the report with just a few lines of code. The sample Sales & Returns Sample v201912 dashboard use for this demo is available for download here You can also download this Microsoft Fabric Notebook used for this Demo here. David’s Task: Perform a Model Best Practice Analyser (BPA) on the Semantic Model of your Power BI report. Perform a Vertipaq Analyzer on your semantic model. Let’s get started: Open your Notebook In Microsoft Fabric, let's investigate what went wrong. Before we get started, we must make sure we have the Semantic Link Labs library installed as well as the other necessary libraries. #Install the Semantic link Labs library in your Fabric notebook %pip install semantic-link-labs After that, we will also be installing the necessary libraries in your notebook. ### Once installed, run this code to import the library into your notebook import sempy_labs as labs from sempy_labs import report as rep from sempy_labs.report import ReportWrapper 1. Performance Model Best Practice Analyzer (BPA) on a Semantic Model report. Model Best Practice Analyzer uses best practice rules to scan your semantic models for bad DAX code, improper formatting and usage of data types, inappropriate relationships, and potentially risky calculation patterns that should be fixed in your report. #Model Best Practice Analyzer import sempy_labs as labs # Enter the name or ID of your semantic model dataset = 'Sales & Returns Sample v201912' # Enter the name or ID of the workspace in which the semantic model # resides workspace = 'Fabricday' labs.run_model_bpa(dataset=dataset, workspace=workspace) When you toggle on the results below, we can see that we have: 16 DAX expression with high rule violation severity, 10 Medium severity, report pages with other details in the Sales & Return Sample v201912 Dashboard. 64 Formatting Medium rule violation severity and 41 on low-level/hints severity. 146 Maintenance low-level/hints rule violation severity and 10 Medium rule violation severity. 46 Performance Medium rule violation severity. & Returns Sample v201912 2. Perform a Vertipaq Analyzer on your Semantic Model. import sempy_labs as labs # Enter the name or ID of your semantic model dataset = 'Sales & Returns Sample v201912' # Enter the name or ID of the workspace in which the semantic model # resides workspace = 'Fabricday' #x = labs.vertipaq_analyzer(dataset=dataset, workspace=workspace) # Setting export='table' will export the results to delta tables in # the lakehouse attached to the notebook x = labs.vertipaq_analyzer(dataset=dataset, workspace=workspace, export='table') # Setting export='zip' will export the results to a .zip file in the lakehouse attached to the notebook. # x = labs.vertipaq_analyzer(dataset=dataset, workspace=workspace, export='zip') The result below shows that the Vertipaq Analyzer Analysis of the Sales & Returns Sample v201912 has been exported to a delta table in my Lakehouse. A snapshot of the Vertipaq Analyzer in my Lakehouse. This shows the Vertipaq Analyzer columns, hierarchies, tables, model, partitions, relationships and tables which can be visualize to understand the semantic model performances. Conclusion If you ever have a slow Power BI Dashboard that takes time to load, and you want to understand the reason for the slow performance. You can download the Microsoft Fabric Notebook used for this optimisation and enhancement Power BI report with Semantic Link Labs here. References Semantic Link Labs Git Hub Repository by Michael Kovalsky: https://github.com/microsoft/semantic-link-labs Feel free to connect with me via my socials below if you want to discuss further. LinkedIn: Musili Adebayo Twitter: Musili_Adebayo https%3A%2F%2Fgithub.com%2FMusili-Adebayo%2F-Musili-Adebayo-fabric_day_project_dashboard%2Fblob%2Fmain%2Fpowerbi_report_notebook.ipynbPortable Power BI Dashboard Templates with Fabric Notebooks
Purpose & scenario This notebook demonstrates how to make a Power BI dashboard portable by parameterizing and programmatically re-binding field references in a report definition. The result: a reusable template you can deploy to a different semantic model with minimal manual effort—useful for multi-workspace/customer scenarios and catalog/factory patterns. How it works Loads a reference template report Maps template placeholders → fields in the target semantic model Uses semPy to update bindings in the report definition Encourages Visual Calculations and report-specific measures (with a dedicated home table) to reduce tight coupling Quick start Add the notebook to a Fabric workspace (capacity-backed). In the configuration section, set: workspace_id, dataset_id, act_measure, bud_measure, dimension, report_name_override. Run the notebook cells in order. Open the generated report and verify the Monitoring Dashboard. Requirements Fabric capacity + Contributor (or higher) Build permission on the target semantic model Python in notebooks (Preview); semPy enabled Semantic model name must not end with a trailing space No sensitive data is required (uses a public reference model) Reusability & clarity Clean, commented steps (load → map → apply → validate) Externalize mappings (CSV/JSON) for repeatable deployments Credits Patrick LeBlanc — Creative way to use semPy to update a Power BI report definition Fabric Unified Admin Monitoring (FUAM) Publication & acknowledgments This Proof of Concept was developed with the assistance of ChatGPT and published for the Fabric Notebooks for Power BI – August Contest. Disclaimer Provided as-is for demonstration purposes. Use at your own risk; no liability for any damages. Github-Repository https%3A%2F%2Fgithub.com%2FMarcusWegener%2Fpbi-dashboard-template-notebook%2Fblob%2Fmain%2FDeploy_Monitoring_Dashboard.ipynbFabCon 2025 European Conference Schedule Analysis
Notebook Overview This notebook captures the complete workflow for exploring the FabCon 2025 conference schedule. It begins with web scraping the schedule from the European Microsoft Fabric Community Conference 2025 website, then performs data cleaning and preprocessing to handle missing values, merge speaker information, and organize sessions by day, time, topic, and level. Using Pandas and Spark, the cleaned dataset is prepared for analysis, and key insights are visualized, including: Number of sessions per day Top 10 topics covered Most active speakers Session distribution by level (Business, Technical, Advanced) Sessions over time The notebook also includes a polished header with the FabCon logo, author information, and professional links, making it easy to follow, visually appealing, and ready for reporting or further analysis. Data Source The dataset used in this notebook comes from the official FabCon 2025 conference website: European Microsoft Fabric Community Conference 2025 - https://www.sharepointeurope.com/conference/schedule/2025-Fabric/ The schedule and session details were web scraped directly from this site to analyze the conference program, sessions, speakers, and topics. Github : https://github.com/prachijain-dreamit/FabCon2025.git https%3A%2F%2Fgithub.com%2Fprachijain-dreamit%2FFabCon2025.git
