Power Apps Model Driven Apps Structured Business Solutions
Canvas apps let you design every screen from scratch. Model-driven apps take the opposite approach — they build themselves automatically from the structure of your data. You define the data model in Dataverse, and Power Apps generates a complete, consistent application interface for you. The result is a professional, feature-rich app that looks and behaves like Microsoft Dynamics 365 — because it uses the exact same underlying technology.
This topic explains what model-driven apps are, when to use them instead of canvas apps, and how to build one that serves real business needs.
Canvas Apps vs. Model-Driven Apps: The Core Difference
Picture two architects working on a building. The first architect designs everything from scratch — every room, every wall placement, every window position. This is a canvas app. The second architect works with a system that automatically generates a building from the floor plan — rooms appear in standard positions, every floor follows the same layout, and changes to the plan update all floors simultaneously. This is a model-driven app.
CANVAS APP vs. MODEL-DRIVEN APP ┌──────────────────────────────┬──────────────────────────────┐ │ CANVAS APP │ MODEL-DRIVEN APP │ ├──────────────────────────────┼──────────────────────────────┤ │ You design every screen │ App generates from data model│ │ Complete visual control │ Consistent, standard UI │ │ Great for custom workflows │ Great for data management │ │ Pixel-perfect layouts │ Complex relationships shown │ │ Works on all devices easily │ Best on desktop/tablet │ │ You place every control │ Forms auto-build from tables │ │ Canvas = Freedom │ Model = Structure │ │ │ │ │ Example: Field inspection │ Example: CRM, case tracking, │ │ app with custom steps │ HR records management │ └──────────────────────────────┴──────────────────────────────┘
When to Choose Model-Driven
Choose a model-driven app when your users need to manage complex, interrelated data — many tables with relationships between them. A customer relationship management system with Accounts, Contacts, Opportunities, and Cases is a classic model-driven scenario. HR systems, help desk solutions, and project tracking platforms also fit naturally. When the data model is complex and the UI needs to reflect that complexity without custom design work, model-driven apps save enormous development time.
The Model-Driven App Architecture
Every model-driven app consists of three layers that work together.
MODEL-DRIVEN APP LAYERS
┌─────────────────────────────────────────────────────┐
│ LAYER 3: APP │
│ (Sitemap + which tables, views, forms are included)│
└───────────────────────────┬─────────────────────────┘
│ built from
┌───────────────────────────▼─────────────────────────┐
│ LAYER 2: UI COMPONENTS │
│ Views (lists) │ Forms (records) │
│ (How records are listed│ (How one record is shown)│
└───────────────────────────┬─────────────────────────┘
│ reads from
┌───────────────────────────▼─────────────────────────┐
│ LAYER 1: DATAVERSE │
│ Tables, Columns, Relationships, Rules │
└─────────────────────────────────────────────────────┘
The Dataverse tables and columns are the foundation. Views and forms sit on top — they define how data appears in lists and how individual records look when opened. The app itself sits at the top — it brings together the tables, views, and forms you select, organized through a navigation structure called a sitemap.
Views: How Records Appear in Lists
A view is a saved query that defines which records to show and which columns to display in a list. Every model-driven app shows records in views — think of them as filtered, sorted columns of a table.
Types of Views
A Public View is visible to all users and appears in the app by default. A Personal View is created by a user for their own use. A System View is built in by Microsoft for standard functionality — like "All Active Accounts" or "My Active Cases." A Quick Find View defines which columns are searched when a user types in the search bar.
What a View Looks Like
SERVICE REQUESTS – OPEN (View)
┌─────────────────────────────────────────────────────────────────┐
│ ☐ │ Request Title │ Priority │ Status │ Created On │
├────┼────────────────────┼──────────┼──────────┼─────────────────┤
│ ☐ │ Printer not working│ High │ Open │ 01 Jun 2025 │
│ ☐ │ Access to HR system│ Medium │ Open │ 02 Jun 2025 │
│ ☐ │Email password reset│ Low │ Open │ 03 Jun 2025 │
└────┴────────────────────┴──────────┴──────────┴──────────────────┘
[< Prev] 1 – 3 of 3 [Next >]
Filter bar appears at top, sort by clicking any column header
To create or edit a view, go to make.powerapps.com, click Tables, select your table, then click Views. Click New view or select an existing one to edit. Add columns by dragging them from the right panel into the view. Sort and filter conditions apply automatically when the view loads.
Forms: How Individual Records Look
When a user clicks on a record in a view, a form opens showing that record's full details. Forms are the most customizable part of model-driven apps — you design which fields appear, how they are arranged, and which tabs organize them.
Form Types
The Main Form is the primary editing interface — full-featured, multi-tab, used for creating and editing records. The Quick View Form appears inside another form as a read-only snapshot of a related record. The Quick Create Form is a compact panel for fast record creation without opening the full form. The Card Form is used in views and dashboards to show a record summary.
Form Layout Anatomy
MAIN FORM: Service Request ┌────────────────────────────────────────────────────────────┐ │ SERVICE REQUEST: Printer not working [Save] [Close] │ ├────────────────────────────────────────────────────────────┤ │ [GENERAL TAB] [NOTES TAB] [HISTORY TAB] │ ├──────────────────────────────┬─────────────────────────────┤ │ SECTION: Request Details │ SECTION: Assignment │ │ │ │ │ Title: Printer not working │ Assigned To: Raj Kumar │ │ Priority: [High ▼] │ Team: IT Support │ │ Status: [Open ▼] │ Due Date: 05 Jun 2025 │ │ Description: │ │ │ The printer on Floor 3... │ │ └──────────────────────────────┴─────────────────────────────┤ │ SUBGRID: Related Comments │ │ ┌──────────────────────────────────────────────────────┐ │ │ │ Date │ Comment │ By │ │ │ │ 01 Jun 2025 │ Device is HP LaserJet │ Priya Sharma │ │ │ └──────────────────────────────────────────────────────┘ │ └────────────────────────────────────────────────────────────┘
Notice the subgrid at the bottom of the form. This shows all related records (Comments related to this Service Request) directly inside the parent form. Model-driven apps handle these relationship-based displays automatically — canvas apps require significant formula work to achieve the same result.
Building a Model-Driven App Step by Step
Step 1: Prepare Your Data Model in Dataverse
Before building the app, make sure your Dataverse tables, columns, and relationships are ready. The app's quality depends entirely on the quality of the underlying data model. At minimum, define the tables your app will use, all the columns each table needs, the relationships between tables (lookup columns), and any required business rules and choices.
Step 2: Create the App
Go to make.powerapps.com and click Create from the left sidebar. Click Model-driven app from blank. Give the app a name (for example, "IT Help Desk"). Choose your Dataverse environment. Click Create. Power Apps opens the model-driven app designer.
Step 3: Add Tables to the Sitemap
The app designer shows a canvas with a Navigation panel on the left. Click Add page to add a new page. Select Dataverse table. Pick your table from the list (for example, Service Requests). Power Apps adds the table to the app with default views and forms. Repeat for each table your app uses.
Step 4: Customize Views and Forms
Click on a table page in the app designer, then click Edit for its Views or Forms. The view editor lets you add, remove, and reorder columns. The form editor lets you drag fields into sections and tabs, group related fields visually, and add subgrids for related records.
Step 5: Configure the Sitemap
The sitemap is the navigation structure of your app — the left sidebar that users see when they open it. By default, each table gets its own entry. You can organize tables into groups (called Areas and Groups in the sitemap editor) to create logical sections — for example, an "Operations" area containing Service Requests, Assets, and Technicians, and a "Reports" area containing dashboards.
SITEMAP STRUCTURE EXAMPLE (IT Help Desk App)
App
├── Area: Operations
│ ├── Group: Tickets
│ │ ├── Service Requests (table)
│ │ └── Comments (table)
│ └── Group: Resources
│ ├── Assets (table)
│ └── Technicians (table)
└── Area: Reporting
└── Dashboards
Step 6: Save and Publish
Click Save, then click Publish. The app is now available to share. Click Play to open and test the app immediately. To share it, click the back arrow to return to the apps list, find your app, click the three-dot menu, and choose Share. Add users or teams by email or security group.
Dashboards in Model-Driven Apps
Model-driven apps include built-in dashboards that display data from multiple views and charts on one screen. Users see their key information at a glance when they open the app.
Types of Dashboard Components
A List shows records from a view. A Chart shows visual data aggregations (bar charts, pie charts, line charts). An iFrame embeds an external web page. An IFrame can embed a Power BI report, giving you live analytics inside your model-driven app without any code.
System Charts
Each table in Dataverse can have System Charts — pre-built visualizations based on that table's data. For example, a Service Requests table might have a chart showing "Cases by Priority" as a donut chart and "Cases Opened This Month" as a bar chart. These charts appear in views (click the Charts icon in the top-right corner of a view) and on dashboards.
Business Process Flows: Guiding Users Step by Step
A Business Process Flow (BPF) is one of the most powerful features in model-driven apps. It appears as a horizontal progress bar at the top of a record form, guiding users through a defined sequence of stages and steps.
BUSINESS PROCESS FLOW: Sales Opportunity [QUALIFY] ──▶ [DEVELOP] ──▶ [PROPOSE] ──▶ [CLOSE] ● ○ (Active stage) (Not reached) At QUALIFY stage, required steps: ☑ Confirm interest ☑ Estimated budget captured ☐ Decision maker identified [Move to Develop Stage →]
Each stage contains steps — fields the user must fill or actions they must complete. Users cannot advance to the next stage until the current stage's required steps are done. This is perfect for sales pipelines, approval processes, onboarding workflows, and any multi-step business process where consistency matters. BPFs are configured in make.powerapps.com under the Flows section — they work exclusively in model-driven apps.
Model-Driven Apps and Security
Model-driven apps respect Dataverse security roles at every level. A user who has only "Read" permission on the Accounts table sees accounts in read-only view — the form opens but all fields are grayed out. The Create and Delete buttons are hidden automatically. A user with "Create" and "Write" permissions sees editable forms and active action buttons. You do not write any code to implement this security behavior — Dataverse and the model-driven app handle it automatically based on the user's security role assignment.
Customizing the Look and Feel
Model-driven apps do not offer pixel-by-pixel design control like canvas apps, but you can customize their appearance in meaningful ways. Themes control the header color, accent color, logo, and font of the entire app. Apply a theme from the app designer by going to Settings and choosing Themes. Custom icons give each table a distinct icon in the sitemap. Table display names change the labels that appear in the app's UI without changing the underlying table name in Dataverse.
Component Library and PCF Controls
Power Apps Component Framework (PCF) controls let developers extend model-driven apps with custom-built controls — richer data visualizations, interactive components, and specialized input fields that standard model-driven controls do not include. PCF controls are installed from AppSource (Microsoft's app marketplace) or built by your development team. Business users import PCF controls through Solutions and add them to forms without writing code. If you ever see a control in a model-driven app that looks unusually rich — like an interactive calendar, a custom signature pad, or an advanced map view — it is almost certainly a PCF control.
Key Points
- Model-driven apps build their UI automatically from Dataverse tables and columns — you design the data model, and the app follows.
- Use model-driven apps for complex, data-heavy scenarios with many related tables: CRM, help desk, HR, project management.
- Views define how records appear in lists. Forms define how individual records appear when opened.
- The sitemap is the navigation structure of your app — organize it into Areas and Groups for clarity.
- Business Process Flows guide users through multi-step processes with stages and required steps.
- Security roles from Dataverse control what each user sees and can do in the app automatically — no code needed.
- Dashboards show multiple charts and lists on one screen. Power BI reports can be embedded directly into dashboards via iFrame.