Microsoft Intelligent Applications Builder

A solution that cannot be moved safely is a liability. You plan environments, put work into solutions, manage dependencies, and understand how changes travel from development to production.

• Environment types and governance
• Solutions, publishers and layers
• Environment variables and connection references
• Managed and unmanaged solutions
• Moving solutions between environments
• Source control for solutions

You build An ALM plan with environments, and a solution that moves from development to test.

The data model decides how well everything above it works. You design tables and columns, choose column types, and model one-to-many and many-to-many relationships, with choices, lookups and calculated values.

• Standard, custom and virtual tables
• Column types, choices and formats
• Lookups and relationship types
• Calculated and rollup columns
• Keys, duplicate detection and auditing
• Importing and loading data

You build A Dataverse data model for a business process, with relationships and sample data.

Some columns can fill themselves. You define prompt columns that classify, summarize or extract from other fields, test their output, and decide when AI-derived values are trustworthy enough to store.

• What a prompt column is and how it runs
• Writing a prompt that uses other columns
• Testing prompt output on real rows
• When AI-derived data should be reviewed
• Cost and refresh considerations
• Using AI columns in views and apps

You build A table with prompt columns that classify and summarize records, with a test of their output.

People use data through forms and views, and they should see only what they are meant to. You build forms and views, then apply security roles, business units and column security to match who may see and change what.

• Main and quick-create forms
• Views, filters and charts
• Security roles and privileges
• Business units and record ownership
• Column-level security
• Testing security as different users

You build Forms, views and a security model tested against three user types.

Model-driven apps put the data model to work with little code. You design navigation, forms and dashboards, use commands and business logic, and make an app that follows the shape of the process.

• The app designer and navigation
• Forms, tabs and sections that fit the task
• Views, dashboards and charts
• Command bar customization
• Copilot in model-driven apps
• Publishing and sharing

You build A model-driven app over the data model, with navigation, forms and a dashboard.

Generative pages let you describe a page and refine what Copilot builds. You write effective descriptions, inspect the generated result, and decide where a generated page is enough and where it needs hand work.

• What generative pages are and where they sit in an app
• Writing descriptions that produce usable pages
• Iterating and refining generated results
• Connecting generated pages to Dataverse data
• Reviewing generated output for correctness
• Limits, and when to build by hand

You build A generative page added to a model-driven app and refined through several iterations.

Canvas apps give full control over layout and behavior. You build screens and controls, write Power Fx formulas, and connect data sources, with attention to how an app behaves for real users.

• Screens, containers and responsive layout
• Controls and their properties
• Power Fx formulas and functions
• Connecting data sources and delegation
• Navigation and app state
• Using Copilot to build and explain formulas

You build A canvas app with several screens, formulas and a connected data source.

An app that works only for its builder has not shipped. You build reusable components, design for accessibility, and fix the formulas and data calls that make apps slow.

• Component libraries and reuse
• Accessibility: keyboard, focus and contrast
• Screen reader support and labels
• Reducing data calls and load time
• Delegation and large data sets
• Measuring performance with the monitor

You build A component library, and a performance and accessibility review of a canvas app.

Apps fail in ways builders do not expect. You handle errors in formulas and data calls, show useful messages, and write automated tests so changes do not quietly break working screens.

• Error handling functions in Power Fx
• Validating input and showing clear messages
• Handling failed data operations
• Test Studio and automated app tests
• Test cases for key user journeys
• Debugging with the monitor

You build An app with consistent error handling and an automated test suite for its main journeys.

Flows connect apps to the rest of the business. You build cloud flows with triggers, actions and conditions, route approvals, and handle failures so automations can be trusted to run unattended.

• Triggers and actions
• Conditions, loops and expressions
• Approvals and approval patterns
• Calling flows from apps
• Error handling and run history
• Connections and ownership

You build A cloud flow that triggers from a Dataverse change and routes an approval.

AI Hub brings models and prompts into your solutions. You build prompts, choose models and consume them from apps and flows, then check results for quality before they reach users.

• AI Hub, models and prebuilt capabilities
• Building and testing a prompt
• Inputs, outputs and structured responses
• Calling prompts from flows
• Calling prompts from apps
• Quality checks and human review

You build A prompt that extracts data from text, called from both an app and a flow.

Rules and guided processes keep data and work consistent. You write business rules that apply on forms and in tables, and build process flows that walk users through stages.

• Business rules: conditions and actions
• Scope of a rule: form, table or all forms
• Business process flows and stages
• Branching and stage gates
• Combining rules, flows and automation
• Testing business logic

You build A set of business rules and a staged process flow for one business process.

Build one working application. You design it, model the data with AI-enriched columns, build the app, add flows and prompts, and ship it through environments.

• Designing from requirements
• Building the data model and security
• Building the app and its generative pages
• Adding automation and prompts
• Testing and moving it to production

You build A deployed intelligent application with data, app, automation, prompts and tests.