No articles matched your search.
Try a different keyword, or to browse all articles.Agent 365 Governance: Query the Agent Registry with PowerShell
You can’t govern what you can’t enumerate. A governance-focused, copy-paste walkthrough for listing every Copilot agent in your tenant and pulling one agent’s details via the Agent 365 Graph Package Management API — the foundation for attestation, dedupe, and lifecycle reviews.
Enterprise AI Hub, Part 7: IaC, CI/CD & the Operating Model
Make the platform repeatable with modular Bicep and a gated dev-staging-prod pipeline using GitHub Actions and OIDC, then define the operating model — golden-path onboarding and guardrails — that turns architecture into an adopted product.
Enterprise AI Hub, Part 6: Observability & Cost
Turn the gateway's token metrics into per-spoke dashboards, distributed tracing, and proactive alerts — then build the FinOps chargeback model that makes shared AI spend fair, visible, and accountable.
Enterprise AI Hub, Part 5: Identity & Security
Replace every key and connection string with managed identities and granular RBAC — the spoke-to-gateway-to-model identity chain, least-privilege data-plane roles, per-spoke isolation, and local auth disabled.
Enterprise AI Hub, Part 4: The AI Gateway
Put Azure API Management in front of Azure OpenAI as an AI gateway: per-spoke token limits, semantic caching, token metering, managed-identity backend auth, and load-balanced failover — five cross-cutting problems solved in one policy.
Enterprise AI Hub, Part 3: The Shared AI Services
Deploy the shared services — Azure OpenAI with model deployments, AI Search for RAG, ADLS Gen2, the model registry, and Key Vault — behind private endpoints and configured for safe, multi-tenant sharing across every spoke.
Enterprise AI Hub, Part 2: The Network Landing Zone
Build the hub-and-spoke network — VNets and subnets, peering, private endpoints, private DNS zones, and deny-all NSGs — so no AI service is ever reachable from the public internet.
Enterprise AI Hub, Part 1: From AI Experiments to a Governed Platform
Why every team building its own AI stack leads to duplicated cost, key sprawl, and governance gaps — and how the centralized hub-and-spoke pattern turns those one-off battles into a foundation every initiative inherits.
Azure Content Understanding, Part 3: The Boundary Problem — Too Much or Too Little
Under-extraction, over-extraction, and how to diagnose which failure you have. A field-level case study that walks through three rounds of description iteration to reach a stable, reliable boundary definition.
Azure Content Understanding, Part 2: Writing Deterministic Field Descriptions
Why vague descriptions fail on edge cases and how to write ones that produce the same output every time — covering anchoring, scope, inclusion rules, exclusion rules, and null cases with before-and-after examples.
Azure Content Understanding, Part 1: extract vs generate — Choosing the Right Method
Why a single word in a field schema — extract vs generate — causes non-deterministic document extraction, and a decision framework for choosing the right method for every field.
GitHub Copilot Billing, Part 3: Token Optimization & Agent Quality
How tokens really work, efficient prompting, planning large work, managing context, agent guardrails, model selection, and measuring quality alongside usage — lowering waste while raising engineering quality.
GitHub Copilot Billing, Part 2: Budgets & Alerts
Budget scopes, soft alerts vs hard stops, avoiding overlapping-budget confusion, worked pilot and production examples, the 75/90/100% thresholds, and a budget governance checklist.
GitHub Copilot Billing, Part 1: What Leaders & Teams Need to Understand
The shift from seat-based adoption to consumption awareness: what actually drives AI usage, why budgets are a visibility tool, and why usage-based billing is a shared operating model — not just a finance topic.
RAG Explained, Part 5: Retrieval, Reranking & Generation
The finale of the RAG series: choosing top-k, hybrid search and metadata filters, reranking for precision, assembling the prompt, grounded generation with citations, and how to evaluate and tune the whole system.
RAG Explained, Part 4: Vector Indexing & Similarity Search
How "closeness" between vectors is measured with cosine similarity, what a vector database does, and how approximate nearest-neighbor search (HNSW) makes million-scale search feel instant.
RAG Explained, Part 3: Embeddings & Vectorization
How text becomes a vector of numbers, why similar meanings sit close together in a "meaning map," how this beats keyword search, and how to choose an embedding model.
RAG Explained, Part 2: Chunking — Cutting Documents the Right Way
Why chunk size and overlap make or break retrieval, fixed vs recursive vs structure-aware vs semantic chunking, the role of metadata, and practical defaults — with worked examples and visuals.
RAG Explained, Part 1: The Whole Pipeline at a Glance
The opening of a five-part RAG series: the two phases (indexing and querying), the eight steps inside them, and a worked example carried through the whole series.
AB-100 Field Notes: Architecting Agentic AI Business Solutions
A practical study guide for AB-100: business outcomes first, agentic-first design, the Microsoft stack, data grounding and RAG, security and responsible AI, multi-agent orchestration, A2A and MCP, ALM, and measurable value.
PL-400 Field Notes: A Developer's Guide to the Power Platform Developer Exam
A practical study guide for PL-400: the five skill areas, configure-before-code, choosing plug-ins vs Power Automate vs Azure Functions, the plug-in execution pipeline, PCF components, solutions and ALM, and Dataverse integrations.
AZ-900: A Practical Guide to Microsoft Azure Fundamentals
A practical roadmap for passing AZ-900: cloud concepts and service models, core Azure services, security and identity, governance, pricing and cost management, SLAs, support plans, and a structured study plan.
Context Is Everything: Memory, Windows & What the AI Actually Sees
How AI context works: the context window as short-term memory, what really goes into a prompt behind the scenes, hidden system instructions, and practical ways to give the model the right background.
Grounding AI with RAG: Giving the Model the Right Context
Why AI invents answers, how retrieval-augmented generation fixes it by fetching the right documents first, and how to do a manual version yourself today in any chat assistant.
Prompting Techniques That Level You Up: Examples, Step-by-Step & Building Knowledge
A practical look beyond the basics: zero, one, and few-shot prompting, chain-of-thought step-by-step reasoning, and the generated-knowledge approach — and when to reach for each.
Six Habits of Effective Prompts: A Practical Checklist
Six repeatable habits that make any AI prompt better: clear instructions, references, breaking work into steps, letting the model think, using the right tools, and checking your results — with a before-and-after example.
What Prompt Engineering Really Is (and Why Vague Prompts Fail)
A clear guide to prompt engineering: what it is, why vague prompts produce useless answers, and how the same question gets dramatically better as you add context, role, and constraints.
Building Agentic AI with Azure AI Foundry: Agents, Tools & Orchestration
What agentic AI really means and how to build it on Azure AI Foundry: the Agent Service, threads and runs, tool calling, grounding with knowledge, multi-agent orchestration, tracing, and evaluation.
Building Agents with Copilot Studio: Topics, Knowledge & Actions
Build low-code AI agents in Copilot Studio: authored topics and trigger phrases, generative answers grounded on your data, calling flows and connectors, and generative orchestration.
Power Platform Governance & ALM: Environments, Solutions, Pipelines
Run Power Platform like a pro: environment strategy, managed vs unmanaged solutions, environment variables and connection references, Pipelines, and DLP policies.
Dataverse Data Modeling: Tables, Columns & Relationships
Model business data properly in Dataverse: tables and columns, data types, choices, keys, 1:N and N:N relationships, rollups, business rules, and the row-level security model.
Power Automate Cloud Flows & Approvals, End to End
Design real-world cloud flows: trigger types, the Approvals connector, Start and wait for an approval, branching on outcomes, expressions, and resilient Try/Catch error scopes.
Power Apps Canvas Fundamentals: Screens, Controls & Power Fx
Build your first canvas app the right way: data sources, galleries and forms, Power Fx formulas, variables and collections, delegation pitfalls, and Patch.
From SharePoint Search to RAG: Indexing, Enrichment & the Road to AI Retrieval
How classic SharePoint Search concepts — crawling, managed properties, and content enrichment — map directly onto modern vector search and Retrieval-Augmented Generation pipelines.
Performance & Governance Best Practices for Modern SharePoint
Taming the 5,000-item list view threshold, indexed columns, throttling (429s), and a practical governance checklist for SharePoint Online at enterprise scale.
Securing a Custom API for SPFx with Azure AD & Azure Functions
End-to-end token flow: register an Azure AD app, expose a scope, call it from SPFx with AadHttpClient, and validate the bearer token in an Azure Function backend.
Building SharePoint Solutions with Microsoft Graph API
Navigating sites, lists, and drives through Graph — resolving site IDs, working with list items and files, and using delta queries to track changes efficiently.
Integrating SharePoint with Power Automate: Patterns & Pitfalls
Trigger conditions, concurrency control, the Send an HTTP request to SharePoint action, and how to avoid infinite trigger loops in production flows.
Column & View Formatting with JSON — No Code Required
Transform list columns and views with declarative JSON: conditional colors, data bars, action buttons, and hyperlinks, all without deploying a single custom component.
SharePoint Webhooks at Scale with Azure Functions
The validation handshake, managing subscriptions and their 180-day expiry, and processing change notifications reliably with GetChanges and a storage queue.
Repeatable Site Provisioning with the PnP Provisioning Engine
Capture a site as a reusable template, parameterize it with tokens, and re-apply it across tenants — plus where site designs and site scripts fit in.
Theming & Fluent UI in SPFx: Building Accessible Web Parts
Consume the section theme via IReadonlyTheme, react to theme changes, and build web parts that look native in any SharePoint site or section background.
Securely Calling Microsoft Graph from SPFx
Using MSGraphClientV3 and AadHttpClient, requesting API permissions in the package manifest, and the tenant-level approval flow in the API access page.
SPFx Extensions: Application Customizers, Command Sets & Field Customizers
Inject persistent headers and footers, add commands to list toolbars, and render custom field markup — the three extension types every modern SharePoint dev needs.
Building SPFx Web Parts with React & PnPjs
Wire up a React web part, read and write list data fluently with PnPjs, and use the property pane to make your component configurable for site owners.
Getting Started with the SharePoint Framework (SPFx)
Set up the toolchain (Node, Yeoman, gulp), scaffold your first client-side web part, understand its anatomy, and test it in the local and hosted workbench.
JSLink & Client-Side Rendering for Custom List Views
Before SPFx, JSLink let us override how fields and views rendered with pure JavaScript. A look at the CSR pipeline — still useful for classic sites today.
Remote Event Receivers in Provider-Hosted Add-ins
Moving server-side event logic to the cloud: wiring up remote event receivers, handling the SOAP notification payload, and why webhooks became the better path.
Mastering the SharePoint REST API
CRUD against lists and items, shaping payloads with $select and $expand, the request digest, and trimming response bloat with OData metadata levels.
PowerShell for SharePoint Developers & Consultants
From the SharePoint Online Management Shell to PnP PowerShell — bulk provisioning lists and fields, automating site lifecycles, and scripting content types.
Migrating from Full-Trust Farm Solutions to the Add-in Model
Why full-trust code became a dead end, how provider-hosted add-ins work with OAuth and ACS, and a pragmatic strategy for refactoring legacy WSP solutions.
CSOM Deep Dive: Batching Requests for Performance
How the Client-Side Object Model batches operations, why one well-formed ExecuteQuery beats ten chatty ones, and patterns for throttling-safe bulk work.
Building Robust SharePoint Server-Side Event Receivers
Synchronous vs. asynchronous events, avoiding the dreaded recursion loop with EventFiringEnabled, and writing event receivers that don't break under load.