The Green Mirage: Uncovering the Blueprint of a Resilient City
I thought I knew what made cities sustainable. The data proved me completely wrong. Armed with data from 3,476 cities and three machine learning algorithms, I set out to rank the factors driving urban sustainability. Building density? Public transportation? Modern infrastructure? The models laughed at my assumptions. What emerged instead was a clear, undeniable pattern: nature and clean energy dominate everything else—combined. We're talking 70% of the entire sustainability equation coming from just two factors, while traditional metrics we spend billions on barely register. This isn't just a data science project. It's a wake-up call for every city planner, policymaker, and citizen wondering why their "smart city" initiatives aren't delivering sustainable results. The cities of tomorrow aren't smarter. They're greener. https://github.com/lahiruC22/data-science-projects/blob/main/cities-of-tommorow/Nov2025_lahiruwimalarathna_CitiesOfTomorrow.ipynb https%3A%2F%2Fgithub.com%2FlahiruC22%2Fdata-science-projects%2Fblob%2Fmain%2Fcities-of-tommorow%2FNov2025_lahiruwimalarathna_CitiesOfTomorrow.ipynbFabric Data Days Notebooks Contest - Cities of Tomorrow: Urban Growth & Sustainability
Submission for the Fabric Data Days – Notebooks Contest This notebook presents an end-to-end data science analysis on urban sustainability, combining Exploratory Data Analysis (EDA), machine learning, and data storytelling to answer a core question: How can we understand and predict the evolution of smart, livable, and sustainable cities using open urban-development data? 🔍 About the Project Using the Sustainable Urban Planning & Landscape Dataset (Kaggle) as the primary source and optional global indicators from World Bank and UN-Habitat, this notebook explores how cities balance: green areas density and mobility pollution and energy use infrastructure livability and long-term sustainability The analysis integrates both local (city-level) and global (country-level) signals to build a richer, more contextual narrative about urban resilience. 🧪 What You Will Find in This Notebook 1️⃣ Data Cleaning & Preparation Handling missing values Standardization Feature engineering Merging supplementary indicators Calculation of a unified sustainability metric (IES – Urban Sustainability Score) 2️⃣ Exploratory Data Analysis (EDA) Correlation heatmaps Sustainability drivers Environmental pressure vs green capacity Urban growth patterns 3️⃣ Predictive Modeling (optional but included) A Random Forest Regression model predicts the overall sustainability score, revealing: the most influential urban indicators the critical factor that cities should prioritize scenario-based insights for decision-makers 4️⃣ Clustering (K-Means) Cities are grouped into sustainability maturity levels, helping identify: leaders emerging cities vulnerable regions 5️⃣ Storytelling & Conclusions The narrative connects technical findings to real urban-policy implications, highlighting actionable insights for city planners and sustainability teams. 📌 Why This Notebook Matters Cities are evolving faster than ever—population growth, environmental crises, and rapid urbanization demand data-driven decisions. The goal of this entry is to demonstrate how Microsoft Fabric assists analysts and scientists in: exploring complex multi-source datasets building reproducible insights combining EDA, ML and storytelling in a single workflow translating data into meaningful urban strategies 📂 Repository All code, datasets, documentation and the full notebook version are available here: 🔗 GitHub: https://github.com/axlrn/Notebooks-Contest-Fabric-Data-Days-2025.git 🚀 Final Message I’m excited to contribute to this global challenge and to learn from the amazing work shared by the Fabric community. Hope this notebook inspires new perspectives on how data science can build the cities of tomorrow. 🌆✨ https%3A%2F%2Fgithub.com%2Faxlrn%2FNotebooks-Contest-Fabric-Data-Days-2025.gitNov2025_BenitovanBreugel_CitiesOfTomorrow
The Cities of Tomorrow This notebook explores the Sustainable Urban Planning & Landscape Dataset, available on Kaggle. It is created as part of the Fabric Data Days Notebook Contest Cities of Tomorrow. The goal is to uncover how cities evolve, sustain, and innovate for the future. Rather than just presenting data, this notebook takes you on a journey, a story told through five chapters, each explained with detailed markdown descriptions. Happy reading and coding! https://github.com/bbreugel/NotebookCityOfTomorrow/blob/main/Nov2025_BenitovanBreugel_CitiesOfTomorrow.ipynb https%3A%2F%2Fgithub.com%2Fbbreugel%2FNotebookCityOfTomorrow%2Fblob%2Fmain%2FNov2025_BenitovanBreugel_CitiesOfTomorrow.ipynbThe Cities of Tomorrow – Urban Growth & Sustainability (Four Pillar Principle)
🏆 Fabric Data Days — Notebook Submission ✨ Overview This project demonstrates an end-to-end pipeline that evaluates and predicts the City of Tomorrow using a four-pillar framework: Sustainability, Infrastructure, Safety, and Livability. I have considered only urban_planning_dataset.csv as my only Data source. The notebook includes data loading, cleaning, exploratory data analysis (EDA), feature engineering, custom metric derivation, model training, evaluation, visualization, and an interactive ipywidgets application that uses a saved model from Models/*.pkl . 🔎 What I built Interactive Application: An ipywidgets-based UI that ingests user inputs and returns pillar predictions using the trained model (saved as a .pkl file). EDA & Statistical Analysis: Thorough EDA with distribution plots, correlation analysis, box/violin plots, density maps, and statistical summaries to understand feature behavior by land use and pillar. Custom Metrics: Derived domain-specific metrics (e.g., resilience-adjusted sustainability, transport equity index) to capture nuanced urban attributes beyond raw features. Interpretation & Visuals: All key findings are supported by clear visuals and explanatory insight blocks for each pillar. Conclusion & Recommendations: A concise, evidence-backed summary with policy- and design-oriented recommendations for future-ready cities. 🧪 Models & Evaluation Below are the model names and evaluations: Overal Average Accuracy: 97.63% (R2) 1. Sustainability Model (RandomForest): 94.43% (R2) 2. Infrastructure Model (RandomForest): 98.66% (R2) 3. Safety Model (RandomForest): 99.91% (R2) 4. Livability Model (RandomForest): 97.52% (R2) 📂 Artifacts & Notebook The full notebook and artifacts are included with this submission. Couldn't upload the .pkl file to github but can be found in the zip attachment with this submission. Open the notebook here: Nov2025_Jai_Rathinavel_CitiesOfTomorrow.ipynb Application Demo GIF: https://github.com/jai-rathinavel/Fabric-Notebooks/blob/main/Fabric-Data-Days/Demo-App-Urban.GIF The model file(s) used by the ipywidgets app are stored in the Models/ folder inside the notebook workspace (e.g., Models/final_model.pkl ). 📌 Key Findings & Conclusion Renewable energy adoption and green space strongly correlate with higher sustainability scores indicating ecological planning drives the sustainability pillar. Industrial zones are the primary contributors to carbon footprint; targeted interventions and cleaner processes are recommended. Transport infrastructure shows generally balanced coverage; where gaps exist, targeted public-transit investments reduce inequity and congestion. Income vs crime correlations are weak policy and social interventions likely have outsized impact on safety compared to income alone. Disaster risk is a major negative driver of livability and overall sustainability resilience planning is essential for vulnerable residential zones. Custom metrics such as the Transport Equity Index and Resilience-Adjusted Sustainability helped surface non-obvious trade-offs and prioritize interventions. The interactive app demonstrates how stakeholders can explore “what-if” scenarios by adjusting feature sliders and immediately seeing pillar outcomes. Overall, cities that balance all four pillars perform best sustainable, resilient, inclusive, and livable urban design is the path to the City of Tomorrow. Submitted by: Jai Rathinavel LinkedIn https%3A%2F%2Fgithub.com%2Fjai-rathinavel%2FFabric-Notebooks%2Fblob%2Fmain%2FFabric-Data-Days%2FNov2025_Jai_Rathinavel_CitiesOfTomorrow.ipynb
BPA + Memory Analyzer + Write to Lakehouse
This script runs the built-in Notebooks for Semantic Model Health Check Sequential: 1. Best Practice Analyzer (BPA) 2. Memory Analyzer (equivalent to Vertipaq Analyzer 3. Added Bonus: The Resultset of the BPA + Three DAX INFO View tables are saved into a Lakehouse Process: 1. Create Lakehouse 2. Add Lakehouse to Notebook 3. Modify in the Python script the configuration for your Lakehouse Name, Workspace Name and Semantic Model Name 4. Run the Script 5. Check the result directly in the notebook or with the SQL Endpoint in your warehouse import sempy.fabric as fabric from datetime import datetime import re import pandas as pd # ============================================================================ # CONFIGURATION # ============================================================================ dataset = "Semantic Model Name" workspace = "Workspace Name" lakehouse = "Lakehouse_Name" # Function to clean column names def clean_column_name(col_name): col_name = str(col_name).replace('[', '').replace(']', '') col_name = col_name.replace(' ', '_') col_name = re.sub(r'[,;{}()\n\t=]', '', col_name) return col_name # Function to save DataFrame with smart append/overwrite def save_to_lakehouse(df, table_name, description="results"): """ Saves DataFrame to lakehouse. Tries append first, creates table if needed. """ full_table_name = f"{lakehouse}.{table_name}" # Convert pandas to Spark if needed if isinstance(df, pd.DataFrame): spark_df = spark.createDataFrame(df) else: spark_df = df print(f"Saving {description}...") try: # Try append first spark_df.write \ .format("delta") \ .mode("append") \ .option("mergeSchema", "true") \ .saveAsTable(full_table_name) print(f"✓ Appended {len(df)} records") except: # Table doesn't exist, create it spark_df.write \ .format("delta") \ .mode("overwrite") \ .option("overwriteSchema", "true") \ .saveAsTable(full_table_name) print(f"✓ Created table with {len(df)} records") # Function to process DAX results with metadata and timestamp handling def process_dax_results(results, dataset, workspace, table_name, description): """ Processes DAX query results: adds metadata, cleans columns, handles timestamps """ if results is not None and len(results) > 0: results['analysis_timestamp'] = datetime.now() results['model_name'] = dataset results['workspace_name'] = workspace results.columns = [clean_column_name(col) for col in results.columns] # Handle old timestamps in common date columns for col in ['ModifiedTime', 'RefreshedTime', 'StructureModifiedTime']: if col in results.columns: results[col] = pd.to_datetime(results[col], errors='coerce') results[col] = results[col].where(results[col] > pd.Timestamp('1900-01-01'), None) save_to_lakehouse(results, table_name, description) display(results.head(10)) return True return False print("="*80) print("STEP 1: Running Best Practice Analyzer...") print("="*80) # Run BPA analysis try: bpa_results = fabric.run_model_bpa( dataset=dataset, workspace=workspace, return_dataframe=True ) except TypeError: bpa_results = fabric.run_model_bpa(dataset=dataset, workspace=workspace) if bpa_results is not None and len(bpa_results) > 0: # Add metadata bpa_results['analysis_timestamp'] = datetime.now() bpa_results['model_name'] = dataset bpa_results['workspace_name'] = workspace bpa_results.columns = [clean_column_name(col) for col in bpa_results.columns] # Save to lakehouse save_to_lakehouse(bpa_results, "bpa_analysis_results", "BPA results") print("\nSummary by Severity:") display(bpa_results.groupby('Severity').size()) print("\n" + "="*80) print("STEP 2: Running Model Memory Analyzer...") print("="*80) memory_results = fabric.model_memory_analyzer(dataset=dataset, workspace=workspace) print("\n" + "="*80) print("STEP 3: Capturing Memory & Storage Statistics via DAX...") print("="*80) spark.conf.set("spark.sql.parquet.datetimeRebaseModeInWrite", "CORRECTED") # Define all INFO queries dax_queries = [ ("INFO.TABLES()", "info_tables", "table statistics"), ("INFO.COLUMNS()", "info_columns", "column statistics"), ("INFO.MEASURES()", "info_measures", "measure statistics"), ("INFO.RELATIONSHIPS()", "info_relationships", "relationship statistics"), ("INFO.STORAGETABLES()", "info_storage_tables", "storage table statistics"), ("INFO.STORAGETABLECOLUMNS()", "info_storage_columns", "storage column statistics"), ("INFO.STORAGETABLECOLUMNSEGMENTS()", "info_storage_segments", "storage segment statistics") ] try: for dax_query, table_name, description in dax_queries: print(f"\nGetting {description}...") results = fabric.evaluate_dax( dataset=dataset, workspace=workspace, dax_string=f"EVALUATE {dax_query}" ) process_dax_results(results, dataset, workspace, table_name, description) except Exception as e: print(f"Error: {str(e)}") print("\n" + "="*80) print("✓ ANALYSIS COMPLETE!") print("="*80) print("✓ All results saved to lakehouse and queryable via SQL Analytics Endpoint") print("\nTables created:") print(" - bpa_analysis_results") print(" - info_tables") print(" - info_columns") print(" - info_measures") print(" - info_relationships") print(" - info_storage_tables") print(" - info_storage_columns") print(" - info_storage_segments") https%3A%2F%2Fgithub.com%2FKornAlexander%2FPBI-Tools%2Fblob%2Fmain%2FNotebook%2520Gallery%2FBPA%2520%252B%2520Memory%2520Analyzer%2520%252B%2520Save%2520to%2520Lakehouse.ipynbFabric Report Resilience: A Scalable Disaster Recovery Notebook
📘 Notebook Description The notebook demonstrates an automated approach to ensuring report availability and resilience in Microsoft Fabric. The notebook orchestrates backup for reports across workspaces. By integrating Fabric APIs and automation logic, it enables seamless failover and continuity planning for analytics assets. 🌟 Benefits Business Continuity: Minimizes downtime and ensures that critical reports remain accessible during outages or workspace failures. Automated Resilience: Reduces manual intervention by automating the backup and restore workflow. Governance & Compliance: Provides a structured DR framework to meet organizational audit and compliance needs. Find the notebook here : https://github.com/NandanHegde15/MSFTFabric-Notebook/tree/main/SemanticModel/DR%20Strategy%20for%20Reports https%3A%2F%2Fgithub.com%2FNandanHegde15%2FMSFTFabric-Notebook%2Ftree%2Fmain%2FSemanticModel%2FDR%2520Strategy%2520for%2520ReportsEnd-to-end Machine Learning with Microsoft Fabric
Why This Notebook Exists When you’re new to data science, it’s easy to get lost in jargon and overly complex code. You start with excitement, but somewhere between “install these 12 libraries” and “let’s build a 50-layer neural net,” the spark starts to fade. I’ve mentored hundreds of data analysts and junior data scientists, and I kept seeing the same pattern: most learners never get to that “aha!” moment quickly enough. Notebook URL: https://www.kaggle.com/code/sahirmaharajj/end-to-end-machine-learning-with-microsoft-fabric The Problem I Wanted to Solve Most data science resources usually fall into one of two categories: Theory with too little hands-on work Overly advanced code that feels intimidating Neither truly helps someone take their first confident step. This notebook is my answer to that problem - It gives you just enough theory to understand what’s happening and practical code you can run right away. The focus is on building confidence, so you walk away knowing you can do this. Who It’s For New learners who want their first end-to-end ML project to be fun and easy to follow Analysts looking to get into machine learning without feeling overwhelmed Career switchers curious about data science but unsure where to start Junior data scientists who want a clean, reusable baseline project If you’re a more senior data scientist, you’ll probably find my Kaggle profile more up your alley - I’m a Kaggle Grandmaster there, ranked #34 globally. So, what’s it in for YOU? It gives you a working end-to-end ML workflow you can understand, reuse, and expand on. You’ll: Learn how to load, explore, and prepare data Train multiple models side-by-side Understand how evaluation metrics work (beyond just accuracy!) And because this is built in Microsoft Fabric Notebooks, you’ll see how to do all of this without complex local setup - making it beginner-proof and instantly reusable for real projects. What Makes It Different Yes, we’re using a well-known dataset (Titanic), but this is not just another “predict” tutorial. I’ve added: A clean, reusable model leaderboard system so you can compare results instantly Rich Markdown explanations woven into the workflow so you learn as you code A structure that blends teaching with real-world workflow (mirroring what I do when mentoring 1-on-1) Meaningful data prep that focuses on understanding each decision rather than just running code It’s a simple (open source) dataset… but the way it’s presented makes it fresh, engaging, and easy to learn from. Designed to Be Shared Every section is: Commented so you know what each line of code is doing Modular so you can swap in your own data and models without breaking the flow Explained in plain English (no complex jargon) Structured logically from data loading → preprocessing → model training → evaluation → comparison If you’re new, you’ll be able to follow along. If you’re experienced, you can reuse the template to speed up your own experiments. Why I Built It This Way I wanted to remove the complexity and show how data science can be approachable, fun, and productive from the very first notebook. Every choice in this project (from the dataset to the explanations to the Microsoft Fabric environment) was made to make learning easier while still giving a solid baseline in both theory and practice. This notebook is my way of making that experience available to everyone using Microsoft Fabric. If you enjoyed this tutorial, learned something new, or have any questions, I’d love to connect with you! Follow me on: LinkedIn: Sahir Maharaj Kaggle: Sahir Maharaj Microsoft Super User Profile: Fabric Community Topmate (Free Power BI Sessions): Let's Chat https%3A%2F%2Fgithub.com%2Fsahirmaharaj%2Fwordlit%2Fblob%2Fmain%2FEnd_to_end_Machine_Learning_with_Microsoft_Fabric.ipynbAutomatically populate Data Agents with Semantic Model Synonyms
Recently, I posted that the Semantic Models are the most valuable asset in your data estate to be used for Data Agents. Semantic Models are (mostly) put in perspective of the business users, using easy to understand terminology and avoiding technical setups like PascalCase or camelCase. Also, your business logic mostly lives in the Semantic Model, captured in DAX expressions. For each of these model objects, you may (or you should have) enriched the model with descriptions and synonyms. However, it was only shortly after that I could no other than conclude that Data Agents do not use the synonyms that are added to the Semantic Model. The implicit measures generated by the Data Agent, may return different results then when you ask the very same question in Power BI Copilot directly, or using the good old Power BI Q&A visual. By simply adding the synonyms to the AI notes for the Data Agent, which are captured on the right-hand side in the Data Agent editor, it will actually use that input to find the right measures in your Semantic Model. In the Notebook, I'm focusing on collecting the synonyms that are added by the developer, by simply filtering to only the items that have a Las Modified time. Collection of all this information happens using Semantic Link Labs. With all the information, I'm building a text string that can be copy-pasted to an existing Data Agent or populated automatically as I'm doing in the next steps. # Get all synynyms in the semantic model allsynonyms = labs.list_synonyms(dataset = semanticmodel_name, workspace= workspace_name) # By default the synonym field is populated with the object name. Therefore, filtering down to only relevant ones # filter out all rows where the object name is the same as the synonym relevantsynonyms = allsynonyms["IsExactMatch"] = allsynonyms["Object Name"].str.lower() == allsynonyms["Synonym"].str.lower() Next, I'm setting up a new Data Agent (defaults to the same workspace) to make sure I can populate the AI Notes with the text string with synonyms. To do so, I'm using the Data Agent SDK. The following actions are performed: Create a Fabric Data Agent Connect the Semantic Model as a source to the Data Agent Adds the text string with synonyms as AI notes to the Data Agent # Update Data Agent config to add instructions data_agent.update_configuration( instructions=f"{result_text}", user_description=f"Data agent to assist users with insights from the Semantic Model {semanticmodel_name}", ) # Get current configuration data_agent.get_configuration() The Notebook cell nicely outputs the configured instructions for the Data Agent. When we open the Data Agent, we see the information populated there as well. Once the data source (Semantic Model) is connected to the Data Agent, no tables are selected yet. All though the SDK allows to directly link tables, I did not automate this, as I believe this is for the Data Analyst to decide which tables are relevant (like Field parameters, which appear as tables in a model). In that same light, some of the synonyms collected in earlier steps, may not be relevant to bring along to the Data Agent. Full notebook can be found on GitHub. https%3A%2F%2Fgithub.com%2Fmarclelijveld%2FFabric-Automation%2Fblob%2Fmain%2FData%2520Agents%2FNB_CREATE_DataAgentSemanticModel.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.ipynbSimplified Model Refresh Using Notebook Application
How cool would it be to refresh partitions of your semantic model the no-code way ? The main goal is to provide a user-friendly "app" experience for data professionals to perform and monitor targeted refreshes of tables and partitions without leaving their Fabric Notebook. Yes the below app is rendered using a Notebook Cell ! Please attach the lakehouse to your notebook before running the below codes Python code starts.. %pip install semantic-link==0.11.2 %pip install semantic-link-labs==0.11.3 #Function to save the dependent utils files from my github repo to the lakehouse's resources section def save_from_github(github_url: str,path:str,file_name: str, force: bool = False): """ Downloads a file from GitHub and saves it under the mentioned path Args: url (str): The URL to download from (use raw.githubusercontent.com). file_name (str): The name of the file to save locally. force (bool): If True, always download and overwrite the file. """ url = github_url.replace("github.com", "raw.githubusercontent.com").replace("/blob/", "/") dest_path = f"{path}{file_name}" file_exists = os.path.exists(dest_path) if file_exists and not force: print(f"❗'{file_name}' already exists. Skipping download.") os.makedirs(os.path.dirname(dest_path), exist_ok=True) response = requests.get(url) if response.status_code == 200: with open(dest_path, 'wb') as f: f.write(response.content) if file_exists & force: print(f"📝 Overwritten the existing '{file_name}' with the latest file.") elif not file_exists : print(f"📥 Downloaded and saved '{file_name}'.") else: print(f"🔴 Failed to download. Status: {response.status_code}, URL: {url}") # Saves the "custom_utils.py" file from my repository to the Notebooks resources section # Use path as "./builtin/" to save file to notebook resources or "./" to save to notebook environment save_from_github( github_url="https://github.com/jai-rathinavel/my-packages/blob/main/sempy/custom_utils.py",path="./",file_name='custom_utils.py',force=True) #Importing all the functions and libraries from custom_utils.py file from custom_utils import get_model_details, launch_enhanced_refresh_ui #If saved to Notebook's resources run the below #from builtin.custom_utils import get_model_details, launch_enhanced_refresh_ui #Populating the dataframe result_df = get_model_details(load_from_lakehouse=False,table_name='Model Details',only_premium_ws=True,workspace_list=['Financial Observations','Fabric Developers']) #Launching the Application launch_enhanced_refresh_ui(input_df=result_df) #(Enable Visualize option to render the SSAS Trace output from sempy_labs package) To get more details about the functions please refer my Github Notebook ! Core Frameworks Used: semantic-link, semantic-link-labs, ipywidgets With my Notebook Application, you can: Refresh partitions on demand without setting up a pipeline. Works on Python Runtime. Access and refresh models from any workspace you’re a member of. Instantly view SSAS tracer output and a statistics DataFrame for better insights. ✨ Features Interactive UI: A simple application interface built with ipywidgets for an intuitive user experience. Workspace & Model Discovery: Automatically fetches all accessible semantic models, tables, and partitions. Data Caching: Ability to save the model metadata to a Lakehouse table to speed up subsequent runs and avoid redundant API calls. Granular Refreshes: Select specific workspaces, models, tables, and even individual partitions to refresh. Advanced Options: Configure advanced settings for each refresh operation, such as: Refresh Type, Retry Count, Max Parallelism, Commit Mode, Apply Refresh Policy Refresh Monitoring: Visualizes the SSAS trace output as a Gantt chart upon completion, showing the duration of each step. Github Link: https://github.com/jai-rathinavel/Fabric-Notebooks/blob/main/Aug-2025-Contest/Model%20Refresh%20App%20Launcher.ipynb Linkedin: https://www.linkedin.com/in/jai-rathinavel/ https%3A%2F%2Fgithub.com%2Fjai-rathinavel%2FFabric-Notebooks%2Fblob%2Fmain%2FAug-2025-Contest%2FModel%2520Refresh%2520App%2520Launcher.ipynb
