Design Dataverse data models and build model-driven apps: tables, relationships, forms, views, business rules, business process flows, and role-based security.
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.