Model Driven Apps in Power Apps – How to Build

When you work with Power Apps, you usually start with Canvas Apps, where you design the layout and user experience from scratch. However, if you want to build apps that focus more on your data and business processes, consider Model-Driven Apps.

Model-Driven Apps let you build powerful, data-centric applications without writing much code. Instead of designing every screen manually, you define your data model, and Power Apps automatically generates the interface based on that model.

In this article, I will tell you everything you need to know about Model-Driven Apps in Power Apps. Also, we will learn:

• What is Power Apps Model-Driven App
• Key benefits of using Model-Driven Apps
• What we need before creating Power Apps Model-Driven Apps
• How to create a Model-Driven App
• Compare Model-Driven Apps and Canvas Apps in Power Apps

Model Driven Apps in Power Apps

A Model-Driven App is a type of app in Power Apps that focuses on your data model and business logic, rather than the app’s custom layout or design.

When you build a Model-Driven App, you don’t have to design each screen manually like you do in a Canvas App. Instead, you define your tables (entities), relationships, views, forms, business rules, and process flows in Dataverse, and Power Apps automatically generates a responsive and consistent user interface for you.

This type of app is ideal when your solution requires:

• Managing complex data relationships
• Enforcing business rules
• Working with structured forms and views
• Using built-in features like filtering, sorting, and searching

Model-driven apps are commonly used in enterprise environments, particularly for scenarios such as customer service, sales tracking, case management, HR systems, and other internal business processes.

Check out: Create a Plan Using Power Apps Plan Designer

Benefits of Model-Driven Apps in Power Apps

Model-Driven Apps are perfect when your business needs go beyond simple forms and buttons. Here are some reasons why you should consider creating Model-Driven Apps:

1. Automatically Fully Responsive App: No need to worry about how our app will look on different devices. Model-Driven Apps are responsive out of the box. Whether we open it on a desktop, tablet, or phone, the layout adjusts perfectly without any extra effort from your side.
2. Focus on data, not design: With Model-Driven Apps, we don’t have to design every screen. Build our data model using Dataverse, including tables, relationships, and views, and Power Apps will automatically generate the interface for us.
3. Built-in logic and process automation: We can easily add business rules and workflows to guide users through tasks.

Requirements to Create Model-Driven Apps

Before creating a Model-Driven App, ensure you have a few key basics in place. Unlike Canvas Apps, Model-Driven Apps depend on Dataverse and some environment-level setup. Here’s what you need:

1. Access to Power Apps (with appropriate license): To build Model-Driven Apps, you need a valid Power Apps license.
2. Power Platform environment with Dataverse: Model-Driven Apps run on Microsoft Dataverse. So, your environment must have Dataverse provisioned.
3. Table(s) in Dataverse: You must have at least one table (entity) in Dataverse. Our app will utilize these tables to generate views, forms, dashboards, and other content.
4. Security roles or permissions: You need the proper permissions to create apps and tables in the environment. If you’re not the administrator, ask your administrator to assign you a role, such as Environment Maker, or grant you the necessary permissions.

Create a Power Apps Model-Driven App

Let’s see how to create a Model-Driven App from scratch. To make things easier to understand, I’ll use a simple business scenario.

Imagine you’re part of a company’s Customer Support team, and you want to build a system to manage customer service tickets. The support team needs to track who submitted a ticket, what the issue is, and whether it’s been resolved or is still pending.

Each ticket must be assigned to a support agent, and there should be a way to monitor the status and priority of each request.

Let’s see how you can create a Model-Driven App in Power Apps for this scenario, using Dataverse, custom views, and forms.

Create a Dataverse Table in Power Apps

First, we need to create a Dataverse table to store customer ticket data.

1. Go to Power Apps and select your environment. From the left navigation, click on Tables.
2. Click on “+ New table” and name it Support Tickets.
3. Add the following columns:
   • Customer Name (Single line of text)
   • Issue Summary (Single line of text)
   • Description (Multiple lines of text)
   • Assigned To (Lookup -> Users)
   • Priority (Choice: Low, Medium, High)
   • Status (Choice: New, In Progress, Resolved, Closed)
   • Expected Resolution Date (Date only)

Every ticket will be stored here along with its status and assignment details.

Create a Custom View in Dataverse Table

Once your table is ready and all the necessary columns are added, the next step is to create a custom view. Views enable you to display filtered lists of records, such as high-priority open tickets or tickets assigned to a specific agent.

Here we’ll create three custom views for our Support Ticket system. Each view will display tickets based on different filters, enabling users to find what they need quickly.

Dataverse View 1: High Priority Tickets

This view displays all open tickets marked as High Priority, allowing managers and agents to focus on urgent issues.

Follow the steps below:

1. Open the Support Tickets table in Power Apps. Click the Views under the Data experiences section.

Read: Create Multi Agent in Copilot Studio

2. Click + Create a view. Name the view: High Priority Tickets

3. Add these columns:
   • Issue Summary
   • Customer Name
   • Assigned To
   • Status
   • Priority
   • Created Date

4. Add filters:
   • Priority = High
   • Status ≠ Resolved and Status ≠ Closed

Read: Add Copilot Studio Knowledge Files Using Power Automate

5. Then click ‘Save and Publish‘ the view.

Dataverse View 2: Tickets Assigned to Lidia (One user)

This view will help agents see only the tickets assigned to them.

1. In the Support Tickets table, create a new view named: Tickets Assigned to Me
2. Add columns:
   • Issue Summary
   • Description
   • Status
   • Created Date
3. Add filter:
   • Assigned Agent = Lidia

Check out: Create Autonomous Agents in Copilot Studio

Dataverse View 3: Newly Created Tickets

This view displays the ticket status as ‘new’, which helps the manager.

1. Create a new view named: Recently Created Tickets.
2. Add columns:
   • Issue Summary
   • Customer Name
   • Priority
   • Created Date
3. Add filter:
   • Status = Resolved
4. Click ‘Save and Publish’ to view.

Create a Custom Form in a Dataverse Table

In Model-Driven Apps, forms are used to view, create, or update individual records. You don’t need to design forms from scratch, as in Canvas Apps; select the columns, sections, and layout, and Power Apps handles the rest.

Since we are creating a Customer Support Ticketing System, you can begin with the main form for submitting issues, which has already been created.

Here, I will create a view for support agents.

1. Go to Tables in Power Apps, and open the Support Tickets table. Click on the Forms tab.
2. Click + New Form -> choose Main form. Name the form: Agent Ticket Form. Click the create button.

3. Add columns:
   • Issue Summary -> read-only
   • Description -> read-only
   • Priority -> read-only
   • Expected Resolution Date -> read-only
   • Assigned To
4. Then click ‘Save and Publish‘ the Form.

This way creates a Form in a Dataverse Table.

Create a Solution in Power Apps

To build a Model-Driven App, you should first create a solution. A solution is like a container that holds everything related to your app: tables, forms, views, flows, business rules, and the app itself.

1. Go to Power Apps and select your environment. In the left navigation pane, click on Solutions.
2. Click + New solution. Enter a Display name, like Support Ticket Solution. Choose a Publisher.
3. Click Create.

4. Inside your new solution, expand Add existing -> Table.
5. Search the Support Tickets table, then click Add.

Create Model-Driven App in Power Apps

Once your solution and Dataverse table are ready, it’s time to create the actual Model-Driven App that users will interact with. This app will consolidate your tables, forms, and views, and Power Apps will automatically manage the layout and responsiveness.

1. In your solution, click + New -> App -> Model-driven app.

2. Give your app a Name, like Customer Support App.
3. Add a Description, such as:
   • An internal tool to manage and track customer support tickets.
4. Click Create.

This opens the modern app designer, where you can start building your app’s pages and navigation.

Add a Table as a Page in Model-Driven App

1. Click + Add page.
2. Choose ‘Datavers Table‘.
3. Select the Support Tickets table (which you created earlier).
4. Click Next.

5. Click the Save button (top right).
6. Then click Publish to make your app live.
7. Finally, click Play to test your app in a new tab.

Then our App will look like the screenshot below.

In the Model-driven app, we are not allowed to add data directly. Check the GIF below.

Let’s assign the ticket to lidia using the Agent Ticket Form

This way, you can create a Model-Driven App: Create a Dataverse table, add columns, build views and a custom form, then create a solution, add the table to it, and use the modern app designer to build and publish your app.

Canvas Apps vs Model-Driven Apps in Power Apps

Power Apps gives you two main ways to build applications: Canvas Apps and Model-Driven Apps. Let’s compare them to help you choose the right one for your project.

Feature	Canvas App	Model-Driven App
Design Approach	Design-first (you control the layout)	Data-first (layout is auto-generated from the data model)
Custom UI Control	Full control over every screen, button, and layout	Limited customization, consistent layout
Data Source	Can use various sources (SharePoint, SQL, Excel, etc.)	Primarily built on Dataverse
Best for	Mobile-friendly, pixel-perfect apps	Business apps with structured processes and workflows
Responsiveness	Requires effort to make responsive	Automatically responsive on all devices
Code Logic	Uses Power Fx formulas	Uses business rules, workflows, and process automation
Learning Curve	Easier to start for designers	Easier for data-driven scenarios and enterprise solutions

In this tutorial, we learned how to create a Model-Driven App in Power Apps using a real-life customer support scenario. We started by creating a Dataverse table, adding columns, building custom views and forms, and then utilizing these components to develop our Model-Driven App within a solution.

We also compared Canvas Apps vs Model-Driven Apps, so you now know when to use each one.

Also, you may like some more Power Apps tutorials:

• Calculate Age in Power Apps
• Calculate Percentage in Power Apps
• Create a Plan Using Power Apps Plan Designer
• Delete All Records From Dataverse Table
• Create a Responsive Navigation Menu in Power Apps