Learn Microsoft Fabric, hands-on.

Weekly call recordings

Every week we host a live call with the instructors: real member questions, new feature roundups, and architecture worked through together. Every call is recorded, so you never miss one. Here is the library so far (33 calls, 32h 18m).

• Metadata-Driven Bronze Layer 18 Feb 2026 58:17

  Building a metadata-driven bronze ingestion layer for a CRM source, with a reusable pipeline and an example notebook you can pull apart (demo files attached).

  metadata-drivenbronze layeringestionpipelines

  Open in Skool ↗
• Various Topics 4 Mar 2026 1:03:12

  Moving work between environments: variable libraries vs deployment-pipeline auto-binding, dynamic workspace and notebook IDs, managed private endpoints, and running pipelines as a service principal.

  variable librariesdeployment pipelinesprivate endpointsservice principal

  Open in Skool ↗
• Networking Features 10 Mar 2026 1:04:07

  A full tour of Fabric networking: inbound vs outbound, Private Link and conditional access, IP restrictions, trusted workspace access, gateways, and managed private endpoints, plus where Spark still has limits.

  networkingprivate linkgatewaystrusted workspace access

  Open in Skool ↗
• New Feature Summary 18 Mar 2026 53:05

  March feature roundup: Git branching with branched workspaces and code compare, DevOps vs GitHub, Custom Live Pools, Fabric data agents going GA, and event-driven apps with Eventstreams.

  feature roundupgit branchingdata agentseventstreams

  Open in Skool ↗
• New Feature Summary 25 Mar 2026 58:34

  A walk through the Power BI March release: custom totals, modern visual defaults, translytical task flows and Direct Lake in OneLake going GA, and DAX user-defined functions.

  power bi releasedirect laketranslytical task flowsdax udf

  Open in Skool ↗
• Terraform 1 Apr 2026 1:03:15

  Terraform for Fabric from the ground up: the declarative, idempotent model, a live init, plan and apply demo creating Azure resources and a Fabric workspace, and where Terraform fits in your deployment workflow.

  terraforminfrastructure as codeworkspace provisioningdeployment

  Open in Skool ↗
• Multi-Workspace Deployments 8 Apr 2026 1:05:12

  Deploying across many workspaces in a data mesh: autobinding vs variable libraries, governance, and a live demo deploying multiple workspaces from Azure DevOps using a service principal.

  multi-workspacedata meshazure devopsservice principal

  Open in Skool ↗
• Various Topics 15 Apr 2026 57:59

  Webhooks in data pipelines, logging and alerting patterns in Fabric, and a preview of the planned end-to-end project course.

  webhooksloggingalertingpipelines

  Open in Skool ↗
• Mirroring Architecture 21 Apr 2026 56:41

  How database mirroring really works: schema drift and CDC, mirroring vs shortcuts, securing mirrored databases with OneLake Security, using Git with them, and the capacity throttling to watch for.

  mirroringcdcshortcutsonelake security

  Open in Skool ↗
• Item takeover via API & other topics 29 Apr 2026 1:00:36

  Taking over item ownership through the API, then a Power BI grab bag: Direct Lake and user-context-aware calculated columns, vibe coding reports, and tuning translytical task flows.

  item ownershipapidirect laketranslytical task flows

  Open in Skool ↗
• Managing Spark Sessions 6 May 2026 58:22

  Getting Spark under control in Fabric: sessions in practice, pools and VCores, high-concurrency sessions, the native execution engine, and my honest take on when Spark is worth it (plus Eventstreams vs Structured Streaming).

  spark sessionspoolsnative execution enginehigh concurrency

  Open in Skool ↗
• Pipeline Identity Management 13 May 2026 1:03:34

  Who runs your pipelines and why it matters: user vs workspace identity vs service principal, how editing a pipeline changes its stored identity, and how CI/CD fixes ownership, plus a detour into OneLake storage tiers and costs.

  pipeline identityservice principalci/cdstorage tiers

  Open in Skool ↗
• Fabric Jumpstart 20 May 2026 49:29

  Fabric Jumpstart end to end: one-click demo setup, a healthcare billing notebook and real-time dashboard, code-quality standards, RTI logging and monitoring patterns, and a look at the AI and MCP roadmap.

  fabric jumpstartreal-time intelligenceloggingcode quality

  Open in Skool ↗
• Various Topics 27 May 2026 56:04

  Faster metadata sync for SQL analytics endpoints, Lakehouse Eventhouse endpoints, managing OneLake security roles and a shortcut gotcha, plus a discussion on AI in real consulting workflows.

  sql analytics endpointmetadata synconelake securityshortcuts

  Open in Skool ↗
• New Feature Summary 3 Jun 2026 59:20

  June feature roundup: Fabric Apps and Rayfin, SQL analytics endpoint CI/CD, materialized lake view refresh, OneLake storage lifecycle, data agents with service principals, GPU acceleration, and pipeline approvals with conditional retries.

  feature roundupfabric appsmaterialized lake viewspipeline approvals

  Open in Skool ↗
• Managed Private EP & Data Gateways 10 Jun 2026 57:14

  Connecting Fabric to network-secured data sources: on-prem and VNet data gateways, private and managed private endpoints with a live demo, how shortcuts behave behind a firewall, and managing gateway connections.

  data gatewaysmanaged private endpointsfirewallshortcuts

  Open in Skool ↗
• Fabric Network Architecture 17 Jun 2026 56:06

  Designing Fabric's network architecture: notebook connectivity and static outbound IPs, gateways vs Spark compute and where to place them, Key Vault connectivity, and shortcuts to secured storage including AWS S3.

  network architecturestatic outbound ipgatewayskey vault

  Open in Skool ↗
• Choosing the Right Fabric Tool 24 Jun 2026 58:47

  A panel on picking the right Fabric tool: the case for Dataflow Gen2, vendor lock-in and migration, the Python vs Spark kernel cost myth, User Data Functions, and why consistent architecture beats over-engineering.

  tool selectiondataflow gen2vendor lock-inuser data functions

  Open in Skool ↗
• Identities, Connections & Ownership 1 Jul 2026 1:02:34

  Access management in Microsoft Fabric: the full access stack (Entra, capacity and workspace roles), the three identity types (user, service principal, workspace identity) and when to use each, how connections and Key Vault references store and reuse credentials, and why item ownership silently breaks pipelines and leaves SQL analytics endpoints stale.

  access managementidentitiesconnectionsitem ownership

  Open in Skool ↗
• Identity and access management 8 Jul 2026 1:00:02

  Whiteboarding session on identity and access architecture in Microsoft Fabric: designing Entra security groups and naming conventions that scale, mapping groups to workspace roles across dev/test/prod, item-level permissions and OneLake security, governing connections and gateways (incl. programmatic management with Terraform), workspace identity vs service principal and the feature-workspace gotcha, the new delegated shortcut access mode (preview, incl. cross-tenant), and exactly what groups and access to request when starting in a new environment.

  identity architectureentra groupsworkspace rolesgovernance

  Open in Skool ↗
• OneLake Security 15 Jul 2026 58:25

  Deep dive into OneLake security (now GA) managed as part of a metadata-driven framework, based on a real client implementation: what it changes vs per-engine access control, workspace roles vs viewer/item permissions and which roles bypass it, defining roles with row-level and column-level security in configuration JSON, syncing data access roles automatically via the OneLake security API with a service principal resolving Entra groups, the SQL analytics endpoint user-identity access mode switch, schema-level shortcut limitations, and migrating older non-schema lakehouses.

  onelake securityrow-level securitycolumn-level securitymetadata-driven

  Open in Skool ↗
• Medallion Architecture 22 Jul 2026 1:00:06

  Panel discussion on the medallion architecture: where the bronze/silver/gold terminology came from and why it is closer to a naming convention than a full architecture, when two, three or more layers make sense, when a silver layer earns its place (normalization and building shared logic once instead of duplicating it across gold tables), what the pattern leaves undefined (data ownership, layer definitions, lakehouse vs warehouse per layer), what each layer looks like in a real Fabric implementation (raw files plus Delta tables in bronze, schemas or domain lakehouses in silver, star-schema gold), separating ingestion and reporting workloads across capacities with shortcuts, data residency and private endpoint constraints, lifecycle/retention policies per layer, version control across layers, and how medallion relates to data mesh.

  medallion architecturebronze silver goldlayersdata mesh

  Open in Skool ↗
• Open Q&A 29 Jul 2026 50:10

  Open Q&A session working through member scenarios: pulling Delta Sharing tables from a partner's Azure Databricks metastore into a lakehouse behind an on-premises data gateway (Dataflow Gen2 fast copy, looping tables with parameters, why notebooks cannot use the gateway), removing orphaned schema-level deny permissions on the SQL analytics endpoint after switching to OneLake security (delegated access mode round-trip), planning around the 1,000-item workspace limit with metadata-driven pipelines and notebooks and splitting workspaces by medallion layer plus an orchestration workspace, simplifying SAP ingestion with CDS views instead of thousands of raw tables, keeping Direct Lake reports healthy with regular Optimize and Vacuum and controlling refresh order so users never hit errors, and choosing between Fabric deployment pipelines and Git pull-request flows (branch protection, backup vs main branches, the fabric-cicd library).

  open q&adelta sharinggatewayonelake securityworkspace limitsdirect lake maintenance

  Open in Skool ↗
• On-Premises Data Gateway 5 Aug 2026 53:42

  Hands-on walkthrough of setting up an on-premises data gateway for Microsoft Fabric from scratch: the three gateway flavors (on-premises, virtual network, streaming virtual network), building the hosting environment in Azure (virtual network, gateway and data subnets, the new private-subnet default-outbound-access change that can break gateway installs, VM sizing against the documented 8-core/8 GB recommendation, Azure Bastion instead of an open RDP port), installing and registering the gateway (admin account choices, why the recovery key must be stored safely and rotated, moving a gateway to a new machine), verifying the setup with the built-in network connectivity test and HTTPS mode, managing the gateway in Fabric (additional admins, connection creators and resharing), high availability with gateway clusters and portal-driven updates, and using the gateway in a data pipeline connection to a network-secured Azure SQL database (firewall whitelisting, lakehouse write access, Azure Key Vault references through the gateway).

  on-premises data gatewaygateway installationazure virtual networkrecovery keygateway clustersazure key vault

  Open in Skool ↗
• CI/CD & Deployment Patterns 12 Aug 2026 1:01:07

  Panel discussion on CI/CD and deployment patterns in Microsoft Fabric: what continuous integration and continuous deployment actually mean and how Git integration (feature branch workflows) covers the CI side while deployment pipelines and the fabric-cicd library cover CD, why data platform CI/CD is harder than traditional software (schema evolution, lookup data that must migrate with the code, refreshing data after a deploy), the minimum Git skills a team needs before adopting any of it, branch strategies (feature branches merged to main via pull requests, feature workspaces per feature vs fixed developer workspaces, workspace identities, the preview that allows branch-out with contributor access), the deployment options compared (Fabric deployment pipelines in the UI, triggering a deployment pipeline through the API from Azure DevOps so a service principal owns the deployed items instead of a personal token that breaks when someone leaves, definition-based deployments with the item APIs and their ID-remapping pain, the fabric-cicd library with parameter.yml for complex requirements), one main branch vs a branch per environment and why cherry-picking releases gets messy, wiring automated tests around deployments, and closing recommendations for small teams vs larger organizations.

  ci/cddeployment pipelinesfabric-cicdgit integrationbranch strategyfeature workspacesservice principal

  Open in Skool ↗
• Fully automated AI agent workflow 19 Aug 2026 58:43

  Live demo of a fully automated AI agent workflow for Microsoft Fabric development: a feature ticket on the Azure DevOps board wakes a developer agent (a headless coding-agent session running under its own Entra service principal) that clones the solution repo and the DevOps wiki, branches out into its own feature workspace, builds and tests a metadata-driven ingestion pipeline for a new source system, documents the work back to the wiki, and opens a pull request that triggers a second reviewer agent from a different vendor, the two iterating on review comments until the only human step left is approving the merge; along the way the demo shows how the agent reacts to a deliberate specification error (it blocks on the ticket and asks for input instead of inventing a workaround), why dispatcher scripts keep token spend at zero while agents are idle, agent design essentials (instructions, a toolbox of deterministic scripts for branch-out and pipeline runs, Fabric CLI, and the Azure DevOps + Microsoft Learn MCP servers), least-privilege permissions and branch policies as guardrails, and the closing discussion on hosting options, data privacy, why wiki documentation quality is the make-or-break prerequisite, and capping review loops so two agents never iterate forever.

  ai agentsautonomous agentsagentic developmentazure devopsservice principalmcp serverguardrailsfeature workspacepull request

  Open in Skool ↗
• Breaking and Fixing Direct Lake 26 Aug 2026 1:00:27

  Hands-on Direct Lake session that first builds a healthy baseline (a 50-million-row Direct Lake report timed with Performance Analyzer, then verified with DAX info functions like TABLETRAITS and column-segment temperature to watch transcoding warm the columns) and then deliberately breaks it in the two ways real platforms break: a destructive table overwrite that evicts every resident column and causes the classic slow cold start, and a repartition into 5,500 tiny Parquet files that breaches the F64 capacity guardrail and takes the report down with a clear too-many-files error; along the way it contrasts the two Direct Lake flavors (Direct Lake on OneLake fails loudly, Direct Lake on SQL endpoint silently falls back to DirectQuery and just gets slow, spotted via T-SQL in DAX Studio server timings), repairs everything with Delta table optimize, history, and the restore function, shows forcing Direct Lake only behavior in the semantic model settings and Tabular Editor, and closes with the operating rules: prefer append over overwrite, run optimize and maintenance notebooks on a schedule, and remember Direct Lake is only as good as the engineering behind it.

  direct lakesemantic modelpower bireframingtranscodingdirectquery fallbacksql endpointcapacity guardrailsdelta tableparquetoptimizerestorevertipaqdax studiotabular editorperformance analyzer

  Open in Skool ↗
• Open Fabric Q&A 2 Sep 2026 59:10

  Open Q&A session with no set topic, just the Fabric questions members brought: how to switch a notebook's default lakehouse between dev, test and prod without touching code (a variable library reference in a configure cell, deployment rules, auto-binding, or skipping attached lakehouses and building abfss paths with notebookutils), why deriving the environment from the workspace name is a hidden dependency that trips up feature workspaces, granting a service principal read access to SQL analytics endpoint views through a group and GRANT statements, a fresh finding on which identity actually runs a data pipeline (the last-modified user is only a best guess, and a CI/CD library deployment resets it), how to split capacities so IT pays for engineering and the business pays for reporting (separate prod from dev and test first, Pro workspaces with import mode for the report layer, pausing small capacities with a runbook), whether one shared silver semantic model is enough or every use case needs a gold model, row-level security in a warehouse and the fallback performance cost, Claude Code with notebooks in VS Code's virtual file system mode versus a cloned repo or the Fabric CLI, what happens when an F64 hits 100 percent (background and interactive rejections, pause and resume, surge protection, the chargeback app), and how to see it coming with capacity events and the FUAM monitoring project.

  q&avariable librarydeployment rulesdefault lakehousenotebookutilsabfssfeature workspaceservice principalsql analytics endpointviewspipeline identityci/cd librarycapacitychargebackpro licenseimport modemedallionsilvergoldsemantic modelrow-level securitywarehouseclaude codevs codefabric clithrottlingsurge protectioncapacity eventsfuamfabcon

  Open in Skool ↗
• Getting Started with Fabric Apps 9 Sep 2026 58:58

  Hands-on session that builds a Fabric app from an empty project: what Fabric apps are (apps hosted on your capacity with Fabric authentication handled for you), checking region availability before creating a capacity, creating the app item and choosing between the Todo, Blank, and Data templates, opening the published Todo app and following its setup guide into VS Code (npm scaffold, running the frontend locally while it still talks to the live Fabric SQL database backend), a walk through the project structure (the data schema that becomes your tables, the pages, and the services), vibe-coding a small change and publishing it with a single upload command, then three real app ideas built the same way (a better connections overview using the Fabric APIs, a pipeline identity flow simulator as a learning tool, and a custom report on top of a semantic model with a Ctrl+K search), followed by the questions the demo raised: opening apps outside Fabric and the current data-app limitation, a look at a community contest game hosted on Fabric, what actually consumes capacity (SQL database, GraphQL API, static storage), how sharing and authenticated versus anonymous roles work, and a frank discussion of Fabric apps versus Power BI (where vibe coding shines, where maintenance and governance bite, and use cases like write-back status reporting or a build-your-own Purview).

  fabric appspreviewregion availabilitytodo appblank appdata apptemplatenpmvs codelocal developmentsql databasegraphqlravenschemapagesservicesvibe codingcodexpublishfabric apisconnectionspipeline identitysemantic modelcustom reportchromelesscapacity consumptiononelake storagesharingrolespower bigovernancewrite-backpurview
• Shortcuts and Networking in Fabric 16 Sep 2026 1:01:58

  Whiteboard-plus-demo session on shortcuts to storage that lives outside Fabric and the networking around them: the target landscape (ADLS Gen2, Blob storage, Amazon S3 and S3-compatible stores like MinIO, Google Cloud Storage) and why most real accounts are not reachable from the public internet, creating storage accounts with and without the hierarchical namespace and with public access restricted, a first shortcut to an open ADLS Gen2 account plus the Storage Blob Data role assignment you still need even as the account creator, why ADLS Gen2 and Blob are two endpoints on the same account with the same permission model (and what the hierarchical namespace changes), what happens when public network access is turned off and how the shortcut cache can mask it, the two ways to let Fabric through the storage firewall (the broad allow-trusted-Microsoft-services checkbox versus Trusted Workspace Access), a step-by-step build of the resource instance rule for a Fabric workspace identity through a custom ARM template deployment (why the portal UI cannot do it, the zero-GUID subscription reference, the tenant ID, and the harmless portal-template error), what the network rule actually checks versus the role assignment layer, switching the shortcut connection to the workspace identity, how notebooks and pipelines then route traffic through the lakehouse shortcut instead of hitting the storage account directly, the on-premises data gateway plus IP whitelisting as the option that works for AWS, GCP and on-prem stores where Trusted Workspace Access does not apply, a note that the same resource instance rule has also worked with a plain Blob storage account, member questions on whether S3 shortcuts for large JSON and Parquet datasets belong under Tables or Files and how the shortcut cache behaves across batch runs, a demo of writing through an ADLS Gen2 shortcut versus the read-only Blob shortcut (ADLS Gen2 is currently the only external target with read and write), and closing questions on shortcuts to shortcuts across dev and UAT, how common on-premises gateways are in practice, and SharePoint shortcuts with a service principal or workspace identity.

  shortcutsonelakeadls gen2azure blob storagehierarchical namespaceamazon s3s3 compatibleminiogoogle cloud storagestorage account networkingpublic network accessstorage firewallallow trusted microsoft servicestrusted workspace accessworkspace identityresource instance rulearm templatebicepterraformrbacstorage blob data readerstorage blob data contributoron-premises data gatewayip whitelistingprivate endpointshortcut cachetables vs filesread-only shortcutswrite through shortcutnotebookspipelinessharepoint shortcutservice principal
• Open Fabric Q&A: Bronze Layers, Connections, Private Links and Migrations 23 Sep 2026 56:48

  Second open Q&A session with no set topic, just the Fabric questions members brought: whether to ingest an on-premises SQL Server straight into Delta tables or land raw files first (raw as insurance for rebuilding downstream layers, SCD2 bronze tables with metadata, the append-only raw-table alternative, and the one question to ask: can you recreate the tables without going back to the source), how to keep 100+ connections manageable when pipelines only reference connection IDs (separate variable libraries for environment variables and external connections, a connection catalog built from the list-connections REST API into a lakehouse table, consistent naming between variables and connections, searching the connections page by ID, Terraform for greenfield setups, and the admin visibility gap that still needs fixing), what is known about custom workloads like Prophecy inside Fabric and their write-back limits against a lakehouse, mapping warehouse queries to capacity unit consumption in near real time (DMVs, Query Insights, the Data Warehouse Monitor, and why capacity operation events are the thing to wait for), a private-link-enabled workspace where a copy job and SQL MI mirroring both fail to write to OneLake plus the guidance to avoid private link where possible and scope it to one workspace, choosing which items fabric-cicd deploys compared with deployment pipelines (scope by type, optional features, and why custom exclusion rules add risk), mirroring versus OneLake shortcuts as the source for an ontology (latency decides, blob in the same region is close to native), and lessons from migrating ADF and Synapse workloads to Fabric (ODBC through the on-premises data gateway being several times slower than a self-hosted integration runtime, corrupt Parquet files from a DB2 source, dedicated SQL pool stored procedures mapping best to Fabric Warehouse, and least-effort lift versus a rewrite).

  q&abronze layerraw layerlanding zonedelta tablesparquetcopy activityon-premises sql serverscd2appendoverwritevariable libraryconnectionsconnection idrest apinaming conventionsterraformcustom workloadsprophecymaster data managementwrite-backwarehousecapacity unitscu consumptionquery insightsdata warehouse monitorcapacity eventsprivate linkprivate endpointazure sql managed instancevnet data gatewaycopy jobmirroringonelakedeployment pipelinesfabric-cicdontologyshortcutslatencyadfsynapsededicated sql poolmigrationon-premises data gatewaystored proceduresfabcon
• September Feature Summary: F0 Capacity, Deployment Plans and Agentic Power BI 30 Sep 2026 56:16

  September feature summary walkthrough, picking the announcements most likely to matter in real projects: the upcoming F0 (Fabric zero-provisioned) capacity with pay-as-you-go billing (why big, steady workloads will probably still be cheaper on a provisioned capacity, where an isolated unpredictable workload or a small dev and learning environment could fit, and how to guard against a runaway job producing a huge bill), centralized workspace monitoring that sends telemetry from many workspaces into one eventhouse so the eventhouse base cost is paid once, deployment plans for explicit item order plus notebooks or pipelines that run before or after an item deploys (with deploying metadata-framework JSON config files into a lakehouse as the example use case, and a note on keeping deployments simple), branch workspace admin profiles that make sure the right security group can always reach branched-out feature workspaces, the business action activity for calling business apps like Jira or Stripe from a pipeline through a Fabric connection, Power BI projects (PBIP) and the purge data option as building blocks for agentic Power BI development, the Power BI agentic tooling (skills for Fabric, the desktop bridge, and the hosted authoring MCP server for editing semantic models without running anything locally), why bringing your own AI agent tends to work better than the built-in Copilot experiences, the tension between AI agents and sensitive production data (with local models as one option), Project Osmos as a multi-agent data engineering harness inside Fabric, Git file-level commits and selective branching, where Fabric apps are heading next to Power BI reports now that code-first tools suit AI better than drag-and-drop, custom SQL pools for reserving warehouse compute per workload, new T-SQL syntax (GROUP BY ALL, ORDER BY ALL and QUALIFY), and a notebook toolkit for agentic development to try next.

  feature summaryseptember 2026fabconf0 capacityfabric zero-provisionedpay-as-you-goon-demand billingspend limitcapacity pauseworkspace monitoringeventhousedeployment planpre-deploy actionspost-deploy actionsdeployment pipelinesmetadata-driven frameworkgit integrationbranch outbranch workspace admin profilefile-level commitselective branchingpipelinesbusiness action activityjirastripepbippower bi projectspurge datapower bi agentic developmentskills for fabricdesktop bridgemcp serverpower bi authoring mcpcopilotlocal modelsproject osmosdata engineering agentfabric appsvibe codingcustom sql poolswarehouset-sqlgroup by allorder by allqualifybusiness centralnotebook toolkit
• FabCon Features Tested Live: Deployment Plans, Policies, Run Conditions and the Monitoring Hub 7 Oct 2026 1:00:01

  FabCon announcements part 2, with the new features tested live in a Fabric tenant to show what works today and what does not yet: deployment plans for deploying items in a set order and running notebooks after they deploy (building a plan on the canvas, deploying with a plan from a deployment pipeline, a failed deployment and thin monitoring, why selecting only the plan deploys just the plan item, using a plan when branching out to a feature workspace, and the plan living as a workspace item), Fabric policies through a policy set item (allow rules that act as an allow list, workspace and item type conditions, a tenant or capacity scope that cannot be changed later, a dedicated admin workspace for policies, no support yet in West and North Europe, changes taking up to 15 minutes, and a policy that blocked our own deployment while still letting one item type through), pipeline run conditions where a downstream pipeline waits for upstream runs with a matching run dimension (no manual runs once a condition is set, why the downstream pipeline still needs its own schedule, a run stuck waiting on dependency, and the dependencies showing up in the pipeline JSON for CI/CD), the new monitoring hub with its job runs view and capacity management page (utilization drill-down, resize and other capacity actions, and runs missing from the list), and which features to adopt first, including what deployment plans mean for deployment pipelines versus the fabric-cicd library and what we hope to see next in the new connections admin API.

  fabconfabcon europefeature demospreview featuresdeployment plansdeployment pipelinesdeploy with planpost-deploy actionsbranch outfeature workspacesgit integrationfabric-cicdfabric policiespolicy setitem creation policyallow rulescapacity scopegovernancepipelinesrun conditionsrun dimensionsupstream pipelinesorchestrationschedulesmonitoring hubjob runscapacity managementcapacity monitoringconnections admin api

Aleksi's Members-only YouTube videos

Plus a growing set of deep-dive videos.

• Top Tips & Strategies to Pass the DP-700 Exam 11:45 Open in Skool ↗
• Variable Library Strategies & Workarounds 12:15 Open in Skool ↗
• CI/CD Compatible Secret Fetcher 8:21 Open in Skool ↗