Most Active Speaker

David Lorenzo

David Lorenzo

Microsoft MVP Business Apps | AI @ Automation Architect at Prodware

Microsoft MVP Business Apps | AI @ Automation Architect at Prodware

Adeje, Spain

Actions

Since 2010 delivering value in the Microsoft ecosystem: .NET web development, designing and building solutions in Azure. Since 2021, more focused in the Power Platform and Artifical Intelligence world.

Desde 2010 entregando valor en el ecosistema Microsoft: desarrollo web .NET y diseño y construcción de soluciones en Azure. Desde 2021, más enfocado en el mundo de Power Platform y la Inteligencia Artificial.

Badges

  • Most Active Speaker 2025
  • Most Active Speaker 2024

Area of Expertise

  • Information & Communications Technology

Topics

  • Power Platform ALM
  • Power Platform
  • Microsoft Power Apps
  • Microsoft Power Automate
  • Power Automate
  • Microsoft Power Virtual Agents
  • Power Platform - Low Code
  • Power Platform Copilot
  • Power Platform Canvas Apps
  • Power Platform - Code First
  • Power Apps
  • Power Apps Portals
  • Azure
  • Azure Data & AI
  • OpenAI
  • Azure OpenAi
  • Azure OpenAI Service
  • .NET
  • .NET Backend
  • dotnet core
  • .NET (Core) development
  • dotNet

Low-Code Meets AI: Building Powerful D365 Agents Without Writing Code

WHAT You'll Learn
- What AI agents are and how they outperform traditional chatbots with generative AI and orchestration
- Navigating Microsoft Copilot Studio's low-code visual canvas for rapid agent design
- Building an agent from scratch: Set instructions, triggers, add knowledge (e.g., SharePoint/Dataverse), and define topics
- Grounding agents in Dataverse to query Dynamics 365 data (e.g., customers, accounts, orders, inventory via RAG)
- Adding no-code tools for record creation, data updates, and workflow triggers (using connectors or Power Automate flows)
- Publishing agents to Teams, demo sites, Microsoft 365 Copilot, or embedding in D365 apps

HOW We'll Do It
- Intro: Demo a live agent handling a D365 customer query to showcase real impact
- Platform Tour: Walk through Copilot Studio's interface, drawing parallels to Power Apps/Platform tools
- Agent Creation: Start blank, define purpose, add SharePoint as knowledge source, test topics
- D365 Connection: Link to Dataverse, query sample customers/accounts/cases with secure RAG
- Tools: Add actions to create cases, update records, and trigger a sample flow—all no-code
- Publish & Deploy: Publish to Teams channel, embed in a demo site, and run end-to-end live test
- Q&A + Next Steps: Share docs, tutorials, and community links for your first solo build

WHY It Matters
- Stay Ahead: AI integration is table stakes for D365 roles; master it or lag behind
- No-Code Access: If you build in Power Apps, you'll own agents in hours—not weeks
- Speed Wins: Prototype and iterate solo, ditching dev backlogs
- Cut Costs: Automate routine D365 tasks 24/7, slashing support tickets by 30-50% (per Microsoft benchmarks)
- Boost Career: Deliver AI solutions that wow stakeholders and open doors

WHO Should Attend
- D365 Functional Consultants (BC, CE, F&O)
- Business Analysts & Power Platform Makers
- D365 Admins & IT Pros
- Project Managers/Solution Architects
- Non-coders curious about AI in D365

KEY TAKEAWAYS
1. Hands-On Confidence: Walk away ready to build/test your first agent, step-by-step
2. D365-AI Mastery: Know how to query/update Dataverse securely for real business data
3. Ready Ideas: Practical starters like service desks, inventory checks, or order routing
4. Low-Code Limits: Spot when to loop in devs (e.g., custom APIs) vs. handle solo
5. Go-Further Kit: Curated links to Microsoft Learn paths, templates, and forums

MCP C# SDK 2.0: everything that changed and how to make the most of it - Hands-On Demo

MCP has become the standard way to connect AI agents with our applications, and version 2.0 of the C# SDK changes quite a few things. The most important one: the protocol goes stateless. There is no initialization handshake or Mcp-Session-Id anymore, so an MCP server now behaves like any other ASP.NET Core application. You can put it in a container, place it behind a load balancer, and scale it out without worrying about sticky sessions.
Throughout the session we will walk through the new features using a real example: an order management MCP server that we will keep extending live.
- First the basics: a working server in just a few lines of code, and several instances answering requests behind a load balancer with .NET Aspire, with no special configuration.
- The new standardized HTTP headers: with one attribute on a tool parameter, a gateway can route calls by region without having to look at the request body. MCP finally plays nicely with the HTTP infrastructure you already have.
- If there is no session, how does the server ask the user for something in the middle of an operation? Enter Multi Round-Trip Requests, the headline feature of this version. We will see a tool that stops, asks for confirmation, and finishes the job when the client resends the call with the answer. And we will look at the traffic to see how it works under the hood.
- We will also try the two new extensions: Tasks, for long-running tools with polling, and MCP Apps, so the server can display user interface inside the client.
- And to wrap up, the practical side of migration: what keeps working from the previous version, what is marked as obsolete, the breaking changes, and how old clients coexist with new servers without having to upgrade everything at once.

Plan, execute, approve: a deep dive into the Microsoft Agent Framework Agent Harness

A language model, on its own, only generates text. For it to plan, use tools, remember what it has done, and act without making mistakes, it needs a set of control tooling around it: what everyone now calls the harness.
Until recently, you had to build it yourself. Since July 2026, Microsoft Agent Framework ships it built in and stable, also in .NET.
In this session we will build an agent live, starting from scratch and adding pieces one at a time to understand what each one brings:
- We start with a basic agent that can only chat, and see why that is not an agent. Then we add the harness and the important parts show up: the automatic loop, persistent history, and context compaction when the conversation gets long.
- We try plan mode and execute mode: the agent first thinks and writes its task list, you review it and correct it if needed, and only then do you let it run. The framework keeps reinvoking it on its own until everything pending is done.
- We give it access to the shell and the file system with human approvals in between: we will watch the agent propose commands and wait for our go-ahead before touching anything. This is where an agent goes from toy to a tool you can let loose with some peace of mind.
- We look at CodeAct: instead of chaining twenty tool calls for a procedural task, the agent writes code, runs it in a sandbox, and returns the result in a single pass.
- We add skills the agent loads on demand, and watch everything happening under the hood with the built-in telemetry.
- And we close with the path to production: how that same agent gets packaged and deployed to Foundry as a Hosted Agent, with scale to zero and state that survives restarts.
The session is hands-on from start to finish, with the goal that you leave knowing what the harness in Microsoft Agent Framework gives you for free, what you have to configure yourself, and when it pays off versus building the loop on your own.
Key Takeaways:
- What an agent harness actually is and why it is the most important part of any agent
- How to build agents with HarnessAgent in .NET: loop, planning, memory, and context compaction out of the box
- How to add human-in-the-loop with approvals over the shell and file system
- What CodeAct is and when running code is cheaper than chaining tool calls
- The path from localhost to production with Hosted Agents in Foundry

Plan, Execute, Approve: A Deep Dive into the Microsoft Agent Framework Agent Harness

On its own, a language model only generates text. To make it plan, use tools, remember what it has done, and act without making mistakes, it needs a set of controls around it: what everyone now calls the harness.

Until recently, you had to build it yourself. Since July 2026, Microsoft Agent Framework ships it built in and stable, in .NET too.

In this session we’ll build an agent live, starting from scratch and adding one piece at a time to understand what each one brings:

We start with a basic agent that can only chat, and see why that isn’t really an agent. Then we add the harness, and the important parts appear: the automatic loop, persistent history, and context compaction when the conversation gets long.
We try plan mode and execution mode: the agent first thinks and writes its task list, you review it and correct it if needed, and only then do you let it execute. The framework keeps re-invoking it on its own until every pending task is done.
We give it access to the shell and the file system, with human approvals in between: we’ll watch the agent propose commands and wait for our go-ahead before touching anything. This is where an agent goes from toy to a tool you can let run on its own with some peace of mind.
We look at CodeAct: instead of chaining twenty tool calls for a procedural task, the agent writes code, runs it in a sandbox, and returns the result in a single pass.
We add skills that the agent loads on demand, and watch everything happening inside with the built-in telemetry.
And we close with the path to production: how that same agent is packaged and deployed to Foundry as a Hosted Agent, with scale to zero and state that survives restarts.

The session is hands-on from start to finish. The goal is for you to leave knowing what the Microsoft Agent Framework harness gives you, what you need to configure yourself, and when it’s worth using it instead of building your own loop.

Key Takeaways:

- What exactly an agent harness is and why it’s the most important part of any agent
- How to build agents with HarnessAgent in .NET: loop, planning, memory, and context compaction built in
- How to add human-in-the-loop approvals for the shell and file system
- What CodeAct is and when running code is cheaper than chaining tool calls
- The path from localhost to production with Hosted Agents in Foundry

Supercharge Your E-Commerce with AI: Power Pages + Copilot Studio in Action

In this session, we’ll explore how to build an e-commerce assistant for Power Pages using Copilot Studio.

We’ll demonstrate how to create an online store with Power Pages, including features like a shopping cart, product management, and order handling.
We’ll build a shopping assistant using Copilot Studio. This assistant will enhance the customer’s buying experience by answering questions and providing detailed product information. It will also interact with the shopping cart, allowing users to add or remove products.
We’ll dive into how to enable this interaction through a full integration between the Copilot Studio Agent and Power Pages using the JavaScript DirectLine SDK. We’ll use context variables to detect the user’s current page and product, enabling personalized interactions.

The Virtual Entity Way: Inivisble paths, infinite reach.

En esta sesión explicaremos cómo dominar las entidades virtuales en Dataverse para aprovechar al máximo la integración de sistemas externos en Power Platform de una manera fluida.

- Exploraremos cómo habilitar Entidades Virtuales de SharePoint para crear un portal de administración utilizando aplicaciones basadas en modelos en Dataverse. Usaremos lookups para gestionar relaciones entre las listas de SharePoint y poder editarlas desde Dataverse.

- Habilitaremos la integración de Entidades Virtuales de Business Central con Dataverse y las expondremos en un sitio de Power Pages para demostrar cómo realizar operaciones CRUD desde un sitio de Power Pages que se integra directa y perfectamente con Business Central. También aprenderemos cómo asegurar que los datos no se expongan más allá de sus límites mediante la configuración de filtros personalizados.

- Finalmente, exploraremos la integración de Entidades Virtuales de SQL Server creando una Power Apps Canvas para gestionar los stocks de productos en un e-commerce. Las tablas de productos están ubicadas en una base de datos SQL Server, mostraremos cómo gestionar los diferentes aspectos de la integración.

En los tres casos utilizamos casos de uso reales para potenciar la adopción de esta tecnología en proyectos reales.

The Team of Agents Behind My Blog: Inside a Production Microsoft Agent Framework System

Most multi-agent demos are a chat loop with a system prompt. This session is a real system that has been shipping for months.

powerplatformninja.com is my technical blog: 2,000-word deep dives on Power Platform and Azure AI engineering, for people who already ship real solutions. Every post follows a house style — a contents list, five to seven sections, a “What to watch carefully” critical-reading section, a “My take” close, cited sources — and that style is exactly what makes it automatable. A crew of seventeen agents orchestrated with Microsoft Agent Framework on Azure AI Foundry now researches, outlines, writes, fact-checks, illustrates and pushes each article into WordPress. Nothing auto-publishes: the crew’s job ends at a draft plus a review report, and I press Publish. Then the system learns from what I changed.

We’ll walk the actual graph. Fan-out/fan-in across three research scouts and two independent validators. Two bounded feedback loops — re-research and revise — and why there is deliberately no third. Conditional entry points that resume a failed run from saved research instead of paying for it twice. A human-in-the-loop approval split across two separate graphs, so no worker is ever held open waiting for a person.

The rule underneath all of it: agents produce typed judgements; code makes every routing decision. Every agent is bound to a structured output contract, and the gates between them are plain, testable logic.

Then the rare part: a supervised self-learning loop. The system diffs its own draft against what I actually published, scores the edit rate, clusters what recurs, and proposes configuration changes — but replays every candidate rule against everything already published first. A rule that fires on text the human shipped is a false positive by construction.

Finally, the production scars: the SDK contract that fails only on real infrastructure, the token meter attached at the wrong seam, and the bug that silently unsubscribed a live recipient.

The Virtual Entity Way: Invisible Paths, Infinite Reach

In this session we will explain how master virtual entities in Dataverse, to unleash the power of integrating external systems into Power Platform in a seamless way.

- We’ll explore how to enable Sharepoint Virtual Entities to make an administration portal using Model-Driven apps in Dataverse. We will use lookups to manage relations between the Sharepoint lists and be able to edit them from Dataverse side.

- We will enable Business Central Virtual Entities integration with Dataverse and expose them on a Power Pages site to demonstrate how we can make CRUD operations from a Power Pages site that integrates directly and seamlessly with Business Central. We’ll also learn how to ensure the data is not exposed out of its boundaries using the customer filter configuration.

Finally, we’ll explore SQL Server Virtual Entities integration by creating a Power Apps Canvas to manage product stocks in an ecommerce. The products tables are located in SQL Server Database and we'll reach them through Virtual Entities, showing the audience how to manage the different aspects of the integration.

In all 3 cases we use real uses cases to empower the adoption of this technology in real projects over the world.

Two Ways to Automate: Agent Flows and Computer Use in Copilot Studio

What
A full-day, hands-on workshop that goes deep into two of the most powerful and distinct automation capabilities inside Copilot Studio — Agent Flows and Computer Use. Attendees build the same real-world automation scenario twice, using each approach independently, then analyze the architectural trade-offs, performance characteristics, and governance implications of both. By end of day they have hands-on experience with both capabilities and a clear decision framework for choosing between them on any future project.

Why
Agent Flows and Computer Use represent fundamentally different philosophies of automation — one structured and API-driven, the other adaptive and UI-driven. Most practitioners have experimented with one or the other, but rarely have they had the structured time and guidance to go deep on both simultaneously. Without that comparative experience, architects and developers make technology choices based on familiarity rather than fit — and that costs projects time, money, and maintainability. This workshop fixes that by giving attendees the rare opportunity to build, compare, and critically evaluate both approaches in a controlled, expert-guided environment.

How
The day is structured as six progressive lab modules:
1. Architecture overview — how Agent Flows and Computer Use work under the hood, where each fits, and where each breaks down
2. Building the automation scenario with Agent Flows — triggers, conditions, actions, and error handling
3. Extending Agent Flows with advanced patterns — parallel branches, loops, adaptive cards, and human-in-the-loop approvals
4. Rebuilding the same scenario with Computer Use — UI interaction, screen recording, element targeting, and fallback handling
5. Stress-testing both approaches — performance, failure modes, maintainability, and governance implications
6. Decision framework workshop — mapping real-world automation requirements to the right approach using a structured evaluation model

Each module combines a structured demo with a hands-on lab, and module 6 uses real scenarios brought by attendees to make the decision framework immediately practical.

Who
Power Platform developers, RPA specialists, automation architects, and consultants who are evaluating or actively adopting agentic automation capabilities in enterprise environments. Skill level 300-400. Prerequisites: solid working knowledge of Copilot Studio, familiarity with Power Automate cloud flows, basic understanding of UI automation concepts desirable but not mandatory.

Top 3 Key Takeaways
1. Deep hands-on experience with both Agent Flows and Computer Use — built on a real automation scenario — giving you the practical confidence to architect and deliver either approach on your next project.
2. A structured decision framework for evaluating any automation requirement against both approaches — covering technical fit, governance risk, maintainability cost, and long-term scalability.
3. A clear understanding of where each approach breaks down in production — failure modes, edge cases, and governance boundaries that only emerge when you push both capabilities beyond the happy path.

Work IQ APIs + Copilot Studio: Agents That Understand How Your Organisation Works

What
A demo-driven session showing how to connect Copilot Studio agents to the Work IQ APIs — now generally available — to give agents a real-time semantic understanding of your organisation built from emails, meetings, documents, chats, and people, accessed through just 10 MCP tools.
Why
Most agents today answer questions from static knowledge bases — they have no understanding of how work actually happens in your organisation right now. Work IQ APIs change that by giving agents access to a continuously updated intelligence layer that knows who is working on what, what decisions were made last week, and how your organisation's people and projects connect. This session shows how to wire that intelligence into a Copilot Studio agent using MCP — without building custom connectors or managing data pipelines.
How
• Work IQ API architecture — what the intelligence layer contains, how it builds semantic understanding from M365 signals, and how the 10 generic MCP tools expose it to agents without hundreds of data-specific connectors
• Live demo — a Copilot Studio agent using Work IQ APIs via MCP to answer 'what is the current status of Project X?' by reasoning across emails, meeting notes, documents, and people in real time
• Context API walkthrough — how to use the Context API to retrieve pre-aggregated M365 context in an agent-optimised format that reduces tokens and round trips
• Copilot Credits consumption model — how Work IQ API usage is metered and how to estimate costs for production agent workloads
• Q&A on API setup, MCP configuration, licensing, and production deployment
Who
Copilot Studio developers, solution architects, and M365 platform leads building agents that need real organisational intelligence beyond static knowledge sources. Microsoft 365 tenant with Copilot licences required. Skill level: 300.
Prerequisites
• Solid hands-on experience with Copilot Studio agent actions and MCP connections
• Microsoft 365 tenant with Copilot licences
• Basic familiarity with REST APIs and MCP concepts
Top 3 Key Takeaways
1. A practical understanding of how Work IQ APIs give Copilot Studio agents real-time access to organisational intelligence — people, projects, decisions, and collaboration patterns — through just 10 MCP tools.
2. Live demonstration of a Copilot Studio agent answering complex organisational queries using live M365 context — showing what genuinely context-aware enterprise agents look like in production.
3. A clear picture of the Work IQ API consumption model and configuration steps needed to connect a Copilot Studio agent to the Work IQ intelligence layer in your own M365 tenant.

Two Ways to Automate: Agent Flows and Computer Use in Copilot Studio

Overview
This session covers two automation capabilities in Microsoft Copilot Studio: agent flows and computer use. Attendees will see how agent flows automate workflows and how computer use enables agents to interact with websites and desktop applications.
What You Will See
Agent Flows (Generally Available)

Agent flows are automated sequences of actions triggered by specific events or conditions
Agent flows can be triggered manually, by other automated events or agents, or based on a schedule
Two creation methods: natural language description or visual designer with drag-and-drop components
Agent flows follow a deterministic path, ensuring that input produces the same output
To add an agent flow to an agent as a tool, it must have the "When an agent calls the flow" trigger and a "Respond to the agent" action
Action types include AI capabilities (generate text, run a prompt, process documents) and human-in-the-loop actions (approval requests)
Agent flows are billed through Copilot Studio based on consumption without requiring a separate Power Automate license
Existing Power Automate cloud flows can be converted to agent flows

Computer Use (Public Preview)

Computer use is a tool in Copilot Studio that lets agents interact with and automate tasks on a Windows computer
Computer use works with websites and desktop apps by selecting buttons, choosing menus, and entering text into fields on the screen
Powered by Computer-Using Agents (CUA), an AI model that combines vision capabilities with advanced reasoning to interact with graphical user interfaces
Because it is AI-powered, it adapts to interface changes; when buttons or screens change, the tool continues working without breaking the flow
Describe tasks in natural language; no coding required
Works with browsers including Edge, Chrome, and Firefox, and desktop applications
Hosted browser option powered by Windows 365 requires no machine setup
Existing machines used to run desktop flows can also be used for computer use
Use cases include automated data entry, invoice processing, and data extraction
Available for environments where the region is set to United States
Each computer use action costs five Copilot Credits

Who Should Attend
Developers, Power Platform implementers, and solution architects working with Copilot Studio automation capabilities.

When Your Multi Agent System Has to Speak Out Loud

WHAT
Imagine saying "find me a hotel in Rome for two, and something to do if it rains". From that one conversation you get a booking, a map and a day by day plan. We built that assistant.

A Copilot Studio orchestrator listens to the traveller and hands each request to the right specialist agent:

a hotel agent that books rooms in Dataverse through Power Automate
a local discovery agent that chains location and places lookups
a logistics agent for flights, weather and currency
a destination expert that runs in Azure AI Foundry with AI Search and Code Interpreter

We also built a second version: a speech to speech concierge on GPT Realtime over WebRTC that you can interrupt while it talks. This session shows both, running live.

WHY
Adding a microphone to a multi agent system changes more than the input box:

Nobody wants to hear six flights read out loud.
Every second of silence feels like something broke.
People interrupt.
The keys that call your agents must never reach the browser.

Most teams also get stuck on a question that sounds simple: should this agent live in Copilot Studio or in Foundry? Our answer was both, each doing what it does best, and we'll explain why.

HOW
We start with a live voice conversation and then show what's underneath it. You will see:

how the orchestrator picks an agent using nothing more than that agent's description
how a Foundry agent joins a Copilot Studio orchestrator as a connected agent
how agent events update a map and a quotation panel on screen, while a model shortens long answers into one spoken sentence

Then we switch to the realtime concierge and compare the two voice designs side by side: speed, interruptions, grounding and how easy each is to change. Everything we show is in public GitHub repositories.

WHO
Makers, developers and architects who build agents on the Microsoft stack. It suits people who want to add voice, and people deciding between low code and pro code for each agent. Knowing some Copilot Studio or Azure AI Foundry helps, but you don't need any voice experience.

KEY TAKEAWAYS

- A multi agent pattern where a low code orchestrator routes to specialists in Copilot Studio and Azure AI Foundry, and how to decide where each agent belongs.
- Why agent descriptions are the real routing logic, and how to write them so the orchestrator chains tools by itself.
- Two voice designs, a speech to text and text to speech pipeline versus realtime speech to speech, and when to choose each.
- Designing for the ear: speak the short answer and show the details on screen.
- How to keep every secret out of the browser with short lived tokens.
- The fallbacks that keep a live voice assistant working when one piece fails.

Hands On Making your own MCP Server with .NET

En esta sesión práctica de live coding, usaremos .NET para crear un servidor MCP que exponga una API personalizada a agentes de IA.
Realizaremos una demo paso a paso:
1. Crearemos un proyecto de servidor MCP en .NET para exponer nuestros endpoints de API.
2. Probaremos nuestro servidor MCP usando GitHub Copilot en VS Code.
3. Compilaremos el proyecto y lo publicaremos en Azure.
4. Nos conectaremos a nuestro servidor MCP en Azure usando Copilot Studio y lo consumiremos en un proyecto real.
¡No te pierdas esta oportunidad de ver lo fácil que es lograr esta integración en solo unos minutos!

Hands On Making your own MCP Server with .NET

In hands on live coding session, we use .NET make an MCP server to expose a custom API to AI Agents.

We’ll go through a step-by-step live demo:

1. We’ll create an MCP Server project in .NET to expose our API endpoints.
2. We’ll test our MCP Server using GitHub Copilot in VS Code.
3. We’ll compile the project and publish it to an Azure Function.
4. We’ll connect to our Azure Function MCP server using Copilot Studio and consume it in a real project.

Don't miss out this opportunity to see how easy is to get this integration done in just a few minutes!

Forge your Multiagent Army: Power Copilot Studio with Azure AI Foundry

In this session, we'll learn how to integrate Copilot Studio with Azure Services like Azure AI Foundry and Azure AI Search.

We will create a multi-agent using Copilot Studio and Azure AI Foundry with multiple capabilities, mixing pro-code and low-code worlds in a fusion team integration.

- We'll show how to integrate Copilot Studio with Dataverse using Power Automate flows through actions, leveraging the AI Orchestrator the power to decide when to use them. We'll implement a complete Hotel Reservation process to create a Hotel Reservation Assistant chatbot.

- We will show how to compose an Azure AI Search index through an agent that will do a webscrapping of web content using AI parsing to extract destination activities description, enhance them using Azure AI Foundry and fill the Azure AI Search Voctor Index on the fly. We'll integrate this index with the Hotel Reservation Assistant chatbot using Azure AI Search Knowledge Sources.

- We'll touch Dynamic Chaining concept by implementing a Nearby Restaurants Finder using Custom Connectors that integrates with Geocoding and Places API. This will allow us the orchestration engine to find places coordinates and then use them to find nearby restaurants.

- We'll also add Speech-to-text and Text-to-speech capabilities to the assistant, using DirectLine integration to expose the chatbot in a website, then use MediaRecorder Javascript APIs to capture user voice and play chatbot messages. Additionally, we use Azure AI Foundry with speak and speech features to convert text to audio and audio to text, creating a full voice experience for the chatbot.

- Finally, we integrate some useful travel APIs like flight information, weather, touristic destination information, and so on.

All this will be story-telled by a Travel Assistant wrapper, that will allow us to connect the different pieces of technology in a centralized system.

Dynamic Chaining en Copilot Studio

En esta sesion explicaremos qué es el dynamic chaining en copilot studio, qué beneficios obtenemos con respecto a la lógica tradicional de chatbots, y veremos en una demo como ponerlo en práctica de una forma sencilla.

La fuerza de los Componentes en Power Apps

En esta sesión, veremos qué son los componentes en Power Apps (Canvas y Model-Driven), para qué se usan y que ventajas nos dan a la hora de construir nuestras aplicaciones y reutilizarlos en futuros desarrollos.
En la DEMO, Crearemos un componente en directo explicando el paso a paso, el uso de parámetros para configurar su comportamiento, su adicion a una libreria de componentes reutilizable y su uso en la creación de aplicaciones Canvas y Model-Driven.

Mezcla lo mejor de cada casa con HybridCache en ASP.NET Core

En esta sesión, explicaremos las ventajas que proporciona esta librería para mejorar el rendimiento en applicaciones ASP.NET, al combinar el uso de Memory Cache y Distributed Cache. Mostraremos algunos ejemplos de uso en una sesión de demostración.

Concepto de Caché Híbrida: HybridCache combina diferentes tipos de almacenamiento en caché, como memoria local (en el servidor) y un caché distribuido (como Redis o Memcached). Esto permite que las aplicaciones aprovechen la rapidez del acceso en memoria junto con la persistencia y escalabilidad de un caché distribuido.

Ventajas:

Velocidad y Escalabilidad: Al utilizar memoria local, se reduce la latencia en la obtención de datos. Al mismo tiempo, el caché distribuido permite compartir el estado entre múltiples servidores, lo que mejora la escalabilidad.
Redundancia y Fiabilidad: Si el caché distribuido no está disponible, la memoria local puede seguir sirviendo solicitudes, ofreciendo redundancia.
Configurabilidad: Los desarrolladores pueden configurar cómo y cuándo utilizar cada tipo de caché según las necesidades de la aplicación.
Uso Común:

Ideal para aplicaciones web que requieren un rendimiento elevado y operan en entornos con múltiples servidores.
Se puede usar para almacenar datos que se consultan con frecuencia, como resultados de consultas de base de datos, configuraciones, o datos de sesión.
Integración con ASP.NET:

HybridCache se integra fácilmente con el ecosistema de ASP.NET, permitiendo utilizar la infraestructura existente de caching y mejorándola con un enfoque híbrido.
En resumen, HybridCache es una solución poderosa para manejar el almacenamiento en caché en aplicaciones ASP.NET, combinando lo mejor de ambos mundos: la rapidez del caché en memoria y la escalabilidad de un caché distribuido.

.NET Hybrid Cache - Mix the best of each house

In this session, we will explain the advantages that this library provides to improve performance in ASP.NET applications, by combining the use of Memory Cache and Distributed Cache. We will show some usage examples in a demo session.

Hybrid Cache Concept:
HybridCache combines different types of caching, such as local memory (on the server) and a distributed cache (such as Redis or Memcached). This allows applications to take advantage of the speed of in-memory access along with the persistence and scalability of a distributed cache.

--------------------

Advantages:

- Speed ​​and Scalability:
By using local memory, latency in obtaining data is reduced. At the same time, distributed cache allows state to be shared among multiple servers, which improves scalability.

- Redundancy and Reliability:
If the distributed cache is not available, local memory can continue to serve requests, providing redundancy.

- Configurability:
Developers can configure how and when to use each type of cache based on the needs of the application.

--------------------

- Common Uses:
Ideal for web applications that require high performance and operate in multi-server environments.
It can be used to store data that is frequently queried, such as database query results, configurations, or session data.

- Integration with ASP.NET:
HybridCache easily integrates with the ASP.NET ecosystem, allowing you to use your existing caching infrastructure and enhance it with a hybrid approach.

In short, HybridCache is a powerful solution for handling caching in ASP.NET applications, combining the best of both worlds: the speed of in-memory caching and the scalability of a distributed cache.

Crea un asistente de reservas de hotel con Copilot Studio

En esta sesión veremos como podemos crear un asistente de reservas usando Copilot Studio, extendiendo su funcionalidad mediante Actions y un Custom Connector que conectará con nuestra API de reservas de hotel.

Dispara tus Pipelines nativas al siguiente nivel

En esta sesión veremos como extender la funcionalidad de las Power Platform Pipelines nativas, añadiendo automatizaciones para: exportar la solución a Azure DevOps, enviar solicitudes de aprobación del despliegue, configurar el despliegue con usuario de servicio.
Con esto conseguimos optimizar el trabajo del desarrollador, que no tendrá que subir manualmente el código a DevOps, así como del arquitecto, que no tendrá que ejecutar manualmente los despliegues.

Launch your pipelines to the next level

Learn how to extend power platform pipelines using power automate to:
- Automate solution export to Azure DevOps Repository
- Add delegated deployments
- Add deployment approvals
Your power platform pipelines will get the next level!

Construye tu Copilot con .NET y Azure

En esta sesión veremos cómo construir tu propio Copilot para consultar tus propios datos. Usaremos .NET para construir la aplicación de chat y para gestionar la ingesta de documentos al copilot.
Además, usamos una arquitectura en Azure que incluye Azure Search, Azure OpenAI, Azure Document Intelligence, Blob Storage y Functions.

Copilot Studio - Create a Hotel Reservation Assistant

In this session, we'll learn how to create a hotel reservation assistant using Copilot Studio. We will learn how to use copilot studio actions to connect an external hotel reservation API in order to integrate our assistant with the Hotel Reservation System that allows us to get hotels availability in an area or get availability of a specific accommodation. We can get the final prices for a specific stay, and of course it will allow us to confirm a reservation.

Boost performance: Best Practices to fin-tune .NET code

In this session, we will show the importance of understanding performance bottlenecks in our code.
We'll show how to use tools like Benchmark.NET and Performance Profiler in Visual Studio to identify and address inefficiencies in the code.
We will also discuss how to use code generators, avoid unnecessary allocations, recommended uses of "Switch" versus alternatives, and many other topics.

This is a 100% practical session where we will fine-tune and optimize our code.

.NET: Buenas Prácticas para un Código Impecable

En nuestra sesión mostraremos la importancia de comprender los cuellos de botella en el rendimiento y entender cómo usar herramientas como Benchmark.NET y el Performance Profiler de Visual Studio para identificar y abordar ineficiencias. Tambien hablaremos de como usar generadores de código, asignaciones innecesarias , usos recomendados de "Switch" frente a alternativas,y muchas mas cosas. Sesión 100% práctica donde afinaremos y pondremos a punto nuestro código.

Caching to Survive - Optimiza tu web app con caché multinivel para alto rendimiento

En esta sesión veremos como aplicar distintos niveles de caché en aplicaciones web y APIs desarrolladas en .NET:

**Output Cache**

Aplicamos Output Cache para conseguir que el front genere claves de caché todas las URLs, evitando que se tengan que volver a regenerar en cada petición. Veremos como aplicar variaciones de caché y generar secciones parciales no cacheables para permitir personalizaciones por usuario

**Response Cache**

Aplicamos ResponseCache a nivel de API para generar claves de caché para todos los endpoints, permitiendo además generar las variaciones necesarias para admitir toda la funcionalidad sin perder rendimiento.

**Redis Cache**

Mejoramos la resiliencia de nuestra aplicación añadiendo un nivel de caché en Redis, de forma que sobreviva a reinicios de la aplicación y se pueda compartir entre instancias.

**DEMO**

En la demo explicaremos la arquitectura e implementación de la solución, y realizaremos un benchmarking con pruebas de carga donde veremos la diferencia de rendimiento de una solución sin caché y otra con caché.

Build your own Copilot with .NET y Azure

In this session we will see how to build your own Copilot to query your own data. We will use .NET to build the chat application and manage the document ingestion.
Additionally, we'll implement a RAG architecture in Azure that includes Azure Search, Azure OpenAI, Azure Document Intelligence, Blob Storage and Functions.

Boost Copilot Studio using Azure AI Search

In this session we will learn how to boost your copilot studio generative AI responses by connecting it to Azure Search through Azure Open AI. In this way, we can create our own index configuration in Azure AI Search, using semantic ranking to prioritize the content that is more relevant to our users.

Power Apps + Sharepoint para hacer apps atractivas en minutos

La idea principal es montar un modelo de datos con listas de Sharepoint relacionadas, para luego crear una Canvas App responsive, en pocos minutos. Con un look & feel atractivo y con una buena arquitectura.

Copilot Tournament: Copilot Studio vs Custom Copilot

En esta sesión mostraremos 2 Copilots uno hecho con Copilot Studio y otro hecho a medida con Azure. Los pondremos a competir para ver cuál es mejor en función de diferentes situaciones y explicaremos como implementar cada uno de ellos.

Di adios a la delegación en Sharepoint usando Graph API

Sesión en la que veremos cómo crear una Canvas App que realiza búsquedas en listas de Sharepoint con más de 2000 elementos, y eliminamos el problema de la delegación mediante el uso de Graph API.

Integración Continua con ALM Accelerator

Explicaremos como conseguir una integración y despliegue continuo en nuestros desarrollos de Power Platform usando ALM Accelerator. Integramos high-code (PCFs y Plugins) y low-code (Solutions) en una sola base de código y automatizaremos los despliegues entre entornos.

Power Pipelines

Mostraremos como configurar Azure DevOps para gestionar el ciclo de vida de nuestra soluciones de Power Platform. Gestionar los repositorios para low-code / high-code. Crear y configurar pipelines para despliegue de soluciones entre entornos DEV, UAT y PRO.

ALM Accelerator - Git Flow con Azure DevOps y Power Platform

Sesión donde veremos como implementar Git Flow para conseguir integración y despliegue continuo (CI/CD) en Power Platform, usando ALM Accelerator.

Construye tu Copilot con .NET y Azure

En esta sesión veremos cómo construir tu propio Copilot para consultar tus propios datos. Usaremos .NET para construir la aplicación de chat y para gestionar la ingesta de documentos al copilot.
Además, usamos una arquitectura en Azure que incluye Azure Search, Azure OpenAI, Azure Document Intelligence, Blob Storage y Functions.

Singapore Microsoft Azure, M365 & Power Platform User group Sessionize Event

August 2026

European Power Platform Conference (EPPC26) Sessionize Event

June 2026 Copenhagen, Denmark

Agent Camp 2026 Sessionize Event

April 2026 Málaga, Spain

Canadian Power Platform Summit 2026 Sessionize Event

March 2026 Vancouver, Canada

DynamicsCon Regional: Pacific Northwest 2026 Sessionize Event

March 2026 Vancouver, Canada

AgentCamp 2026 - Milan - Winter Edition Sessionize Event

March 2026

Global Power Platform Bootcamp 2026 Sessionize Event

February 2026

Global Dynamics 365 Bootcamp 2026 Sessionize Event

February 2026

Global Power Platform & Agent Bootcamp 2026 Sessionize Event

February 2026

Tenerife Winter Sessions 2026 Sessionize Event

February 2026

.NET Conf 2025 - .Net Baires Sessionize Event

December 2025

Christmas Power Data Platform 2025 Sessionize Event

December 2025

Festive Tech Calendar 2025 Sessionize Event

December 2025

Academyverso 2025 Sessionize Event

November 2025 Madrid, Spain

AgentCon Ponferrada Sessionize Event

November 2025 Ponferrada, Spain

Cloud Bootcamp Colombia 2025 Sessionize Event

October 2025

Azure Tour 2025 - Tenerife Sessionize Event

October 2025 Santa Cruz de Tenerife, Spain

Bizz Summit ES 2025 Sessionize Event

October 2025 Madrid, Spain

Cyber Back to School 2025 Sessionize Event

October 2025

Nordic Summit 2025 Sessionize Event

September 2025 Göteborg, Sweden

Azure Back to School 2025 Sessionize Event

September 2025

AgentCon 2025 - Berlin Sessionize Event

June 2025 Berlin, Germany

Canadian Cloud Summit 2025 Sessionize Event

June 2025

Power Summit 2025 - Power Platform & AI Agents Sessionize Event

May 2025 London, United Kingdom

Global Azure 2025 - Madrid Sessionize Event

May 2025 Madrid, Spain

Evento de datos Valencia 2025 Sessionize Event

May 2025 Valencia, Spain

NetCoreConf Barcelona 2025 Sessionize Event

April 2025 Barcelona, Spain

Microsoft Learn Zero to Hero Community User group Sessionize Event

July 2024, December 2024

Low Code/ No Code Power Platform Conference Sessionize Event

November 2024

2024/2025 Monthly Power Platform UX/UI A11ys User Group Call User group Sessionize Event

October 2024

Bedrock Tech Talks VIRTUAL User group Sessionize Event

June 2024

Power Platform Learner to Leader User group Sessionize Event

April 2024

NetCoreConf Barcelona 2024 Sessionize Event

March 2024 Barcelona, Spain

Global AI Bootcamp 2024 Sessionize Event

March 2024 Madrid, Spain

Microsoft 365 Live 2023 Sessionize Event

November 2023

Bizz Summit ES 2023 Sessionize Event

September 2023 Madrid, Spain

Global Azure 2023 - Spain Sessionize Event

May 2023

Global Power Platform Bootcamp Madrid 2023 Sessionize Event

February 2023 Madrid, Spain

David Lorenzo

Microsoft MVP Business Apps | AI @ Automation Architect at Prodware

Adeje, Spain

Actions

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