Blake Beckemeyer
Solution Advisor - Applied Information Sciences
Indianapolis, Indiana, United States
Actions
Blake Beckemeyer is a technical lead of Power Platform and Fabric solutions at Applied Information Sciences, specializing in knitting low-code and analytics into simple, governed solutions — and in pushing nascent tooling into production ahead of his peers. A professional tenor based in Indiana, he brings an energetic, visceral style to the stage.
Area of Expertise
Topics
From Power BI to the Lakehouse: Building Fabric Semantic Models That Scale
Microsoft Fabric changes the contract between your semantic model and the data underneath it. Direct Lake promises import-mode speed over lakehouse tables with no scheduled refresh — but only if you respect its rules. Get the modeling wrong and you silently fall back to DirectQuery, framing goes stale, and the “fast” model is anything but. This session is the practical guide to building Fabric semantic models that actually perform.
We’ll work through the decision that drives everything else — Direct Lake vs. Import vs. DirectQuery — and when each is the honest right answer. Then we’ll build a proper star schema over OneLake, cover the constraints Direct Lake imposes (data types, calculated columns, relationships), keep an eye on fallback, and apply the modeling and DAX patterns that hold up as data grows. You’ll leave knowing how to bring your Power BI modeling instincts into Fabric without getting burned by the new storage layer.
The Spec Is the Source of Truth: Building Real Software with Spec Kit
AI coding assistants made it trivially easy to prompt-and-pray your way to a feature — and just as easy to end up with code nobody can explain, reproduce, or extend. That approach doesn’t scale past a toy. Spec-driven development flips the model: the specification becomes the durable, version-controlled artifact, and code becomes a build output you can regenerate. GitHub’s open-source Spec Kit makes this concrete with a structured workflow that any AI coding assistant can drive.
In this session I’ll show spec-driven development the way I actually use it every day. We’ll walk the full Spec Kit workflow live — establishing a project constitution, specifying a feature, clarifying ambiguity, planning, breaking work into tasks, and implementing — and see how the quality gates catch the mistakes that prompt-and-pray ships to production. You’ll learn when to take the lean path and when the full set of gates earns its keep, and why this approach is agent-agnostic: it works with whatever assistant you already use. You’ll leave able to start spec-driving your own work the same week.
From Demo to Dependable: Running Copilot Studio Agents in Production
The demo always works. Production is where agents break — and they break in ways traditional software testing never prepared you for. The same prompt returns a different answer twice. The agent confidently answers outside its grounding. An action fires against the wrong record. There’s no test harness because there’s nothing deterministic to assert against. This session is the honest field guide to operating agents once the applause dies down.
We’ll walk through the failure modes that actually show up in production and what to do about each: testing behavior that won’t repeat, guardrails that keep an agent inside its lane, action safety, and the monitoring and feedback loops that tell you an agent is drifting before your users do. We’ll close on the governance gates worth enforcing before go-live. You’ll leave able to take an agent that demos beautifully and make it something you’d actually put in front of real users.
Flow to Agent in Practice: Hands-On Copilot Studio Migration & Governance
Every Power Platform shop now has hundreds of Power Automate flows — and a leadership mandate to “add agents.” But an agent is not a flow with a chat window bolted on, and re-platforming the wrong process is how teams end up with brittle, ungoverned automation that nobody trusts. This hands-on, full-day workshop walks you through migrating real Power Automate flows to Copilot Studio agents the right way: deciding when a flow should stay a flow, when reasoning genuinely adds value, and how the two work better together.
You will build alongside the instructor through six lab segments — starting from a working flow, dissecting the anatomy of a Copilot Studio agent (topics, actions, knowledge), and re-platforming a process end to end. We then tackle the parts most demos skip: orchestrating deterministic flows from inside an agent, governance and ALM across environments, and the genuinely hard problem of testing non-deterministic behavior before it reaches production. You will leave with a repeatable migration playbook, a governance checklist, and a clear-eyed sense of which of your own flows are good agent candidates and which are not.
Beyond the Chatbot: A Hands-On Workshop on Building Data-Grounded Copilot Studio Agents
Everyone wants to “add Copilot to our data,” but a generic chatbot that hallucinates over your business is worse than no chatbot at all. The difference between a demo and a dependable agent is grounding: connecting the model to your real, governed data with the right knowledge sources, actions, and guardrails. In this hands-on, full-day workshop you will build Copilot Studio agents that answer from your data — and admit it when they can’t.
You will build alongside the instructor through six lab segments: wiring knowledge sources (SharePoint, Dataverse, and Fabric-backed data), adding actions that call real systems, and grounding responses so every answer traces back to source. Then we tackle the parts most demos skip — keeping the agent inside its lane, testing non-deterministic behavior, and the governance and ALM you need before this touches production. You will leave with a repeatable build pattern, a governance checklist, and a clear-eyed sense of what it actually takes to ship a data-grounded agent your users can trust.
Fabric Data Agents & Copilot Studio: Integrating Data in Low-Code
Fabric Data Agents and Copilot Studio unlock a new pattern for grounding AI experiences in governed enterprise data—without heavy code. This session explores how low‑code makers and architects can integrate Fabric Data Agents with Copilot Studio to deliver accurate, contextual, and secure AI interactions across Teams and Power Platform. Learn practical patterns, tradeoffs, and design considerations for building data‑aware copilots that reason over lakehouses, warehouses, and semantic models while preserving simplicity and governance.
Orchestrating MCP Servers: Azure DevOps + Power BI + Fabric for Agentic Workflows
Modern teams are experimenting with Model Context Protocol (MCP) servers, but most demos stop at single-server capabilities. This session goes deeper—showing how to orchestrate multiple MCP servers to automate real engineering workflows. You’ll see a practical, end-to-end scenario that connects the Azure DevOps MCP (for work items, pipelines, and repos) with the Power BI Remote MCP/Fabric MCP (for data queries, semantic models, and report refresh) to create a closed loop: code changes trigger DevOps actions, telemetry rolls into Fabric/Power BI, and insights feed back to improve delivery. We’ll cover architecture choices, security boundaries, and governance patterns you can take to production. By the end, you’ll have a blueprint for multi-MCP orchestration that accelerates delivery, improves observability, and keeps compliance front-and-center. The session balances live demos with design guidance so you can adapt the patterns to your stack—whether you’re starting with Power BI models or consolidating analytics under Fabric. Attendees leave with artifacts and checklists to replicate the scenario and extend it to Terraform, Git, and other MCP servers.
End-to-End Data in Low Code
We will take an FinOps Industry example of a Profit and Loss statement and create an incremental refresh protocol solely using low-code.
- Learn how to create a data pipeline with parametrized outputs directly in source control.
- Create a medallion architecture with dataflows.
- Limit SQL and Python where possible to democratize data engineering.
- Best practices around building semantic models, especially in GL scenarios.
DAX/Power Query & Dataverse: Making Power BI Work for Dataverse
Anyone who has worked to bolt-on Power BI reports on a Dataverse-grounded project has dealt with these three problems: multi-select fields, audit history, and dynamically selecting columns in your query. In the UI, there are also requests that ask for an excel-like output with things like blank rows, categories, and differing aggregations that matrices are not designed for. Moreover, the data model is already fairly firm before reporting requirements are even generated.
Let’s instead embark on a two-pronged process: how data analysts ideally collaborate with Power Platform architects in the nascent stages of the application build, and how do analysts smooth conflicts between UI requirements and reporting requirements when they arise. Get equipped to develop in tandem with common Dataverse development patterns that are harder than they appear in Power BI.
Mastering Migrations to Dataverse: Data, Documents, and Security
Enterprise app builders, are you ready to conquer the challenges of data migration? We’ll dive into the essential tools and techniques for seamless data migration, covering everything from polymorphic fields to Business Units, Teams, and the systemuser table, all of which cause significant headaches when shaping data from a source to a target regarding security modeling.
Discover how to maintain a robust security model during migration and tackle common obstacles head-on such as multi-select columns, filling and cleaning Excel-based data, normalizing data, and understand how to avoid triggering automations. We’ll share insights on the entire migration process, including data UAT and go-live strategies, ensuring you’re well-prepared for success.
Join me to transform your data migration experience and unlock the full potential of Dataverse with the legacy data too!
Low-Code CI/CD: Tooling, Event Hooks, and Fusion Development
This session will demystify the processes, empowering developers to confidently configure, understand, and participate in CI/CD workflows using a fusion development esthetic.
Explore how Power Automate serves as the perfect environment for implementing event hooks with to maintain consistent practices across all applications, from simple Canvas Apps to complex Model-Driven Apps with Power Pages. We’ll walk through the nascent steps of deploying your first pipeline to showing complex use cases that include source control through GitHub and pull-request-lite practices using Azure DevOps and Microsoft Teams Approvals.
We’ll delve into best practices for choosing and using deployment systems, addressing limitations, and exploring extensibility options. By treating governance as an integral part of development, you’ll ensure that your pipeline is both robust and adaptable.
Join us to elevate your development process, streamline deployments, and embrace the future of low-code CI/CD.
M365 Community Days - Saint Louis Sessionize Event
Please note that Sessionize is not responsible for the accuracy or validity of the data provided by speakers. If you suspect this profile to be fake or spam, please let us know.
Jump to top