Dataverse is the cloud database that powers serious Power Apps — but only if you understand how it's organized. This lesson teaches you exactly how tables, columns, and rows work together, with hands-on exercises and real business examples that build genuine competence from scratch.
Learn how to design production-quality Dataverse schemas using the right relationship types, lookup configurations, and choice columns. This lesson goes beyond the basics to cover cascade behavior, referential integrity, and the lookup-vs-choice decision that determines your app's long-term maintainability.
Learn how to build a complete model-driven app from scratch — designing tables, configuring forms with subgrids and quick views, creating operational views, and building a site map that organizes everything into a deployable, role-aware application. This is the deep-dive lesson that teaches you to think in model-driven architecture, not just click through a designer.
A cluttered model-driven form kills adoption before your app ever gets a chance. Learn how to design professional forms using tabs, sections, subgrids, and Quick View forms — the building blocks that turn raw Dataverse data into a tool people actually want to use.
Views are the primary lens users interact with in model-driven apps — and most of them are badly designed. Learn how to build purpose-built views with multi-condition filters, strategic sort orders, FetchXML for complex queries, and editable grids for inline record editing.
Business Rules in Dataverse let you enforce data quality and control form behavior without writing a single line of code—but scope, condition logic, and action types have sharp edges that trip up even experienced makers. This lesson goes deep on every mechanism so you can build rules that actually work in production.
Business Process Flows (BPFs) transform inconsistent, documentation-dependent workflows into structured, in-form guidance that enforces data quality at every stage. Learn how to design, build, and deploy BPFs that actually guide users — including branching logic, stage-gating, and security configuration.
Learn how to architect a production-grade Dataverse security model using business units, custom security roles, owner teams, access teams, and AAD-linked teams. This complete lesson covers real-world design patterns, privilege configuration, and troubleshooting for multi-team organizations.
Table-level security controls who can access records, but real production environments often need finer control — down to individual columns and specific records. This lesson teaches you how to implement Field Security Profiles, configure column-level access, and use record sharing to grant targeted exceptions without restructuring your entire security model.
Learn how to embed business logic directly into your Dataverse data model using formula columns and rollup columns. Build margin calculations, pipeline aggregates, and deal status signals — no code, no flows required.
Stop making users leave the record to trigger their most-needed actions. Learn how to add custom buttons, write dynamic visibility rules, and call Power Automate flows directly from the model-driven app command bar using Power Fx — no JavaScript required.
Custom Pages let you embed fully expressive canvas app experiences inside model-driven apps — dashboards, bulk editors, and operational hubs that standard forms and views simply can't deliver. This lesson covers the architecture, authoring, context-passing, security, and performance patterns you need to build Custom Pages that work in production.
Duplicate records don't happen by accident — they happen when your data model doesn't have structural guardrails. Learn how to use Dataverse alternate keys and duplicate detection rules to enforce data quality at the database level, not just the UI layer.
Learn how to load data into Dataverse using Excel import, Power Query dataflows, and upsert logic with alternate keys. This deep-dive lesson covers realistic transformation scenarios, lookup resolution, sequencing for relational data, and troubleshooting the failures that actually happen in production.
Learn how to design and implement a complete Dataverse audit strategy that satisfies GDPR, SOX, and HIPAA requirements. This expert lesson covers the three-layer audit architecture, Web API queries, real-time alerting, storage management, and the common gaps that leave organizations exposed during audits.
Master the Dataverse solution framework from the ground up — publishers, prefixes, managed vs unmanaged deployment, and the layering algorithm that explains almost every mysterious behavior in multi-environment Power Platform projects. This is the architectural knowledge that separates professional delivery from accidental success.
Learn how to secure your model-driven app from the ground up. This lesson walks through creating security roles, applying column-level security profiles, and using team-based access — so the right people see exactly the right data.
A poorly structured site map makes even great apps unusable. Learn how to design navigation Areas, Groups, and Subareas from scratch — and wire them to security roles so each user sees exactly the menu they need, nothing more.
Most model-driven app problems aren't about missing features — they're about misconfigured views. Learn how to set Default Views, Quick Find Views, and Lookup Views so records are always findable, searchable, and presented with the right context wherever they appear in your app.
Learn how to configure one-to-many and many-to-many relationships in Dataverse, understand cascade behaviors that protect your data integrity, and see exactly how relationships surface inside model-driven app forms. This is the structural knowledge every Power Apps maker needs.
Standard model-driven form controls hit a wall when you need genuinely custom UX — star ratings, card layouts, traffic lights, and more. This expert lesson walks you through building, testing, and deploying real PCF field and dataset controls from scratch, with full TypeScript implementations and production deployment patterns.
Column properties are the difference between a model-driven app that produces clean, consistent data and one that's constantly fighting user errors and dirty records. This lesson teaches you how to choose the right data type, configure required fields at the right layer, and set up display settings that guide users toward correct data entry — without writing code.
Virtual tables let you surface live data from SQL Server, REST APIs, and OData services directly inside your model-driven app — no ETL, no data copy, no sync. This lesson teaches you to configure OData data sources, map columns, build cross-system relationships, and handle the security and performance challenges that come with production virtual table deployments.
Standard lookups point to one table. But real business data is messier than that — a customer might be an Account or a Contact, an expense might belong to a Project or a Department. Learn how Dataverse polymorphic lookups, Customer columns, and Regarding columns solve this cleanly, and how to configure them end-to-end in model-driven apps.
Learn how to build self-referential parent-child hierarchies in Dataverse, configure hierarchical security so managers automatically inherit access to subordinates' records, set up multi-level rollup aggregation, and display interactive tree visualizations in model-driven apps. This expert-level lesson covers the architecture, edge cases, and performance trade-offs you need to get it right.
Model-driven app dashboards give your users live, interactive summaries of Dataverse data without spreadsheets or manual reports. This lesson teaches you how to build charts, assemble system dashboards, and set them as the default app experience — step by step with a real scenario.
Misconfigured table permissions are the most common way model-driven apps go wrong after launch. This lesson teaches new makers how Dataverse security roles, privilege types, and access levels work together — with real-world examples, step-by-step role configuration, and a hands-on exercise to test your understanding.
Learn how to configure Dataverse calculated columns and rollup columns to aggregate related record data for forms, views, and business logic. Build an Account Health scoring system using real rollup and formula patterns with no code.
Native Dataverse M:N relationships fall short the moment your junction needs to carry data, enforce business rules, or support granular security. This expert-level lesson teaches you to design custom intersect tables from scratch — with columns, cascade behaviors, filtered subgrids, and validation logic that the platform's auto-generated junction table simply can't provide.
Real-time workflows in Dataverse enforce business rules at the pipeline level — blocking invalid operations regardless of whether they come from a form, an API call, or a bulk import. This lesson teaches you to design, configure, and troubleshoot synchronous workflows that genuinely enforce complex multi-condition logic without writing a single line of code.
Learn how to configure Dataverse audit logging at the organization, table, and column level — then surface that change history directly on model-driven app forms. This expert-level lesson covers storage architecture, security role configuration, API querying, and compliance patterns.
Learn how the Dataverse event pipeline really works — stages, modes, images, and filtering — and how to configure plug-in steps and business event handlers without writing code. Build systems with genuine transactional integrity and event-driven automation.
Learn how to build Quick Forms and Card Forms in Power Apps model-driven apps so users see rich, contextual summaries of related records directly inside lookup flyouts and subgrids — no navigation required. This hands-on lesson covers creating, configuring, and troubleshooting both form types from scratch.
Most Dataverse Search problems aren't data problems — they're configuration problems. This lesson teaches you exactly how to enable Dataverse Search, control which tables and columns are indexed, and tune Quick Find views so users actually find what they're looking for.
Learn how to configure Dataverse queues and routing rules to build a structured work assignment system in model-driven apps. This lesson covers queue item lifecycles, team-based distribution patterns, and automatic case routing from scratch.
Learn how to design and configure Dataverse auto-numbering columns that generate reliable, auditable record identifiers for procurement, compliance, and business process workflows. Covers format string patterns, seed management, API configuration, and production deployment strategies.
Standard lookups can't capture the full complexity of who plays what role in a relationship — a contact might be a sponsor on one project and a stakeholder on another. This lesson teaches you how to design, configure, and deploy Dataverse connection roles for real-world professional scenarios, including reciprocal pairs, table restrictions, form surfaces, and security.
Environment variables are the key to building Power Platform solutions that deploy cleanly across dev, UAT, and production without manual edits. This deep-dive lesson covers the full lifecycle: creating typed variables, managing the default/current value split, binding connection references, and injecting overrides at deployment time using Power Platform CLI and deployment settings files.
When your Dataverse tables grow to tens of millions of rows, standard optimization tricks stop working. This lesson teaches you the architectural decisions — elastic tables, partition key strategies, TTL, and time-series patterns — that determine whether your model-driven app scales or buckles under production load.
Managed properties are Dataverse's mechanism for declaring exactly what downstream consumers can modify after your managed solution is installed — and most ISVs configure them wrong. This expert-level lesson covers the full component taxonomy, XML-level configuration, solution layering interactions, and a practical boundary strategy for building platform-grade solutions.
Learn how Dataverse activity tables really work — the Activity base table, Activity Party model, and Regarding polymorphic lookup — and build a fully configured Timeline control for your model-driven app, including custom activity types and security-aware visibility. This is the lesson that turns the Timeline from a mystery into a deliberate design choice.
Dataverse choice columns are simple dropdowns on the surface—but the decisions you make about global vs. local option sets, multi-select behavior, and dependency filtering determine whether your data model stays coherent as your app scales. This lesson teaches the internals, the patterns, and the pitfalls that experts need to know.
Learn how to configure Dataverse column mappings so that child records created from parent forms automatically inherit field values through the relationship — eliminating repetitive data entry and improving data quality in model-driven apps. This lesson covers type compatibility rules, step-by-step configuration, runtime behavior, and programmatic use via InitializeFrom.
Monolithic Power Platform solutions create fragile, risky deployments — but splitting customizations across solutions requires understanding how Dataverse tracks component ownership, resolves layer conflicts, and enforces dependencies. This deep-dive lesson teaches you how to design a layered solution architecture, manage cross-solution dependencies safely, and build an ALM pipeline where teams can ship independently without stepping on each other.
Learn how to embed a custom page inside a model-driven form, pass the host record's ID as context, surface related Dataverse data using Power Fx, and wire navigation so users stay inside the model-driven shell. A complete, production-ready walkthrough with a hands-on client dashboard exercise.
Learn how Dataverse actually stores file attachments, full-size images, and binary content — and how architectural decisions you make at design time determine whether your app scales or hits a storage wall. This lesson covers Image columns, File columns, Notes attachments, SharePoint integration, and Azure Blob patterns with realistic capacity planning examples.
Cascade rules determine what happens to child records when you assign, share, delete, or reparent records in Dataverse — and misconfiguring them is the source of some of the most baffling data quality and security issues in production model-driven apps. This lesson teaches you how each of the five cascade actions works, when to use Parental vs. Referential vs. Custom behavior, and how to configure and troubleshoot cascade rules across multi-level table hierarchies.
Access team templates let you grant per-record permissions dynamically — without creating new security roles or managing individual record shares. This deep-dive lesson covers template configuration, form integration, Power Automate automation, and the performance trade-offs you need to know before deploying at scale.
Every Dataverse record has a lifecycle — but without configuration, users can jump between stages in ways that break your business rules. Learn how to define meaningful Status Reason values, enable transition enforcement, and build a governed record lifecycle that the system itself polices. Practical, from first principles, with a full hands-on exercise.
Most Business Process Flow implementations barely scratch the surface of what's possible. Learn how to build branching multi-path BPFs, enforce true stage gates at the data layer, scope stages to related Dataverse tables, and lock records when they reach completion — all in a realistic contract qualification scenario.
Table-level security isn't granular enough when you need to hide salary data from managers who can see the rest of an employee record. This lesson teaches you how Dataverse Column Security Profiles work architecturally, how to create and configure them, and how to assign them across security roles, teams, and users — including the edge cases that silently break integrations and audit trails.
Learn how to write and register JavaScript event handlers for model-driven app forms in Dataverse. This hands-on lesson walks through OnLoad, OnSave, and OnChange events with realistic business logic, the formContext API, and step-by-step registration in the form designer.
Learn how to configure Dataverse webhooks and Azure Service Bus bindings that fire when table events occur in your model-driven app. This lesson covers endpoint registration, step filtering, entity images, authentication, and production deployment patterns for real integration scenarios.
Learn how to build production-quality Dataverse dataflows with Power Query transformations that reliably sync external data into model-driven app tables. Covers upserts, alternate key mapping, incremental refresh, multi-table dependencies, and operational monitoring — everything you need to run a pipeline a team can trust.