📌 Power Platform — (Lecture 1)

Power Platform
Power Platform is a suite of business applications developed by Microsoft that helps
organizations automate processes, analyze data, and build custom applications—all without
needing extensive coding skills. It consists of five core components:

1. Power BI (Business Intelligence):

o Think of this as a super-powered, interactive Excel sheet. Power BI allows you to
take data from various sources (Excel files, databases, online services, etc.) and
transform it into visually appealing, easy-to-understand dashboards and reports.
These reports can help businesses make data-driven decisions by presenting the
data in a way that’s more digestible and actionable.
Analogy: Imagine you are a chef looking at a messy kitchen (your data). Power BI is like a smart
assistant that helps you organize the ingredients, sort them by type, and display the recipe steps
(insights) so you can cook a perfect meal (make decisions). Power BI is like your high-tech
magnifying glass, allowing you to see the tiniest details in your business performance.
2. Power Apps:
o Power Apps allows you to create custom applications without needing to know
much coding. You can build apps for different devices (phones, tablets, desktop)
that help automate tasks, capture data, or interact with other business systems.
It provides a drag-and-drop interface for creating apps quickly.
Analogy: It's like having a Lego set where you can choose different blocks (features) to build
your own structure (app), without needing to be a professional architect or builder. Power
Apps are like customizable power tools, enabling you to build solutions and automate specific
tasks that make your workshop run more efficiently.
3. Power Automate (formerly Flow):
o Power Automate helps you create workflows that automate repetitive tasks. For
example, it can automatically send an email every time a new file is uploaded to
a certain folder or move data between apps like SharePoint, Outlook, or
Salesforce without needing you to manually intervene.
Analogy: Think of Power Automate as a conveyor belt in a factory. Once you set it up, it carries
items (tasks) automatically from one place to another, saving you time and energy. Power
Automate is the conveyor belt system that moves work automatically between tasks, making
sure everything runs without you having to manually move each part.
 4. Power Virtual Agents:
o This component helps you create chatbots to engage with users or customers,
offering automated assistance. You can design and deploy bots without having
to know anything about coding. The bots can be used on websites, in apps, or in
various messaging platforms.
Analogy: It’s like building a helpful robot assistant who can answer customers' questions, guide
them through processes, and help solve problems, all without requiring you to be present.
Power Virtual Agents are like helpful assistants or robots that can communicate with
customers, take instructions, and complete tasks without needing constant human supervision.

5. Power Pages:
Power Pages is the low-code service for building secure, data-driven websites. It extends
the Power Platform into the web domain, allowing you to design, configure, and publish
external-facing sites that interact seamlessly with your business data in Dataverse. You get a
visual, drag-and-drop design studio plus templates for common scenarios (customer portals,
partner hubs, event registration sites, etc.), all without having to hand-code HTML or CSS.

Analogy: Imagine you’re creating a storefront in an online marketplace. Power Pages is like
a ready-made display window and shelving system—you arrange the products (data and
pages) visually, customize the look and feel, and go live, without ever having to build walls
or wiring from scratch.

How they work together:

All five components are built on the same underlying data platform (Dataverse) and integrate seamlessly
with each other, as well as with , and countless external connectors:

• Unified data
Every tool—BI dashboards, apps, workflows, bots, and websites—can read from and write to
the same Dataverse tables. That means your Power App can capture customer feedback, which
instantly becomes available in a Power BI report, and can even trigger an automated approval
flow in Power Automate.
• Cross-tool embedding
Embed a Power BI report inside a canvas app or a Power Pages site. Surface your chatbot (Power
Virtual Agents) directly within a Power Pages portal to assist external users, or invoke a flow
(Power Automate) from a button in Power Apps to send notifications or update records.
• End-to-end scenarios
1. Customer Service Portal
▪ Power Pages hosts the external-facing support site.
▪ Power Virtual Agents chatbot answers common questions or collects case
details.
 ▪ Power Automate routes submitted issues to the right queue or triggers an
email.
▪ Power Apps provides an internal case-management app for agents to update
statuses.
▪ Power BI dashboards track response times, case volumes, and customer
satisfaction.
• Single sign-on and security
Leverage Azure Active Directory for sign-in across all Power Platform components, apply fine-
grained role-based access, and enforce data-loss prevention policies centrally.

By combining these tools, you get a cohesive, end-to-end solution: from capturing data in apps or on
websites, automating back-office processes with flows, engaging users via chatbots, and surfacing
insights through rich analytics—all within a unified, low-code environment.

🎨 1️⃣ Power BI

• Purpose: To visualize and analyze data through interactive dashboards and reports.
• Key Use: Converts raw data into meaningful insights for decision making.

• Language Used:
o Primarily uses DAX (Data Analysis Expressions) for calculations and Power
Query M Language for data transformation.
Example:
A sales manager uses Power BI to track regional sales performance through visual dashboards.

📱
2️⃣ Power Apps
• Purpose: To create custom business apps without or with minimal code.

• Main Component: Central to Power Platform, connects with Dataverse and other data
sources.
📌 Types of Power Apps:

Type Purpose Example

Pixel-perfect, drag-and-drop layout based

Canvas App A shop inventory management app
apps for internal use

Model-Driven Data-driven, based on business rules and A patient record management

App Dataverse model system

Websites for both internal and external A customer service portal for
Power Pages
users booking appointments

Features:
• Easy to build apps
• Connect to various data sources
• Role-based security management

• Pro-dev extensibility (can integrate custom APIs)

• Integrations with Microsoft services and other systems

🔄 3️⃣ Power Automate

• Purpose: Automates workflows and repetitive business tasks.

• Example:
Automatically send an email to HR when a new employee record is added in SharePoint.
• Key Feature:
Essential for integrating with external services and APIs.
o We use HTTPS calls to connect APIs and retrieve/send data.
Example:
Fetch employee details from Azure AD via a REST API and update a Dataverse table.

🤖 4️⃣ Power Virtual Agents

• Purpose: To create AI-powered chatbots without coding.
 • Use: Automates customer service, FAQs, and support tasks.
Example:
A chatbot on a healthcare website that answers common appointment queries.

🌐 5️⃣ Power Pages

• Purpose:
To build secure, low-code business websites for internal and external audiences.
• Key Difference from Canvas App:
Power Pages support external users while Canvas Apps are for internal users.

• Tech Involved:
Can involve JavaScript and Liquid (a template language for rendering dynamic content).
Example:
An insurance company’s online claims submission portal.

🗺️ 6️⃣ Model-Driven App

• Purpose:
Focused on data structure and business processes within Dataverse.
• Key Features:
o Based on business rules and processes.
o Less design flexibility than Canvas Apps.

o Uses Business Process Flows for guiding users through standard processes.
Example:
A ticketing system for internal IT service requests.

📦 BACKEND Components

🔗 1️⃣ Data Connectors

• Enable connection with external data sources like SQL, SharePoint, Azure, Excel, etc.

🗄️ 2️⃣ Dataverse (Common Data Service)

 • A cloud-based storage platform for securely storing and managing app data.
• Functions:
o Create tables (entities), columns (fields), and set relationships

o Define business rules

o Manage environment security and security roles
Example:
A table for storing employee details with relations to a department table.

🧠 3️⃣ AI Builder

• Add AI capabilities (like prediction, text recognition) into Power Apps and Power
Automate without coding.
Example:
Use AI to predict customer churn based on past interaction data.

☁️ Microsoft Azure & Supporting Services

• Azure:
Microsoft’s cloud platform for hosting services, apps, and managing company-wide
data.
It handles:
o Employee details

o Assigned roles, permissions

o Group memberships
• Graph API:
o Used in Power Automate to interact with Azure AD services (like fetching user
details)
• Azure Functions:
o Custom APIs hosted in Azure, triggered via Power Automate or Power Apps.
Example:
Get a logged-in user's manager hierarchy instantly.
🔗 GitHub

• Used for deploying apps and code.

Deployment Methods:
• Manual Deployment
• Using Pipelines

• Octopus Pipelines (a deployment automation tool)

🌐 Environment Types in Power Platform

Environment Purpose

Dev Environment Build and test apps

System Environment Run apps and services

UAT (User Acceptance Testing) Final testing before production

Production Environment Live environment for end users

📚 Summary — What is Microsoft Dataverse?

• Cloud database for business apps

• Allows you to:
o Define Tables

o Set Columns & Data Types

o Create Relationships
o Build Business Rules
o Design Forms & Views

o Configure Security Rules

Example:
An online clinic app where patient, doctor, appointment, and billing data are managed in
Dataverse.
✅ Final Recap — Power Platform Uses:

Tool Purpose Example

Power BI Data visualization and reporting Sales Dashboard

Power Apps Custom business app development Inventory Management

Power Automate Workflow automation Leave Approval Process

Power Virtual Agents AI-powered chatbots Online Support Bot

Power Pages External-facing websites Public Event Registration

Power Platform – Lecture 2:

1. Microsoft Dataverse
1.1 Why Use Dataverse?
• Recommended by Microsoft as the primary data platform for Power Platform.
• Provides a scalable, secure, managed relational database with built-in business logic
(e.g., validation, workflows).
1.2 Default Tables & the User Table
• Every new environment includes a set of core tables out-of-the-box.
• The User table is first in the list—stores information about each signed-in user.
o Use case: When logging in, you see only the records and actions allowed by your
user record.
o Security roles are assigned via the User table to control access.
1.3 Core vs. Custom Tables

Table Type Definition Example

Core Predefined by Microsoft Account, Contact, User

Custom Created by you to fit your business model “InvoiceLineItem”, “ProjectTask”

2. Model-Driven Apps vs. SharePoint
• Model-Driven Apps
o Only connect directly to Dataverse as their primary data source.

o Provide rich forms, views, charts, and dashboards automatically.

• SharePoint
o Can be used for attachments or external documents, but not as a primary table.
o Example:

• If you need to store file attachments for a record, you can enable SharePoint
integration—
• files are stored in SharePoint while metadata remains in Dataverse.

3. Importing & Exporting Data

3.1 Excel Integration
• Import: Use Import data from Excel on the command bar in the table view.
o Steps:
1. Download the sample template.

2. Populate data in Excel.

3. Upload and map columns to Dataverse fields.
• Export: In a table view, choose Export to Excel (static or dynamic).
3.2 Security Considerations
• View-only access for external stakeholders (e.g., BI report authors).
o Create a custom security role granting read-only on specific tables/columns.

4. Delegation in Canvas Apps

• Delegation: Power Apps delegates data operations to the data source to handle large
datasets.
• Limit: By default, queries are limited (e.g., 500 rows).
• Warning: If an operation can’t be delegated, you’ll see a “Delegation Warning.”
 • Example:
• // Delegable
• Filter(Contacts, StartsWith(LastName, "S"))

• // Non-delegable
• Filter(Contacts, DateDiff(CreatedOn, Today(), Days) < 30)

Delegable vs. Non-Delegable Functions in Canvas Apps

When you connect a canvas app to a large, server-side data source, only delegable
functions/operators are translated and executed on the server. Non-delegable ones pull a
limited number of records (default 500, max 2,000) locally, which can lead to incomplete
results.
<details> <summary>**Delegable Functions & Operators**</summary>
• Data-retrieval functions: Filter, Search, First, LookUp
• Logical operators: And (&&), Or (||), Not (!), In
• Comparison operators: =, <>, >, >=, <, <=

• Arithmetic operators: +, -
• Text/Date functions: TrimEnds, IsBlank, StartsWith, EndsWith, constant values (e.g.
Today())
• Others: If, *, /, Mod, casting (Text, Value), Concatenate (&), ExactIn, string manipulators
(Lower, Upper, Left, Mid, Len, …), signals (Location, Acceleration), volatiles (Rand),
collections
• Sorting: Sort, SortByColumns
• Aggregates (when supported): Sum, Average, Min, Max, CountRows, Count

</details> <details> <summary>**Non-Delegable Functions**</summary>

• FirstN, Last, LastN
• Choices
• Concat

• Collect, ClearCollect
 • GroupBy, Ungroup
• (And any other functions not listed as delegable; these will trigger a blue underline
warning in the formula bar.)

</details> *Source: Microsoft Learn “Understand delegation in a canvas app”

:contentReference[oaicite:4]{index=4}*

5. Environments

• Production Environment
o Hosts the final, customer-facing version of apps & data.
o Changes here should be well tested.

6. Building a Canvas App

6.1 Naming & Structure
1. Screens & Folders
o Follow a strict naming convention (e.g., scrHome, frmCustomerDetails).
2. Containers

o Use Container controls (Horizontal/Vertical) to make layouts responsive.

6.2 Power Fx Language
• Formula language used across Power Apps, Power Automate, etc.
• Syntax example:
• // Set a global variable
• Set(selectedCustomer, ThisItem);
•

• // Update a field on save

• Patch(Accounts, selectedCustomer,
• { Address1_City: [Link] }
• );
7. Variables & Collections

Type Scope Creation

Local Single screen UpdateContext({ showModal: true })

Global Entire app Set(userRole, "Manager")

Temporary in-app table (multiple Collect(colOrders, Filter(Orders,

Collection
rows) Status="Open"))

• Clearing:

• Clear(colOrders);
• ClearCollect(colOrders, Filter(Orders, Status="Open"));

8. Solutions

• A Solution packages all components (apps, tables, flows) in one container.

• Must specify a Publisher when creating.
• Note: Always start by creating a Solution, then add Apps/Flows to it—rather than
creating loose Apps.

9. Power Automate
9.1 Flow Types
1. Cloud Flows
2. Desktop Flows (RPA / “UI Flows”)
3. Instant Flows (triggered manually or from an app)
4. Scheduled Flows
🔄 Types of Flows in Power Automate
Flow Type Description Example

Automates workflows across cloud services When a new item is added to a

Cloud
and apps like SharePoint, Outlook, Teams, SharePoint list, send a Teams
Flows
Dataverse. notification.

Automates tasks on your desktop or legacy

Desktop Log in to an old desktop application,
systems using Robotic Process Automation
Flows (RPA) extract data, and save it to Excel.
(RPA).

Triggered manually by a user from a button

Instant In a Power Apps app, click a button to
click in Power Apps, Power Pages, Teams, or
Flows instantly send an approval email.
mobile app.

Every day at 8 AM, export Dataverse

Scheduled Runs on a set schedule (daily, hourly, weekly,
records to Excel and email it to the
Flows etc.).
manager.

📌 Quick Summary:

• Cloud Flows = cloud app automation

• Desktop Flows = desktop software automation
• Instant Flows = manual trigger (button click)
• Scheduled Flows = runs on a timer

9.3 Licensing & Connectors

• Avoid Premium connectors in shared apps unless every user has a license.
9.4 Triggering from Canvas Apps & Pages
• Canvas: use the [Link]() function.
• // Calling an instant flow named ‘NotifySupervisor’
 • [Link]([Link])
• Power Pages: no direct [Link]—use APIs/webhooks to invoke flows.

10. Power Pages

10.1 Views
• Studio View: design pages with drag-and-drop.
• Portal Management View: configure security, entities, and advanced settings.

10.2 Security Roles

• Anonymous: for unauthenticated visitors.
• Authenticated: for signed-in users.
• Control page access via web roles and entity permissions.

10.3 Building a Page

1. Web Template: HTML structure with Liquid placeholders.
2. Page Template: layout and zones.
3. Web Page: ties URL, template, and content together.
10.4 Web Files

• Used to upload assets (images, CSS, JS).

• Fields:
1. Name
2. Parent Website
3. Partial URL

11. Canvas App Form Submission

Method Description Syntax

Submits all fields for the form’s

SubmitForm SubmitForm(frmCustomer);
data source
Method Description Syntax

Manually specify which fields to Patch(Customers, Defaults(Customers), {

Patch
update or create in a table Name: [Link] });

12. Chatbot & Copilot

• Knowledge Articles: store FAQs and how-to’s in Dataverse.
• Chatbot

o Trains on Knowledge Articles.

o Can be embedded in Canvas Apps, Pages, Teams, etc.
• Channels: define where the bot is available (e.g., Website, Microsoft Teams).

Tip: Always keep your apps and automations modular—use descriptive names, group related
logic, and document your formulas or flow steps with comments. This makes maintenance,
handover, and troubleshooting much easier!

Lecture 3: Importing Excel Data & Deployment Options

Thursday’s Task

Goal: Take data from a local Excel file and import it into Dataverse.
Key Question: Can we use a local Excel file as a local data source in Power Apps?
• Answer:
o Power Apps does not support using a purely local Excel file as a live data source.

o Workaround:
1. Upload the Excel file to OneDrive or SharePoint.
2. Create a connection in your Power Platform solution to that cloud-hosted
file.

3. Import into a Dataverse table via the Data → Get data wizard.

Deployment Methods
When you’re ready to move your solution (apps, flows, tables, etc.) to another environment or
tenant:
1. Manual Deployment

o Export the unmanaged or managed solution from the source environment.

o Import it manually via the Power Platform admin center.
2. Azure Pipelines
o Automate solution export & import by configuring a YAML or Classic pipeline
that calls the Power Platform CLI.
3. Octopus Deploy
o Use Octopus steps to package and push your solution file into target
environments.

4. XrmToolBox Commands
o Leverage plugins like the “Solution Transfer” or “Configuration Migration” to
script deployment tasks.
Tip: Always include versioning and change notes in your solution export to keep track of
updates.

Publisher & Prefix

• Each solution is associated with a Publisher, identified by a Publisher Prefix (e.g., new_,
abc_).

• When you create any custom component (table, field, flow), Dataverse automatically
prefixes its schema name with your publisher prefix:
• Publisher Prefix: abc_
• Custom Field: abc_TotalSales

• Best Practice:
o Create a dedicated publisher for each project or division.
o Keep prefixes short (3–5 characters) and meaningful.

Solution Scoping
 • Solution 1 → Designed to bundle all components (apps, tables, flows) for one specific
app or feature set.
• You can maintain multiple solutions for different areas (e.g., “SalesSolution,”
“HROnboardingSolution”).

Lecture 4: Connecting to Data & SharePoint Integration

Best Way to Import Data
1. Create a Dataverse Table
o Define columns (fields) with proper data types.

2. Create a Connection
o In your solution, add a Connection resource that points to your data source (e.g.,
SharePoint, OneDrive).
3. Use “Get Data” Wizard

o Map SharePoint list columns to Dataverse fields and import.

Note: Trying to patch directly from a local Excel without going through cloud storage will result
in errors when submitting data.

SharePoint as a Data Source

• Site vs. List

o Site: A container at the “broader” level (e.g.,
[Link]
o List: A table-like structure within a site (think of it as a spreadsheet with columns
and rows).
o SharePoint Site
o ├── List A (e.g., “Employees”)
o ├── List B (e.g., “Assets”)

o └── Document Library (e.g., “Policies”)

• Key Points:
o One Site can host multiple Lists or Document Libraries.
 o A List cannot span multiple Sites.
Advantages of SharePoint
• Centralized data storage (lists) and document storage (libraries).

• User & permission management at both site and list levels.

• Column-level security & metadata: You can add custom columns, enforce data types,
and map user roles to permissions.
• Built-in sharing & collaboration features (check-in/check-out, version history).

SharePoint Site Types

1. Team Site
o Designed for internal collaboration.
o Comes with a document library, team news, and default lists.

o Recommendation: When creating a team site for your app’s data, build “from
scratch” (no unused templates) to keep it clean.
2. Communication Site
o For broad announcements, news, and content publishing.
o Not ideal for data integration—use a Team Site for lists that the app will patch
to.
Naming Convention: Always apply a consistent naming scheme to your sites (e.g., PP-HR-Site,
PP-Sales-Site) to ensure clarity and governance.

Lecture 5: Connectors, Connections & App Controls

Connector vs. Connection
• Connector:
o The “driver” that knows how to talk to a particular service (e.g., SharePoint, SQL
Server, Excel Online).

• Connection:
o A configured instance of a connector, including credentials and endpoints.
Important:
 • Connections live outside your solution.
• Solutions only hold references to connections (so you can switch them per
environment).

Power Apps Galleries

• A Gallery is a control to display records in a scrollable list or grid.
1. Simple Gallery: Flat list of items (e.g., a list of accounts).

2. Nested Gallery: Gallery inside another gallery (e.g., for grouping by category).
• Adding Items:
o Always insert into the first layout section (template) of your gallery.
o // Example: Patch a new record into your data source

o Patch(Accounts, Defaults(Accounts), {
o Name: [Link],
o Industry: [Link]
o })
• Large Datasets & Filtered Views:

o If you only need to show specific columns or filter on the fly, use Collections:
o ClearCollect(
o colFilteredAccounts,
o Filter(Accounts, Industry = "Technology")
o );
o [Link] = colFilteredAccounts

Screens: Splash & Dashboard

1. Splash Screen
o Serves as the app’s loading or welcome screen.
o Often shows branding or a progress indicator.
 2. Dashboard Screen
o Displays key KPIs (charts, summary cards) relevant to the user’s role.
o Example controls:

o // Show total sales this month

o Text(Sum(Filter(Sales, Month(SaleDate)=Month(Today())), Amount), "[$-en-
US]$#,###")

Tomorrow’s Task
Action Items:
1. Recreate your SharePoint list in Dataverse as a native table.
2. Shift all data from SharePoint into the new Dataverse table (use the “Get Data” wizard
or Power Query).

Study Tips:
• Practice by creating a dummy SharePoint site, list, and then importing into Dataverse.
• Experiment with both simple and nested galleries to understand template sections.

• Version & back up your solutions before deploying—use publishers wisely.

Power Platform Lecture 6 —

These notes summarize and clarify the key concepts from Lecture 6 on Power Apps, organized
for easy review. Each section includes definitions, syntax, examples, and tips.

1. FILTERS
Definition:
• The Filter function returns a subset of records from a data source that match a given
formula (criteria).

Syntax:
Filter(DataSource, Formula)
• DataSource – your table or list (e.g., SharePointList, SQLTable, Collection).
 • Formula – a logical expression that each record must satisfy.
Example:
// Show only active vendors

Filter(Vendors, Status = "Active")

Use Cases:
• Restrict gallery items to those meeting specific conditions.
• Build dynamic views (e.g., "Top 10 sales", "Customers in Karachi").

2. GALLERY SEARCHES
Definition:
• The Search function scans a table and returns records where specified columns contain
a search string.
Syntax:
Search(DataSource, SearchString, "Column1", "Column2", ...)
Example:
// Enable a search box to filter gallery by VendorName or City

Search(Vendors, [Link], "VendorName", "City")

Tip:
• Combine Search with Filter for advanced scenarios (e.g., search within a filtered subset).
Filter( Search(Products, [Link], "Name"), Stock > 0 )

3. LOOKUP
Definition:
• The LookUp function returns the first record that matches a condition, or single column
value if specified.
Syntax:
// Full record
LookUp(DataSource, Formula)
// Single column
LookUp(DataSource, Formula, ColumnName)

Example:
// Get the first "Top" vendor record
LookUp(Vendors, Rating = 5)

// Get just the email of the first high-rating vendor

LookUp(Vendors, Rating = 5, Email)
Use Case:
• Quickly fetch specific details without loading entire data sets.

• Populate form fields or variables based on selection.

4. GALLERY TEMPLATE FILL (Highlighting Selected Item)

Behavior:
• When you click an item in a gallery, you can change its fill color to indicate selection.
Unselected items appear faded.
Syntax (Gallery > TemplateFill property):
If(
[Link],
ColorFade(RGBA(94, 199, 167, 1), -2%),
RGBA(0, 0, 0, 0)
)
• [Link] – true for the currently selected record.

• ColorFade(color, amount) – lightens (positive) or darkens (negative) a given color.

Tip:
• Use matching ContrastColor formulas for text inside the template to ensure readability.
5. SORTING GALLERY DATA
Scenario:

• You want your gallery items sorted by a column (e.g., date, name, rating).
Syntax (Gallery > Items property):
Sort(DataSource, ColumnName, [Link])
// Or

SortByColumns(DataSource, "ColumnName", If(SortDescending, Descending, Ascending))

Example:
// Static descending sort by CreatedDate
Sort(Orders, CreatedDate, Descending)

// Dynamic sort on header click

SortByColumns(Products, "Price", If(varSortDesc, Descending, Ascending))
Tip:
• Use a toggle or icon button to switch varSortDesc between true/false.

6. FORM MODE–BASED BUTTON STATE

Goal:
• Enable or disable a form’s Submit button based on the form’s Mode (New/Edit/View).
Key Property:
• FormMode – indicates [Link], [Link], or [Link].
Syntax (Button > DisplayMode property):
If( [Link] = [Link], Disabled, [Link] )

Example:
// Disable Submit if viewing
[Link] = If([Link] = [Link], [Link],
[Link])
Use Cases:

• Prevent submits when the form is just for viewing.

• Conditionally show/hide other controls based on form state.

7. CREATING A COLLECTION

Definition:
• A Collection is an in-memory table used to store data locally in your app for quick access
and offline support.
Syntax:

// Add all records from a data source

Collect(CollectionName, DataSource)

// Add specific fields or records

ClearCollect(Col_SmallSet, ShowColumns(Products, "Name", "Price"))

Important Notes:
• Collections improve performance for small or frequently used data sets.
• Define Collect or ClearCollect in the OnVisible property of a screen so data loads when
the user navigates there.

Example:
// OnVisible of Home Screen
ClearCollect(
Col_Vendor,

ShowColumns('Vendors KPI', "VendorName", "Rating", "Status")

)

8. ASSIGNMENT (Due Thursday)

Task:
1. Create a collection with at least 4 records (e.g., a subset of Col_Vendor).
2. Display filtered data from that collection in a gallery or data table.

3. Demonstrate filtering by a formula (e.g., show only those with rating ≥ 4).
Hints:
• Use Filter(Col_Vendor, Rating >= 4) in the gallery’s Items property.
• Ensure your collection loads via OnVisible before filtering.

9. UPCOMING TOPIC: SLIDER NAVIGATION

• Next week: Implement a slide-out navigation pane (e.g., hamburger icon triggers a side
menu animation).

10. INDUSTRY NOTE: POWER PAGES TREND

• Power Pages are increasingly popular for building secure, standalone portals.
• If you’re interested in portal development, start exploring the Power Pages licensing and
templates.

Study Tip: Review each syntax block in your own sandbox, tweak parameters, and observe
effects live in the Power Apps Studio.

Power Platform Lecture 7: Building a Left Navigation Slider in Power Apps

1. Introduction to Components in Power Apps

What is a Component?
• A reusable UI element or grouping of controls (e.g., buttons, icons, labels) packaged
together.

• Defined once and used across multiple screens or apps to ensure consistency and ease
of maintenance.
Benefits:
 • Reusability: Design once, deploy everywhere.
• Consistency: Uniform look and behavior across screens.
• Maintainability: Update in one place and propagate changes.

2. Planning the Left Navigation Slider

A "Left Nav Slider" (sometimes called a hamburger menu) is a side-panel that toggles in/out
when the user clicks an icon.

Key Elements:
1. Component container to hold the navigation panel.
2. Hamburger icon to toggle open/close.
3. Variable to track the open/closed state.

4. Custom property on the component to expose the state or trigger behavior.

3. Step-by-Step Implementation
3.1. Create the Component

1. In the Power Apps canvas, go to the Tree view ➔ Components ➔ + New component.

2. Rename it (e.g., LeftNavMenu).

3. Set its dimensions:

o Width: match the app’s width:

o Width = Max([Link], [Link])
o Height: divide height as needed (for header vs content), e.g., 1/5 of app height:
o Height = Max([Link], [Link]) / 5

o Tip: Use Max([Link], [Link]) to ensure it respects the

minimum screen height in responsive layouts.
3.2. Add the Toggle Icon
1. Inside the component, insert an Icon > IconHamburger.

2. Position it at the top left (e.g., X: 16, Y: 16).

3. Rename to icn_Hamburger.
3.3. Create and Use a Global Variable
• In the OnSelect property of icn_Hamburger, set:
• OnSelect = Set(VarOpenMenu, !VarOpenMenu)

o VarOpenMenu: a global Boolean variable (true = open, false = closed).

o !VarOpenMenu: negation operator to toggle.
• Note: Variables do not work until they are first created. The above line both creates and
toggles.

3.4. Define a Custom Property for the Component

1. With the component selected, go to Properties > Custom, click + Add custom property.
2. Configure:
o Name: MenuWidth (or another name reflecting its purpose).

o Property type: Output (so the parent screen can read it).
o Data type: Number.
3. In the Formula field for MenuWidth, enter:
4. If(VarOpenMenu,
5. Max([Link]) / 3,

6. 100
7. )
o When VarOpenMenu is true, width = one-third of minimum screen width.
o When false, width = 100px (mostly hidden).
3.5. Use the Component on a Screen
1. Insert the LeftNavMenu component onto your screen.
2. Select the instance, and in its Width property, set:
3. [Link]

4. Now, clicking the hamburger icon toggles the component’s width between 100 and
[Link]/3.

4. Putting It All Together: Full Example

 1. On App’s OnStart (optional):
2. // Initialize menu state as closed
3. Set(VarOpenMenu, false);

4. LeftNavMenu Component:
o Size formulas as above.
o icn_Hamburger.OnSelect = Set(VarOpenMenu, !VarOpenMenu).
o Custom property MenuWidth = If(VarOpenMenu, Max([Link])/3,
100).
5. Screen Layout:
o Insert → Custom → LeftNavMenu.
o [Link] = [Link].

o Position at X = 0, Y = 0 (so it slides from the left edge).

Behavior: Clicking the hamburger icon toggles the global VarOpenMenu, which updates the
custom property MenuWidth. The screen-bound component instance adjusts its Width
accordingly.

5. Tips and Best Practices

• Naming conventions: Prefix component names with cmp, icons with icn, screens with
scr for clarity (e.g., cmp_LeftNavMenu, icn_Hamburger).
• Responsive design: Use [Link] and [Link]/Height to handle different
device sizes.
• Testing: Insert temporary Label controls to display variable values (Text =
VarOpenMenu) while debugging.
• Performance: Minimize complex formulas in component properties; compute once in a
variable if reused.

Power Platform Lecture 8: Galleries, Icons, and Labels

1. Overview
Power Apps Galleries let you display and interact with a set of records (collections or data
sources) in a flexible, templated layout. In this lecture, we cover:
• Gallery Controls: How to configure and bind data

• Icon Controls: Adding intuitive visuals

• Label Controls: Displaying text values
• Input Properties: Customizing navigation (LeftNav)
• [Link]: Detecting and responding to the current screen

• Practical Example: Building a left-navigation menu

2. Gallery Controls
2.1. What is a Gallery?

A Gallery is a container that:

• Repeats a template (row, list, tile) for each record in an Items data source.
• Supports horizontal, vertical, and flexible layouts.
• Allows each template to contain charts, images, icons, text, and controls.
2.2. Key Properties

Property Description

Items The collection or table to display (e.g. MyCollection).

TemplateSize Height (vertical) or width (horizontal) of each item.

Layout Preset layouts (Title, Title and subtitle, etc.).

OnSelect Action to run when a template is selected.

2.3. Binding Example

// Suppose you have a collection:
ClearCollect(LeftNav,

{
Title: "Home", Screen: HomeScreen, Icon: [Link] },
{ Title: "Details", Screen: DetailScreen, Icon: [Link] },
 { Title: "Tasks", Screen: TaskScreen, Icon: [Link] }
);

// Bind a Vertical Gallery

[Link] = LeftNav
In the Gallery template:
• Text label (Title): [Link]

• Icon control: set Icon property to [Link]

• OnSelect of the template/container: Navigate([Link], [Link])

3. Icon Controls

3.1. Purpose
Icons provide visual cues for actions and navigation without requiring text.
3.2. Syntax & Use
• Insert via Insert ▸ Icons
• Icon property: set to a member of the Icon enum, e.g. [Link], [Link], [Link].

• Color, Size, and PAdding can be customized.

// Example:
[Link] = [Link];
[Link] = 24;
[Link] = If(
[Link] = [Link],
[Link],
[Link]

)
This highlights the current item in a different shade.
4. Label Controls
• Used to show text fields from your data or static headings.
• Text property: bind to [Link] or any formula.

• Common properties: Font, FontSize, Color, Padding.

// Example:
[Link] = [Link];
[Link] = Font.'Segoe UI';

[Link] = 14;

5. Input Properties: Customizing LeftNav

5.1. Items Property

Define a collection or table of navigation options.

ClearCollect(LeftNav,
{ Title: "Home", Screen: HomeScreen, Icon: [Link] },
{ Title: "Details",Screen: DetailScreen, Icon: [Link] },
{ Title: "Tasks", Screen: TaskScreen, Icon: [Link] }

);
5.2. Default Selection
To default-select the first item:
[Link] = First(LeftNav)

6. [Link]
• Definition: Returns a reference to the screen that the user is currently viewing.
• Use Cases:

o Highlight the active menu item:

o If(
o [Link] = [Link],
 o [Link],
o [Link]
o )

o Conditional Logic based on the current screen.

7. Putting It All Together: Left-Nav Example

1. Define Navigation Collection

2. ClearCollect(LeftNav,
3. { Title: "Home", Screen: HomeScreen, Icon: [Link] },
4. { Title: "Details",Screen: DetailScreen, Icon: [Link] },
5. { Title: "Tasks", Screen: TaskScreen, Icon: [Link] }

6. );
7. Configure Gallery
o Items: LeftNav
o Default: First(LeftNav)
o Template Fill:

o If(
o [Link] = [Link],
o [Link],
o [Link]
o )
o Template OnSelect:
o Navigate([Link], [Link])
8. Bind Controls in Template

Control Type Property Formula

Icon Icon [Link]

 Control Type Property Formula

Label Text [Link]

9. Run & Test

o Clicking an icon or label navigates to the corresponding screen.

o The active menu item highlights automatically via [Link].

8. Tips & Best Practices

• Use clear, descriptive titles for navigation items (e.g., "Dashboard", "Reports").
• Optimize gallery layout for your form factor (mobile vs. desktop).
• Keep icon sizes consistent to maintain visual rhythm.
• Localize text by storing labels in a translation table if needed.

• Leverage themes ([Link], [Link]) for consistent styling.

Power Platform LEC-10: Containers & Count Functions

1. Overview
This lecture covers two main topics:
1. Using Containers to organize screen layouts.

2. Applying Count functions to summarize data.

By the end of these notes, you will know how to:
• Create and configure vertical and horizontal containers.
• Build a header component with dynamic user information.

• Use Count, CountRows, CountAll, and CountIf functions—including filtering and sorting.
• Link container properties for consistent styling.
• Export and reuse components across apps.

2. Containers in Power Apps

Containers group controls and manage responsive layouts.
2.1 Types of Containers
• Vertical Container: Stacks child controls from top to bottom.

• Horizontal Container: Places child controls side by side.

Tip: Choose Vertical if you want a column layout; choose Horizontal for a row layout.
2.2 Creating a Container
1. In the Insert pane, select Layout > Vertical Container or Layout > Horizontal Container.

2. Rename it appropriately (e.g., hdrContainer).

3. Set its Width, Height, Padding, and Gap properties to manage spacing.
2.3 Header Component Example
1. Insert a Vertical Container at the top of the screen and rename to HeaderContainer.

2. Add a Rectangle inside it to serve as a backdrop; set its Fill (color) to a theme color (e.g.,
RGBA(0, 120, 212, 1)).
3. Insert a Label into the container for the title (e.g., "Sales Dashboard");
o Set FontWeight to Bold.
4. Insert a second Label to show the current user’s name.

o Text property: "Welcome, " & User().FullName

o Align right or place as desired.
Context: By placing the labels inside HeaderContainer, any style changes to the container (e.g.,
background color) will cascade to the child elements.
3. Count Functions
Count functions summarize data in tables and columns.

Function Description Syntax Example

Counts the total number of records

CountRows CountRows(Orders)-> returns total orders
(rows) in a data source.

Similar to CountRows; counts all rows

CountAll regardless of any filters applied on CountAll(Products)
the screen.

Counts non-blank values in a specific Count(Inventory, QuantityInStock)(counts

Count
column. rows with a value in QuantityInStock)

Counts rows where a specified CountIf(Orders, Status = "Shipped")(counts

CountIf
condition is true. only shipped orders)

Why use Counts?

• Provide metrics (e.g., total customers, number of pending requests).
• Dynamically update dashboards with real-time data.
3.1 Filtering & Sorting within Counts

You can filter and sort a table before counting:

// Count overdue orders sorted by OrderDate descending
CountRows(
SortByColumns(
Filter(Orders, DueDate < Today()),
"OrderDate", Descending
)
)

Syntax Breakdown:
1. Filter(Orders, DueDate < Today()) filters overdue orders.
2. SortByColumns(..., "OrderDate", Descending) sorts them.
3. CountRows(...) counts the resulting set.
4. Linking Container Styles
Containers allow you to manage styles in one place:

• Changing [Link] updates the background of all its children.

• If you need a child control to override, explicitly set its own Fill property.
Example: If you change the screen’s theme color, you can bind:
[Link] = [Link]

so the header always matches the app theme.

5. Exporting & Reusing Components

1. Select the container (e.g., HeaderContainer).

2. In the ribbon, click Export > Component.

3. Save as .msapp file.
4. Import into other apps via Components > Import.
Use Case: Create a standardized header that all your apps share, ensuring consistent branding.

6. Best Practices & Tips

• Label Formatting: Use Bold text for count labels to make metrics stand out.
• Naming Conventions: Prefix containers (hdr, flt for filters, cnt) to make your tree
organized.
• Performance: Use delegation-friendly functions (CountRows, Filter) to handle large data
sources.

• Accessibility: Ensure color contrast for header backgrounds and text.

Power Automate (Lecture 12) —

1. Introduction to Power Automate

Power Automate is Microsoft’s cloud-based service for automating workflows between apps
and services. It can be built in two contexts:
1. Inside a Solution (Dataverse)

o Flows live alongside your Dataverse apps, tables, and other components.
o Ideal for managed, environment-scoped automation in enterprise applications.
o You control connectors and data via Dataverse security roles.
2. Outside a Solution (Standalone)

o Flows created outside any solution, managed at the tenant or user level.
o Quick to build and test, but less structured for ALM (Application Lifecycle
Management).

Tip: Always prefer creating flows inside a solution when you plan to move, package, or deploy
them across environments.

2. Configuration Contexts
Scope Where Configured Managed By

Azure AD Tenant/Company-wide IT/Global Admin

Dataverse Solution/App level App Makers/Owners

• Azure AD connectors (e.g., Office 365, Azure Active Directory) are managed at the
company/tenant level.
• Dataverse connectors and table triggers/actions live in your solution and are governed
by your app’s security model.

3. Core Components of a Flow

1. Trigger
o The event that starts your flow (e.g., "When an item is created" in a Dataverse
table).

o Example:
o trigger:
 o type: "[Link]"
o inputs:
o entityName: "new_invoice"

2. Actions
o Steps executed after the trigger. Could be standard connectors (Outlook, Teams)
or custom Dataverse operations (Create, Update).
o Example: Send an email via Outlook:

o - action: "Send an email (V2)"

o inputs:
o To: "user@[Link]"
o Subject: "New Invoice Created"

o Body: "Invoice #@{triggerOutputs()?['body/invoiceid']} was created."

3. Adaptive Cards
o Rich cards you can send, e.g., in Teams or Outlook, to collect or display
information.
o Example use: send an approval card with buttons directly inside an email.

4. Conditions and Limits

• Conditions let you branch your logic:
o Simple If yes/no checks on any expression.
o Limit: A single condition block supports up to 9 AND / OR checks.
o Workaround: If you need more, nest another flow or call a child flow from your
8th/9th condition.
• Condition #1: status == 'Pending'

• Condition #2: amount > 1000

• ... up to 9 checks

5. Switch Statements
 • The Switch action evaluates one expression against multiple values:
o Each case is a branch.
o Executes only the matching branch.

o Useful when you have many possible values for a single variable.
• - action: switch
• inputs:
• On: @{triggerOutputs()?['body/priority']}

• Cases:
• - Case: 'High'
• Actions:
• - send mail: ...

• - Case: 'Medium'
• Actions:
• - create task: ...
• - Case: 'Low'
• Actions:

• - log to history: ...

Interview Tip: Questions on Switch vs Parallel Branch usage are common.

6. Parallel Branches
• Parallel Branch allows multiple paths to run simultaneously:
o Great for independent actions that don’t need to wait on each other.

o Example: Send both an email and create a Teams message at the same time.
• - action: parallelBranch
• branches:
• - name: EmailBranch

• actions:
 • - send mail: ...
• - name: TeamsBranch
• actions:

• - post message: ...

7. SLA (Service Level Agreement) Automations

• Use Case: Remind users about pending approvals or notifications they haven’t
responded to.
• Pattern:

1. Trigger on initial notification.

2. Wait for X hours/days.
3. Check if response received.
4. If not, send reminder or escalate.

Example: If approval not received within 48 hours, send a second adaptive card with the
message: "Please approve offline or click here to respond".

8. Sample Scenario: Offline Approval

1. Initial Flow: Send approval request via Adaptive Card.
2. User doesn’t respond: SLA timer kicks in after 24 hrs.
3. Reminder Flow: Send an email saying:
"You have not responded to the approval request. If you’re offline, please respond via the link
below."
Include a link generated by the PARAM() function:
concat('[Link] triggerOutputs()?['body/itemid'])

9. Tasks & Hands-On Until Next Class

1. Canvas App: Add a Run() command to the OnSubmit property.
2. Notification: On application button click, send a Power Automate notification.
 3. Manual Trigger: Configure a manual trigger flow and wire it to the app’s OnSelect event.
4. Dataverse Table Trigger: Build a flow that fires When a row is added in a Dataverse
table.

5. Dynamic Content: Insert Dataverse table fields into the flow’s email/body dynamically.
6. Explore Outlook Action: Familiarize yourself with the various Outlook connector
actions.
7. Deep Link: In any incoming notification (email), embed a text link that opens your
Canvas App. Use:
8. Param(
9. '[Link]
10. 'recordId',

11. triggerOutputs()?['body/itemid']
12. )
13. Deployment: Before deploying an app, set up & use Connection References under the
solution’s Connections area.

Key Takeaway: Structuring your flows inside solutions, leveraging built-in actions (Trigger,
Conditions, Switch, Parallel Branch), and following SLA patterns will make your automation
robust, maintainable, and enterprise-ready.

Power Platform – Lecture 14: Patch vs. SubmitForm

1. Overview
In Power Apps, there are two primary ways to send data from your app to a data source (e.g.
SharePoint, Dataverse, SQL Server, etc.):
• SubmitForm: Designed to work with an entire form control.

• Patch: Flexible function for creating or updating individual records or fields.

2. SubmitForm
 • What it does
o Submits (creates or updates) the entire record bound to a Form control.
o Works only on the fields included in that Form.

• Key characteristics
o Bulk operation: One call, one data operation.
o Form-bound: Only form fields are sent.
o Automatic validation: Honors all form validation rules.

o Reset: ResetForm(FormName) clears all fields to their default values.

• Typical usage
• // To create a new record
• NewForm(EditForm1);

• SubmitForm(EditForm1);
•

• // To edit an existing record

• EditForm(EditForm1);
• SubmitForm(EditForm1);

• // To reset fields after submit

• ResetForm(EditForm1);

3. Patch
• What it does

o Creates or updates one or more fields in a record—without requiring a Form

control.
o You explicitly specify which fields to send.
• Key characteristics
o Granular control: Only the fields you list are sent.
 o Create & update in one: Can use Defaults() to create new records, or pass an
existing record to update.
o No built-in validation: You must handle validation manually.

o Individual resets: You reset each input control separately (e.g.,

Reset(TextInput1)).
• Basic syntax
• // Create a new record

• Patch(
• 'MyDataSource',
• Defaults('MyDataSource'),
• {

• Title: TextInput_Title.Text,
• Description: TextInput_Desc.Text
• }
• );
•

• // Update an existing record

• Patch(
• 'MyDataSource',
• ThisItem, // or Lookup(...), [Link], etc.
• {
• Status: Dropdown_Status.[Link],
• Comments: TextInput_Comments.Text
• }

• );

4. Key Differences
Aspect SubmitForm Patch

Scope Entire form Individual fields

Data
One atomic operation per form Create or update per call, per record
operation

Validation Automatic (per form rules) Manual (you decide)

Flexibility Limited to form schema Full control over fields and data shape

ResetForm(FormName) resets all Reset(ControlName) for each input control

Field reset
form fields separately

Custom scenarios, partial updates, bulk

Best for Standard create/edit forms
operations, choice fields

5. Working with Choice Columns

• SharePoint Choice field format

• // To submit a choice value

• Patch(
• 'MyList',
• Defaults('MyList'),
• {

• 'Machine Types': { Value: "Automatic" }

• }
• );
• Setting a default

o When you call Defaults('MyList'), every field starts blank or at its default.
o For choice fields you must explicitly supply a { Value: ... } record.

6. Resetting Inputs after Patch

Since Patch does not reset controls automatically, do this manually for each field:
Patch(
'MyList',
Defaults('MyList'),

{
Title: TextInput_Title.Text,
'Machine Types': { Value: Dropdown_MachineType.[Link] }
}

);
// Reset each control
Reset(TextInput_Title);
Reset(Dropdown_MachineType);

7. When to Use Which

• SubmitForm
o You have a fully-formed EditForm or NewForm with lots of built-in UI and
validation.
o You want the quickest way to save all form data.
• Patch

o You only want to update or create specific fields (e.g., header info, metadata).
o You’re building a custom UI (galleries, buttons) that doesn’t use a Form control.
o You need to work with more advanced data shapes (lookups, choice fields,
complex tables).

8. Example Scenarios
8.1. Partial Update
Scenario: Only update the “Status” of a record when an Approve button is clicked.
Patch(
'Tasks',
 Gallery_Tasks.Selected,
{ Status: "Approved" }
);

Reset(Gallery_Tasks); // if needed to refresh selection

8.2. Create with Defaults + Specific Fields
Scenario: Add a new “Machine” record but only send Name & Type; other fields use SharePoint
defaults.

Patch(
'Machines',
Defaults('Machines'),
{

Name: TextInput_Name.Text,
'Machine Types': { Value: "Automatic" }
}
);
Reset(TextInput_Name);

Reset(Dropdown_MachineType);

9. Clarifications & Tips

• Defaults(...) always indicates “new record.”
• ThisItem or [Link] indicates an existing record for updates.
• Always wrap multi-part names (spaces, special chars) in single quotes, e.g. 'Machine
Types'.
• Choice fields need a nested record: { Value: "YourChoice" }.
• For lookups, use the entire record shape, e.g.
• 'Project Manager': {

• '@[Link]': "#[Link]",
• Claims: "i:0#.f|membership|" & Lower(TextInput_Email.Text),
 • DisplayName: TextInput_Name.Text,
• Email: TextInput_Email.Text
• }

10. “Tomorrow’s Tasks”

1. Implement Patch-based field resets for your form controls.
2. Submit and reset default choice values back to SharePoint via Patch.

Here’s a clean, well-structured set of study notes for Power Platform LEC-15, broken into
logical sections, with definitions, syntax examples and contextual clarifications.

Power Platform – Lecture 15

1. Security Model in Dataverse

Key Concept: Dataverse “entities” are your tables; security is always applied at the entity-role
level.
1.1 Entities & Security Roles
• Entity = table in Dataverse.
• Security Role = a bundle of privileges (Create, Read, Write, Delete, etc.) scoped to
entities.
• Security Group (Azure AD group) is what you assign Security Roles to.
• // Assigning a role to a group (Azure AD portal / Power Platform admin)
• Security Group ──▶ Security Role

• You CANNOT assign a Security Role to a Security Role—only to a security group or

directly to users.
1.2 Privilege Levels
• Read-Only (RO): user can only view records.
• Read + Write (RW): user can view and edit records.

Best practice: Always give clients at least Read access; only give Write where strictly needed.
1.3 Common Roles & Scopes

Role Typical Assignment Scope

System Admin IT / Azure AD admin Full access, including Prod

CoE (CEO) Center of Excellence team Setup environments, solutions

Basic User End-users Can only run apps shared to them

2. Power BI & Dataverse

• Power BI connects to Dataverse but does not auto-refresh in real time—you must
schedule or manually refresh datasets.

• Write access should only be granted to BI developers if they truly need to update data;
otherwise stick to Read.

3. Modern Controls in Power Apps Forms

With the new “modern” form designer, you’ll use controls like Choice and Lookup out of the
box.
3.1 Choice Control
Displays the set of options defined on a Dataverse choice (option-set) column.
// Syntax: Choices( [Link] )
// Example: fetch the Industry choices on the Account table
Choices( [Link] )

3.2 Lookup Control

Lets the user pick a related record from another table.
// Syntax for showing a lookup as a dropdown of names:
Choices( [@'Contact Table'].PrimaryAccountId )
// or with LookUp() when you need to filter or show a computed value:
LookUp( Accounts, AccountNumber = "123", AccountName )

3.3 Patch, Notify & ResetForm

Function Purpose Syntax Example

Patch Create/update a record ```powerapps

Patch(

Contacts,
Defaults(Contacts),
{
FirstName: [Link],

LastName: [Link],
Account: [Link]
}
)
| **Notify** | Show a toast message | ```powerapps

Notify(
"Record saved!",
[Link],
3000

)
``` |
| **ResetForm** | Clear form fields | ```powerapps
ResetForm( frmMyContactForm )

``` |

> **Note:**
> - Inside a **DataCard**, use `.Value` to read/write the field value.
> - For a plain **TextInput**, use `.Text`.

---

## 4. Application Lifecycle (ALM)

> Managing your Power Apps solutions through source control & automated deployments.

1. **Solution Export**

- Export managed/unmanaged solution from Dev environment.

2. **Version Control**
- Store the solution files in a GitHub repository.
3. **Build & Release**

- Use **Octopus Deploy** (or Azure DevOps) to pick up the GitHub “release” artifact.
- Octopus pushes the solution into target environments (UAT, Prod).

```text
┌──────────────────┐ ┌───────────────┐ ┌──────────┐

│ GitHub Repo │──▶───▶│ Octopus Build │──▶───▶│ Target │

│ (solutions/) │ │ & Release │ │ Environment
└──────────────────┘ └───────────────┘ └──────────┘

4. URL References Needed

o Environment URL (e.g. [Link]
o GitHub URL for repo access

Quick Recap
• Security: assign Security Roles to Azure AD groups; use RO/RW judiciously.
 • Power BI: give devs Write only if they must update data; refresh manually/scheduled.
• Modern Forms: use Choices(), LookUp(), plus Patch(), Notify(), ResetForm().
• ALM: export solutions → GitHub → Octopus → target environments.

Power Platform Lecture 16: Model-Driven Applications

1. Introduction to Model-Driven Apps

Model-driven apps in Power Platform are component-focused and driven by data stored in
Microsoft Dataverse. They provide a rapid way to build sophisticated business applications
without heavy coding.
Key Characteristics:

• Data-first Approach: UI is generated based on the data model (tables, forms, views).
• Responsive Layout: Automatically adapts to different screen sizes.
• Built-in Business Logic: Supports Business Process Flows (BPF), workflows, and plug-ins.

2. Integrating SharePoint Documents with Dataverse

You can leverage SharePoint as a document store within your Dataverse-based app. This is ideal
for files such as contracts, invoices, and specifications.
• Why SharePoint?
o Optimized for document management (version control, metadata).
o Scales to large files without impacting Dataverse storage limits.
• Setup Steps:
1. Enable the SharePoint Document integration feature in your environment settings.
2. In your target table (e.g., Project), go to Document Management > Enable.

3. Choose or create a SharePoint site to host your document libraries.

Example: Store all Contract records’ attachments in a dedicated Contracts library on
SharePoint. Users click Documents on the form to upload or view files.
3. Business Process Flows (BPF)
Business Process Flows guide users through a standardized set of stages and steps to complete
tasks in a consistent manner.
3.1 What Is a BPF?
• A visual representation of a multi-stage business process.

• Ensures data entry follows required business rules before moving forward.
3.2 Core Components of a BPF

Component Description

Stage A major phase in the process (e.g., Qualify, Develop, Close).

Step A specific data input or action within a stage (e.g., capture budget).

Condition Logic that controls branching or stage transitions.

Action Triggers workflows, Power Automate flows, or custom logic at runtime.

3.3 Creating a BPF

1. In the Power Apps maker portal, select Solutions > New > Business Process Flow.
2. Base Table: Choose the Dataverse table (e.g., Lead, Opportunity).
3. Add Stages & Steps: Drag stages onto the canvas, then add steps (fields) under each.
4. Define Conditions & Actions:
o Condition: e.g., only show Proposal stage if Budget ≥ $10,000.

o Action: e.g., trigger an email flow when status changes.

5. Activate the flow to make it available in your app.
Syntax Snippet (Power Automate trigger in BPF):
triggers:

- type: DataverseWorkflow
table: opportunity
event: onStageChange
conditions:

- field: statuscode
 operator: equals
value: 3
actions:

- type: sendEmail
to: owner
subject: "Opportunity Closed"

4. Form & View Types in Model-Driven Apps

When working with model-driven apps, you design different form types to present data:

• Main Form: Primary interface for viewing/editing records.

• Quick View Form: Displays related record data inline (read-only).
• Card Form: Compact view used in editable grids or mobile cards.
Creating a Form:

1. Navigate to the table in the solution explorer.

2. Under Forms, click + New Form and select the type.
3. Drag and drop fields, sections, and components as needed.
Example: In a Patient table, use a Quick View Form to show the latest Allergy record when
viewing the patient’s details.

5. Submission Types & Customization

Model-driven forms support multiple submission behaviors:
1. Default Save & Close – Standard save button, persists data to Dataverse and closes the
form.
2. Customized Submission – Leverage the Ribbon Workbench to add or override buttons,
change labels, or call JavaScript actions.
Using Ribbon Workbench:
• Add a custom Save & Notify button: invokes a JS web resource to save and then send an
email.
 • Change icons or visibility rules for out-of-the-box commands.
Example JavaScript (Save & Notify):
function saveAndNotify(primaryControl) {

[Link]();
[Link]({ text: "Record saved! Notification sent." });
}

6. Data Steps in BPF

A Data Step collects user input and writes it to Dataverse during a BPF stage.

• Design: When adding a step, select the field (e.g., EstimatedCloseDate) and specify
requirements (business rules).
• Validation: Use business rules or JavaScript for client-side checks before moving stages.
Context: Think of a data step as a mini-form embedded within the BPF stage.

7. Stage Prerequisites & Navigation

To move from one stage to the next, prerequisites must be met:
• Field Completion: Required fields in the current stage must have values.
• Condition Logic: Custom conditions must evaluate to true.
Connecting a View to BPF:
1. Create a view showing records at a specific stage (e.g., "Qualify Incomplete").
2. In the BPF designer, add a Command Bar button to open that view.

8. Application Lifecycle Management (ALM)

Proper ALM ensures your solution is well-documented, maintainable, and scalable.
8.1 Key Documents
• Business Requirement Document (BRD):

o Lists stakeholders, objectives, and high-level requirements.

 • Technical Design Document:
o Specifies architecture, tables, data sources, integrations, and security.
8.2 ALM Overview

1. Plan & Design: Gather (with client) and analyze (with team) requirements.
2. Build: Configure tables, forms, BPFs, and flows in a Dev environment.
3. Test: Validate functionality, performance, and security.
4. Deploy: Use managed/unmanaged solutions to move between environments.

5. Monitor & Maintain: Apply updates, fix bugs, and optimize.

9. Summary & Next Steps

• Model-driven apps center around data in Dataverse, generating UI automatically.
• SharePoint is ideal for document storage integration.
• BPFs enforce business logic via stages, steps, conditions, and actions.

• Customize submission buttons using Ribbon Workbench and JavaScript.

• Proper ALM with BRDs and technical docs ensures project success.
Practice Exercise: Build a simple Lead-to-Opportunity BPF:
1. Create a Lead table with fields Budget, Industry.
2. Build a BPF with Qualify and Develop stages.

3. Add a condition to show Develop only if Budget > $50,000.

4. Test the flow by qualifying a sample lead.

📖 Power Platform LEC-17: Power BI

📌 What is Power BI?

Power BI is a business analytics tool by Microsoft that allows users to visualize their data, share
insights across an organization, or embed them in an app or website. It connects to multiple
data sources and provides interactive dashboards and reports.
📌 Workspaces in Power BI

• Workspace in Power BI is like a ‘solution’ in Power Apps.

• It’s a collaborative area where multiple reports, dashboards, and datasets can be
managed together.

• You can:
o Create your own workspace.
o Manage your work.
o Add other users for collaboration.

Example:
If you’re working on sales reports for your company, you can create a ‘Sales Analysis
Workspace’ and add team members there.

📌 Data Collaboration Scenario

When developing reports for customers/clients:

• A Data Team usually provides the raw data.

• The data team:
o Cleans and prepares the data.
o Removes redundancy.
• As a Power BI developer, you:
o Do not give the Data Team editing rights in Power BI workspaces.
o Only allow them to share data and view dashboards if required.
Example:
If the finance team shares quarterly data, you import it into Power BI and build reports —
without giving them editing rights in your workspace.

📌 Dashboards vs Reports
Aspect Dashboard Report

Purpose Final product / summary screen Detailed data representation

Displayed in an app or shared Shows detailed, interactive, graphical data

Use Case
view visuals

Can pull visuals from multiple Created using data models, usually a single
Source
reports dataset

Interactivity Limited (static summary) Highly interactive with slicers and filters

Example:
• Finance Dashboard: Summarized sales, profits, expenses.
• Finance Report: Detailed visualizations of sales per region, month-wise profit charts.

📌 Data Checking Before Report Building

First Step in Any Power BI Task:
✔️ Check data for redundancy (duplicate/unnecessary repeating data).
This process is known as Data Normalization:

• Removing duplicate data.

• Ensuring clean, structured, and consistent data.
Example:
If a CustomerName appears 5 times unnecessarily in the dataset — remove redundancy to
optimize the report.

📌 Security Role Access in Power BI

You can manage access using:

• Security Roles
• Test Accounts
• Groups

➝ Test Accounts:
• Create dummy accounts to test security roles.
➝ Groups:

• Add multiple people to a group.

• Assign the same access level/role to all group members.
• Groups make it easier to manage permissions:
o Instead of assigning rights to 10 individuals separately, assign it once to a group.

Best Practice:
Create as many groups as there are applications (or workspaces) for organized access control.
Example:
If you have a ‘Finance Report App,’ create a ‘Finance Team Group’ and assign relevant access to
the group.

📌 Data Modeling in Power BI

Data Modeling is the process of creating relationships between data tables in Power BI to
support complex queries and reports.
Features:

• You can build ERD (Entity Relationship Diagrams) visually in Power BI.
• Connect different tables via relationships (one-to-many, many-to-one, etc.)
Example:
• Orders table connects to Customers table through CustomerID.
• Orders table connects to Products table via ProductID.

Table Connections:
• Eliminate data redundancy.
• Create meaningful relationships for accurate reporting.

📌 Difference: Excel vs Power BI

Excel Power BI

Works on sheets (spreadsheets) Works on data models and visual dashboards

Excel Power BI

Limited visualization options Advanced and interactive data visualization

Manual, less automation Automated refreshes, scheduled reports

Example:
Excel works like a traditional table-based interface, while Power BI works with datasets,
relationships, and interactive dashboards.

📌 Summary of Important Points:

• Workspace is like a solution in Power Apps.

• Don’t give editing rights to the Data Team.

• Dashboard is for final display, Report is for detailed visual analysis.
• Always check data for redundancy → this is normalization.
• Manage access using Security Roles, Groups, and Test Accounts.

• Use Data Modeling to connect tables and remove redundancy.

• Build ERD diagrams inside Power BI.
• Understand the difference between Excel sheets and Power BI data models.

📌 Bonus: Basic Power BI Report Creation Steps

1. Get Data
→ Home Tab → Get Data → Choose Source
2. Transform Data
→ Power Query Editor for cleaning and shaping
3. Build Data Model
→ Manage Relationships between tables

4. Create Visualizations
→ Use Charts, Tables, KPIs
5. Create Dashboard
→ Pin visuals from reports to a dashboard
 6. Manage Security
→ Assign roles and access levels
7. Publish and Share

Power Platform – Lecture 18: Power Pages.

1. Power Pages Overview

Power Pages (formerly Power Apps portals) allow you to build externally-facing websites that
interact securely with Dataverse data. They support:

• Authentication via Azure AD or other providers

• Role-based security to control table (entity) and record access
• Customization through configuration, Liquid templates, Web Files, and custom code

2. Authentication & Assigning Roles

2.1 Azure AD Authentication
• Why: Leverage your organization’s Azure Active Directory for single sign-on.
• How:
1. In the Power Pages maker portal, go to Site Settings.

2. Add an entry:
3. Name: Authentication/OpenIdConnect/AzureAD
4. Value: ClientId=<your-app-id>; TenantId=<your-tenant-id>;
Authority=[Link]

5. Enable the Azure AD identity provider under Authentication settings.

2.2 Assigning Web Roles
Once users authenticate, you map them to Web Roles (e.g., “Visitor,” “Customer,” “Admin”):
1. In the portal management app, open Web Roles.

2. Create or edit a role, then add Linked Contacts (users) or Azure AD Group Claims.
3. Under Table Permissions, tie security rules to that Web Role (see §4).
3. Site Settings & Custom Code
Power Pages exposes many global settings via Site Settings (key/value pairs).

• Why: Custom code (JavaScript/CSS) often requires toggles or URLs.

• Common Settings:
o CustomCss: URL to a custom stylesheet
o CustomJavaScript: URL to a custom script file

• Tip: You must register any setting you’ll reference in your code—otherwise, your
customization won’t load.

4. Table Permissions (Role-Based Security)

Under Table Permissions, you define which Dataverse tables and records each Web Role can:
• Create
• Read
• Update
• Delete

Each permission rule specifies:

1. Table (e.g., contact, case)
2. Scope (Global / Contact only / Parent child)
3. Filter (e.g., owner = current user)
4. Web Roles it applies to
Example:
Grant “Customer” role the ability to read only their own case records:
• Table: Case

• Access: Read
• Scope: Contact (the case’s parent contact = current user)
• Web Roles: Customer
5. Web Roles & Out-of-Box Roles
• Out-of-Box:
o Administrators: Full access

o Authenticated Users: Any signed-in user

o Anonymous Users: Unauthenticated visitors
• Custom: Create roles like “Vendor,” “Partner,” etc., then attach Table Permissions to
enforce access.

6. Shortcuts (Conditional Actions)

Power Pages lets you define Shortcuts (client-side JavaScript triggers) to perform actions when
conditions are met.

• Use case: Auto-populate a field when another changes.

• Syntax (in a registered JS file):
• // e.g., when Status changes to Approved, set ApprovalDate.
• [Link]('#status').addEventListener('change', function(evt) {
• if ([Link] === 'Approved') {

• [Link]('#approvalDate').value = new
Date().toISOString().substr(0,10);
• }
• });

• Register your script under Site Settings (e.g., CustomJavaScript).

7. Web Files
Web Files store static assets (CSS, JS, images) in Dataverse so they’re served by your portal.

1. In the Portal Management App, go to Web Files.

2. Create a file record, upload content or specify an external URL.
3. In your page or template, reference it:
4. <link rel="stylesheet" href="/_webfile?webfileid=<GUID>">
 • Alignment: You can organize files under folders via Web File Folders for easier
maintenance.

8. Web Templates & Liquid

Web Templates let you define reusable HTML fragments with server-side logic using Liquid.
8.1 Basic Syntax
<h1>Welcome, {{ [Link] }}!</h1>

{% if [Link] > 0 %}
<ul>
{% for contact in [Link] %}

<li>{{ [Link] }} – {{ contact.emailaddress1 }}</li>

{% endfor %}
</ul>
{% else %}
<p>No contacts found.</p>

{% endif %}
8.2 Using FetchXML
To retrieve records, embed a FetchXML query:
{% fetchxml accounts %}
<fetch mapping="logical" count="5">
<entity name="account">
<attribute name="name" />
<filter>

<condition attribute="statecode" operator="eq" value="0" />

</filter>
</entity>
 </fetch>
{% endfetchxml %}

<ul>
{% for item in [Link] %}
<li>{{ [Link] }}</li>
{% endfor %}

</ul>

9. Custom Forms Submission

To handle custom form posts (beyond the out-of-box form):

1. Create a Web Form record (Portal Management).

2. Add Form Metadata to map form fields to Dataverse attributes.
3. In your page, embed:
4. {% webform id: 'your-webform-id' %}
5. If you need full control, use Liquid to post data and call Power Automate or a PCF
component (see §10).

10. Power Automate Integration

You can trigger flows from Power Pages to run business logic.
10.1 From Button Click
1. Create a Power Automate flow with the When an HTTP request is received trigger.
2. In your portal page JavaScript:
3. fetch('[Link] {

4. method: 'POST',
5. headers: { 'Content-Type': 'application/json' },
6. body: [Link]({ recordId: '<entity-id>' })
 7. })
8. .then(resp => [Link]())
9. .then(data => [Link]('Flow result', data));

10. Secure the endpoint via Azure AD or use a shared key.

10.2 Out-of-Box Actions
You can also invoke simple Dataverse actions via Liquid:
{% assign result = [Link]('new_CustomAction', parameters: { "contactid": [Link] }) %}

{{ [Link] }}

11. Site Settings Recap

Whenever you add any customization—JavaScript, CSS, external services, conditional
shortcuts—you’ll reference a Site Setting. Without registering it, the portal won’t load your
assets or use your custom logic.

Quick Reference Table

Feature Where to Configure Key Syntax / Example

Site Settings →
Azure AD Auth Authentication/OpenIdConnect/AzureAD
Authentication

Portal Management →
Web Role N/A (UI-based)
Web Roles

Portal Management →
Table Permission Scope: Contact; Filter: ownerid eq current user
Table Perm.

Portal Management →
Web File <link href="/_webfile?webfileid=<GUID>" />
Web Files

Web Template Portal Management → {% fetchxml %}…{% endfetchxml %}; {{

(Liquid) Templates [Link] }}

Portal Management →
Custom Form {% webform id: '...' %}
Web Forms
Feature Where to Configure Key Syntax / Example

Power Automate Power Automate → HTTP

fetch('[Link] { method:'POST', body:… })
Flow Trigger

Portal Management → Site

Site Setting CustomJavaScript, CustomCss, etc.
Settings

Power Platform LEC-19: ALM & Deployment

1. What Is ALM in Power Platform?

Application Lifecycle Management (ALM) isn’t just about building apps—it also covers
packaging, testing, and deploying them into your customers’ environments.
Key stages:
1. Plan & Develop
2. Test & Validate
3. Package & Release

4. Deploy & Operate

Why care?
• Ensures consistency across environments
• Automates repetitive tasks (build, test, deploy)
• Improves traceability and rollback capabilities

2. Deployment Methods
There are three primary ways to move solutions into a target environment:

Method Description When to Use

1.
Export solution, import via Power Platform UI Small teams, quick demos
Manual

Automate with pipelines (GitHub Actions, Azure Frequent releases, multiple

2. CI/CD
DevOps, Octopus) environments
Method Description When to Use

3. Built-
Use Power Platform’s in-portal import/export Simple one-off migrations
in

3. Deploying Portals (Power Pages)

Portals require special handling of both metadata (pages, web files) and data (site settings, web
roles):

1. Configuration Migration Tool

o GUI tool to export portal configuration as a ZIP
o Import into target via the same tool
o Example CLI:

o [Link] export --configFile

configs\[Link] --output [Link]
2. PAC CLI commands
3. pac paportal download --portal-id MyPortalID --output-folder ./portal_artifacts
4. pac paportal upload --portal-id TargetPortalID --path ./portal_artifacts

Tip: Always align portal schema between environments before deploying.

4. Connections & Connection References

Canvas apps (and other solution components) don’t carry direct connector credentials—instead
they reference a Connection Reference in your solution.
• Connection: the actual credentials (e.g. to Dataverse, SharePoint)
• Connection Reference: a logical pointer inside your solution
Why this matters

During deployment, you’ll map each connection reference’s logical name to an environment-
specific connection.
Example: Reference in Solution XML
<ConnectionReferenceDisplayName>Dataverse
Connection</ConnectionReferenceDisplayName>
<LogicalName>crb_DataverseConnection</LogicalName>
<ConnectorName>/providers/[Link]/apis/shared_commondataservice</Connec
torName>

5. Service Account vs. Personal Account

• Personal Account
o Tied to an individual’s credentials

o May lose access if that person leaves

• Service Account
o Non-interactive “robot” account
o Ideal for CI/CD pipelines—stable, auditable

Best Practice: Use a dedicated service account for all connection references in your CI/CD
flows.

6. Core Steps to Deploy a Solution

1. Map Connection References

o In target environment, create Connections (using service account)

o Assign each connection to the solution’s references
2. Publish Customizations
o Open Maker portal → Solutions → [Your Solution] → Publish All
3. Export as Managed
o Choose Managed (read-only) layer for customer environments
4. Import into Target
o In target: Solutions → Import → select your managed ZIP

7. Configuring CI/CD Pipelines

A. Create & Structure a Git Repo
• Repo name → matches your project/solution name
 • Folders:
• /src ← solution artifacts (XML, configuration)
• /.github/workflows

• /portal ← Power Pages artifacts

B. Sample GitHub Actions Workflow
name: PowerPlatform CI/CD

on:
push:
branches: [ main ]

jobs:
export_solution:
runs-on: windows-latest
steps:
- uses: actions/checkout@v3

- name: Setup PAC CLI

run: pac install latest
- name: Authenticate
run: pac auth create --url ${{ secrets.PP_URL }} --tenant ${{ secrets.PP_TENANT }} --clientId
${{ secrets.PP_APPID }} --clientSecret ${{ secrets.PP_SECRET }}
- name: Export Managed Solution
run: pac solution export --name MySolution --managed --path ./artifacts/[Link]
- uses: actions/upload-artifact@v3

with:
name: solution-drop
path: ./artifacts/[Link]
 import_solution:
needs: export_solution

runs-on: windows-latest
steps:
- uses: actions/download-artifact@v3
with:

name: solution-drop
- name: Import Managed Solution
run: pac solution import --path ./artifacts/[Link] --async
Note: Secure all credentials as GitHub Secrets.

8. Octopus Deploy Integration

Octopus can orchestrate multi-step deployments across on-prem & cloud.
1. Create a Project in Octopus
2. Define Variables for your service-account connection strings

3. Add a Deploy Step using the “Power Platform: Deploy Solution” plugin
4. Map Octopus variables to CLI parameters

9. Environment Variables & Connection Strings

Instead of hard-coding URLs and credentials, use environment variables:
# .env
PP_URL=[Link]
PP_TENANT=[Link]

PP_APPID=00000000-0000-0000-0000-000000000000
PP_SECRET=superSecretValue
In your pipeline or local dev, load these before running pac:
# PowerShell
Get-Content .env | Foreach-Object { $name, $value = $_ -split '=';
[[Link]]::SetEnvironmentVariable($name, $value) }

pac auth create --url $env:PP_URL --tenant $env:PP_TENANT --clientId $env:PP_APPID --

clientSecret $env:PP_SECRET

📝 Quick Reference: PAC CLI Essentials

# Authenticate
pac auth create --url <OrgUrl> --clientId <AppId> --clientSecret <Secret>

# Solution operations
pac solution export --name <SolutionName> [--managed] --path <[Link]>
pac solution import --path <[Link]> [--async]

# Portal operations
pac paportal download --portal-id <ID> --output-folder <Folder>
pac paportal upload --portal-id <ID> --path <Folder>

Extra Class Notes

Notes on Copilot Studio, Power Apps, GitHub, and Deployment Tools

1. Virtual Machine (VM) & Canvas App Connection Reference

• Canvas App does not create a connection reference by default.

• When a user logs into a Canvas App using their account, the connection is mapped using
their email.
• There are two types of accounts used:

o Personal Account: Used during development; connection references are user-

specific.
 o Service Account: Recommended for deployment and automation; connections
are reusable and centralized.
Power Automate Integration:

• Reuses one connection reference throughout the flow.

• Once created, it avoids duplicating references for each action.
• Best Practice: Always use service accounts for development and deployments.

2. Production vs. Non-Production Environment Management

Environments:
• Production (PRD): Live environment
• Non-Production:

o DVE (Development)
o UAT (User Acceptance Testing)
o SYS (System Testing)
Key Rules:
• Deployment should be executed only on Production from designated accounts.

• Always map the logical name of the environment and service account.
Power Automate Considerations:
• Automate flows are created using service accounts.
• Connections fetched via service account offer better control and security.
• Runtime connections are mapped automatically based on logical names.

3. Connection Reference Creation & Mapping

Process Overview:

• When adding a new reference, only one needs to be created and reused.
• Mapping becomes easy if reference exists.
Example Scenario:
 • For Active Directory (AD) users, their account is mapped with existing reference.
Steps:
1. Map all references.

2. Publish customization into a solution.

3. Use managed solutions for deployment (avoid unmanaged in production).
Best Practices:
• Create references only with service accounts.

• Always set environment-level permissions to maintain separation.

4. Octopus Deployment Tool

Components of Deployment:

1. Download Package from JFrog.

2. Import Solution
3. Update Environment Variables
4. Update Connection References
Usage Note:

• Create separate variables for each environment (DEV, UAT, SYS).

• SharePoint Variables help manage multiple environments.
• Always use live data in production, never test data.
Deployment Modes:
• Variables and connection strings are configurable within Octopus.
• Environment-specific values must be isolated.

5. Git Repository & Solution Exporting

Repository Setup:
• Project Name = Git Repository Name (Consistency is key).
• Push code only once during creation.
GitHub Workflows:
• GitHub actions/workflows manage solution deployment.
Types of Exports:

1. Latest Cut of Solution

2. Directly Connected Builds
3. Automatic Export
Language Used: YAML (used to define CI/CD pipelines)

Solution Export Commands:

• solution unpack
• solution update
• solution pack

Naming Conventions:
• Application and solution names should match logical names.

6. Environment Creation & CI/CD

Key Steps:

1. Environment Creation
2. Account Creation
3. Granting Access to Environment
Important:
• Without account access to an environment, deployment will fail.
• CI/CD Pipelines are configured for production deployments only.
Tool Used: Configuration Migration Tool
• Create schema

• Export and import solutions between environments

7. Common Data Service (CDS) & UAT

Environment Variables:
• These dynamically assign values like email, IDs, and conditions depending on
environment.

Connection Reference Mapping:

• Links the app’s logic to the respective connectors within an environment.
• Without mapping, the app cannot fetch data or work as intended.
Deployment Best Practices:

• Master data and logic must always be mapped using connection references.
• No deployment without active and valid connection reference.

8. Copilot Studio - Knowledge Integration

Data Sources Supported:

• SharePoint
• Public Websites
• Dataverse
• Azure AI Search

• Azure SQL
• Salesforce
• Zendesk
Limitations:
• At a time, you can search a maximum of 4 websites.
• Results fetched are authentic and depend on added sources.
Language Support:
• Additional languages can be added to Copilot.

Use Case Example:

• Topic: "How the conversation took place"
• Based on refined data from multiple connected sources.
Genesys Tool:
• Converts documents/language to voice.
• Useful in multilingual support applications and IVR systems.

9. Custom Forms, Submissions, and Power Pages

CRUD Operations:
• Create, Read, Update, Delete handled via custom forms.

Security & Roles:

• Defined using web roles and portal permissions.
Submission Handling:
• Form submission integrated using Power Automate or Web API.

• Useful in web portal integrations.

Wrapper Notes:
• Use AJAX to fetch XML or Liquid templates dynamically.
• Part of assignment design for Power Pages.

10. Power Pages Customization

Frontend Technologies:
• Liquid
• CSS
• JavaScript
Features:
• External user login via Azure Directory.
• Sitemap and customized web files supported.

Templates & Forms:

• Multistep form support.
• Use of dropdowns, aligned with form code.
Web Roles:
• Manage view, edit, and create rights through Portal.
Common Issues:

• Lookup field problems

• Incorrect mapping from source to query string
Best Practice:
• Use GUIDs for record identification.

• Always use clean, validated data in production portals.

Thanks! I've extracted the text from all your handwritten notes and will now present them in a
detailed, organized, and easy-to-study format with explanations, examples, and relevant
syntax where useful. This content covers topics from Power BI, Power Apps, Business Process
Flows (BPF), Model-Driven Apps, Security Roles, and Power Automate.

🔹 1. Business Central & BPF (Business Process Flows)

Purpose:
To minimize manual work in business processes using automated flows.
Basic Stages:

1. Save – Store form data

2. Validate – Ensure the entered data meets conditions
3. Activate – Make data available for use
Form & BPF Integration:

• Form: Where data is entered

• BPF: Guides users through a set of stages for process completion
View Creation:
• Create custom views in Model-Driven apps

• Add columns to these views

• Display them using model-driven interface
Navigating Stages:
• Use conditions and validations to allow transition to the next BPF stage.

🔹 2. Power BI Overview
Installation:

• Power BI Desktop required for creating reports

Usage:
• Used to show quarterly reports (Q1–Q4)
• Enables data visualization via dashboards

Workspaces:
• My Workspace: Personal area
• Combined Workspace: Shared with teams
Embedding Reports:

• Report Creation → Embed → Refresh

• Example: Embedding a report in a web app for auto-update every hour
Dashboard vs Report:

Feature Dashboard Report

Type App-like overview Graphical + numerical representation

Usage Used like canvas app dashboard Typically financial/analytical

Example Quick status update view Sales Report Q1-Q4

Important Concepts:
• Normalization of Data – Reduce data redundancy

• Security Roles – Define user access

• ERD – Entity Relationship Diagrams to map tables

🔹 3. Security Roles
Key Concepts:
• Stages are locked unless specific permissions are given.
• Form customization using drag & drop in Model-Driven App

• Sync issues may arise when new fields are added

• Save & Publish is necessary after making changes
BPF Stages Setup:
1. Form must be ready

2. Define actions to perform

3. Conditions for transitions
4. Automation can be triggered

🔹 4. Model Driven App

Structure:

• Document Storage
• Integrates with BPF to guide user process
• Built using:
o Forms: Data entry (Types: Card, Quick View, Main)
o Views: Grid displays (called galleries)

Use Case:
• Submit data via frontend form
• View processed info in views
Example:

• Main form type is often used for BPF integration and is set as the default popup form.

🔹 5. Data Import & Modeling (Power BI)

Importing Data:
• From Excel into Power BI
 • Create ERD diagrams to visualize relationships
Mapping Tables:
• Define relationships using:

• A → B → C (Mapping path)
• Use cross-filtering:
o One-directional or Both-directional
View & Model:

• Use View & Model pane to manage Excel data added to Power BI

🔹 6. Courses & Certification Notes

AD (Active Directory):
• Critical for managing user permissions
• PowerApps depend on AD for roles, security, etc.

Notifications:
• Use Teams and Outlook notifications
• Create adaptive cards for better interactivity
Naming Conventions:
• Always follow standardized naming

• Example: cc-shared-approvals-b306 (logical name)

Approval Workflows:
• Approval used in every app
• Max response time: 6–7 days

• Schedule Types are predefined

🔹 7. Approval & Automate Flows

Approval Link:
• Use item link for email notifications
 • Run manually if needed
Flow Checker:
1. Errors: E.g., missing mandatory field

2. Warnings: E.g., connection break warning

Example Message:
"Connection break hogya – life is about to expire"

🔹 8. Triggering Approvals in Power Automate

Approval Title:

• "Please do the needful" type messages

• Assigned using dynamic content
Scenario Setup:
• Pick values from SharePoint list

• Trigger flows manually or automatically

Example:
Column Name: [NameX] → fetched from SharePoint → mapped to target column

🔹 9. Power Automate Essentials

Role:
• Backend automation for apps

• API calls, notifications, dashboard updates

Triggers:
• Start the automation (e.g., HTTP Call)
• Common trigger: When an item is created or modified

Actions:
• PDF merge
• 3rd Party Connectors like Plumsail
Connections:
• Use Connection ID + Logical Name mapping

Here's a structured and detailed version of the notes from your most recent image, with
explanations, context, and syntax where relevant:

🔹 Adaptive Card in Power Automate

Purpose:

An Adaptive Card is a visually rich UI element used within flows (especially Microsoft Teams or
Outlook) to present information or gather input from users.
Usage Context:
• Shown after an automation step to:

o Request approval
o Notify client
o Inform about process status
Example Use Case:
"Send an Adaptive Card in Teams after a flow completes, asking the user to approve a
submitted form."

🔹 Automate: Connection Break & Condition Handling

Connection Break:
Occurs when:
• A service (like SharePoint, Outlook, Dataverse) loses authentication or session.

• Usually caught using Flow Checker with a warning.

Checklist:

✅ Ensure all connections are active before running a flow

🔹 Flow Conditions (8-9)

Condition Block:
• Use Case: Branching logic in Power Automate
• Nested Actions: You can nest multiple actions within an If condition
Example:

If (Status == 'Approved') {
Send Email to Manager
} else {
Notify Requestor

🔹 Interview Concept: Switch Statement vs Parallel Branch

Feature Switch Statement Parallel Branch

Control flow based on exact case

Purpose Run multiple branches simultaneously
matching

Syntax Switch -> Case 1, Case 2... Multiple flows execute side-by-side

Branch
One selected path based on match All branches run at once
Behavior

Example Use Check status in SharePoint & Dataverse

Route based on document type
Case at once

Notes:
• Switch: Used when there are multiple exact cases (e.g., "Pending", "Approved",
"Rejected")
• Parallel Branch: Executes all branches together. Used when:

"Working on both ends; it can check Dataverse and trigger same time."

🔹 Scenario: "Paired Organization"

Use Case:
Handling communication between two systems (inbound and outbound flows)

Direction Action

Inbound Receiving email (internal)

Outbound Blocked email via 3rd party connector, attempt to send

Resolution:
• The system team (IT/Admin) must release access through Active Directory (AD)
Diagram:

Inbound --> receiving --> email

Outbound --> blocked (3rd-party policy) --> attempt to send email
↑
Must be released by AD team

📌 What is ALM in Power Platform?

ALM (Application Lifecycle Management) in Power Platform refers to the process of managing
apps and solutions throughout their lifecycle — from development, testing, staging, to
production.
Power Platform uses Environments to separate these stages and manage data, apps, and
resources securely and efficiently.

📦 Types of Environments in Power Platform (Used in ALM)

Where Used /
Type Details
Purpose

✅ The main environment where apps, flows, data, and

customizations actively run in production for business users.
A) Live Business ✅ Highly controlled with governance rules. ✅ Requires a
Production Operations database (Dataverse) and is typically backed up regularly. ✅
Can host critical business apps for customers, clients, and
internal use.
 Where Used /
Type Details
Purpose

✅ Used for app and solution development, testing, and pre-

Development /
production deployments. ✅ Isolated from production —
Testing / UAT (User
B) Sandbox changes here don't affect live apps. ✅ Can be reset, backed
Acceptance
Testing) up, and restored without risk to live data. ✅ Great for trying
new features, testing app behavior, and training scenarios.

✅ Every Power Platform tenant automatically has a Default

environment. ✅ Primarily for personal productivity apps and
General-Purpose / flows. ✅ Anyone with a license in the tenant can create apps
C) Default
Unmanaged and flows here. ❌ Not recommended for production
business apps due to lack of governance. ✅ Used more like a
personal or ad-hoc development space.

✅ Created when a developer uses Power Apps Developer

Individual Plan. ✅ Private to that individual user. ✅ Good for learning,
D)
Developer experimentation, and proof-of-concept development. ✅
Personal
Environments Can't share resources easily with others. ✅ Not suitable for
production deployments.

📊 Visualizing Environment Use in ALM Process

A typical ALM workflow might look like this:

1. Personal Environment → Initial concept and personal testing.
2. Sandbox Environment → Collaborative development, testing, and QA.
3. Production Environment → Deployment for end-users and live business processes.

The Default environment is mostly avoided for structured ALM processes because it lacks strict
control and governance features.

📌 Quick Example:

Let’s say you're building your ClinicPro app:

• Start developing a prototype in your Personal environment.

• Move your solution to a Sandbox environment for team testing and validation.
 • After approval, import the solution into the Production environment for actual clinic
use.
• Avoid doing any of this in the Default environment as it's not governed.

✅ Summary:

Environment ALM Role Key Characteristics

Production Live business processes Highly governed, critical apps

Sandbox Testing / UAT / Training Isolated, resettable

Default Personal productivity Open to everyone in the tenant

Personal Individual testing Private, experimental

---

Hello everyone, Reza here! In this video, we will focus on solutions in the Power Platform.

Solutions are the mechanism through which we can implement application lifecycle management. They
allow us to transport components such as apps, flows, bots, connections, and more from one
environment to another. This is a key concept every maker in the Power Platform should be aware of, so
let's check it out in action!

**\[Music]**

Where do we begin when creating apps, flows, bots, and more in the Power Platform? Let's take an
example of Power Apps.

We start in [[Link]]([Link] and whenever we come across a

scenario where we need to create an app, we head here to start creating our app, connect to our data
sources, and so on.

It is important to understand that when you're building something in the Power Platform ecosystem, it
is built in the context of an environment. The environment you start with is always the default
environment.
The default environment is the standard environment set up for every tenant, and in this environment,
every user with a valid license—be it an Office license covering apps and flows—has the rights to create
things. This cannot be blocked by administrators. Meaning, the default environment is open, allowing
anyone to create apps, flows, and more.

A good recommendation is to rebrand this environment for personal productivity only. It should not be
used for business-critical applications.

To implement application lifecycle management (ALM) in Power Apps and other Power Platform
products, it's crucial to have a good environment strategy in place.

In my tenant, I have created three different environments:

1. A **dev environment** for development purposes,

2. A **test environment** where I deploy and test applications,
3. A **production environment** where, after testing, I move applications for end users to consume.

A Power Platform environment is a space to store, manage, and share your organization's business data,
apps, chatbots, flows, and more. It serves as a container to separate apps that may have different roles,
security requirements, or target audiences. Environments play a key role in application lifecycle
management.

In each environment, we can set up a Dataverse database, and only one database can be set up per
environment.

### How should we create apps, flows, bots, and more in a controlled and governed manner?

If you create apps directly in [[Link]]([Link] or flows in

[[Link]]([Link] these are created outside the context of solutions.

Solutions are used to transport apps and components from one environment to another. A solution can
contain one or more apps and other components such as database tables, web resources, flows, bots,
and much more.

Where should we create our apps, flows, bots, and more? We should be creating them directly inside
solutions.

Now, I want to bust a common myth—solutions are not a premium feature. The myth is that the user
creating the solution or accessing artifacts inside the solution requires premium licensing. Although
solutions and containers are created inside Microsoft Dataverse, which is a premium licensed feature,
working with solutions does not require premium licensing. All it requires is a Dataverse database set up
for the environment.

Let's walk through two scenarios:

1. I have access to my **dev environment** and I want to create a solution from scratch.
2. I already have an app, flow, and database created outside a solution, and now I want to make them
solution-aware.
### Scenario 1: Creating a Solution from Scratch

I'll create a solution called **Issue Tracker**. This solution will have a SharePoint list that tracks issues.
I'll also create a flow to send an email to the admin when a new issue is created in the list.

For this, I'll go to **Solutions** and click on **New Solution**. Here, I will create my solution and
define a publisher for it. A publisher is a mechanism to help avoid naming collisions when solutions from
different publishers are installed in an environment. I’ll name my publisher **RD** with a prefix
**RD\_** to apply to all objects in the solution.

I’ll create my solution, and within the solution explorer, I’ll create a **Canvas App**. After that, I’ll start
connecting to my data sources, in this case, SharePoint.

Since Dataverse is environment-specific, I’ll create a new SharePoint site for my test environment. The
next step is to make the app dynamic by using an environment variable. This will allow me to configure
the app to point to different SharePoint sites depending on the environment.

Once the app is connected to SharePoint and the data is linked to the environment variables, I can save
and publish my app.

Next, I’ll create a flow in the solution. This flow will send an email whenever a new item is created in
SharePoint. I’ll make the email recipient dynamic by using an environment variable for the email.

### Scenario 2: Making an Existing App Solution-Aware

Let’s say I already have an app (like **My Tasks App**) that connects to multiple data sources like
SharePoint and Dataverse. I want to add this app to a solution for better ALM.

First, I'll create a new solution in my **default environment**. After that, I will add the app to the
solution. Since this app is outside of the solution, I’ll need to edit it to replace hard-coded connections to
SharePoint with environment variables.

For the SharePoint connection, I'll create an environment variable for the site and list, and modify the
app to use those environment variables instead of hard-coded connections. After making the necessary
changes, I'll save and publish the app.

Next, I’ll add a flow, **Service Desk Report**, to the solution. I’ll make the flow aware of the
environment variables in the same way as I did with the app. I'll replace hard-coded connections with
environment variables.

Once the app and flow are solution-aware, I can export the solution and move it to another
environment, following the steps I outlined earlier.

### Exporting and Importing Solutions

Once everything is ready, I can export the solution from my **dev environment** to a **test** or
**production environment**. Before exporting, I'll ensure that all environment variables have no
current values, as this will prompt me to set new values when I import the solution to a different
environment.

When exporting the solution, I’ll select the **managed solution** option for production environments.
After exporting, I can import the solution into the target environment. I’ll update the environment
variables (e.g., SharePoint site URLs and email recipients) as necessary and finish the import process.

Now, the solution is successfully moved to the test environment, and I can see it working with the
updated environment variables.

---

If you enjoyed this video, don’t forget to like, comment, and subscribe to my YouTube channel. Thanks
for watching!

---

This is the organized and streamlined version of the text for your video. Let me know if you need any
further adjustments!

Here is the detailed explanation of the notes you shared, specifically for Power Apps and related
concepts. I have organized and elaborated on each section to give you a thorough understanding of the
topics covered.

1. Text Formatting and Conversion

• Text: In Power Apps, the Text function is used to format numbers or values into specific string
representations. This function can format a number as a string, which can include options such
as currency, percentage, or date formats. This allows for easier handling of data presentation.
• Plain Text: The Plain Text function in Power Apps removes any HTML or XML tags from a string.
For example, if the string includes any HTML tags like <b> or <i>, they will be stripped, leaving
just the plain text. This is useful when working with raw input or data imported from web pages
or external sources.
• Match: The Match function is used to extract a portion of text that matches a given pattern or
regular expression. For example, if you have a text input field and you want to extract email
addresses from that text, Match can be used to find and extract the relevant part of the string.
• Value: The Value function is used to convert a string that contains numeric characters into an
actual numeric value. For example, if you have a string "123" in a text field, the Value function
converts it into the number 123, allowing you to perform arithmetic operations.

2. Model Driven Apps and Power Apps

• Model Driven Apps: Model Driven Apps are a type of Power Apps that are primarily used for
creating applications that are data-centric. These apps are designed to provide users with a
consistent experience based on structured data stored in a database, such as Microsoft
 Dataverse. Model Driven Apps provide a more rigid structure compared to Canvas Apps and are
more suited for scenarios where the application's functionality is based on the structure of the
data itself.
• Power Apps: Power Apps is a low-code development platform that allows users to create apps
without extensive programming knowledge. There are two types of Power Apps:
o Canvas Apps: These are fully customizable apps that allow you to design the layout and
behavior by dragging and dropping elements on a blank canvas.
o Model Driven Apps: These apps are designed around your data model. They
automatically generate forms and views based on the data, providing a more structured
approach to app development.
• Excel Workbooks in Power Apps: It's important to note that Model Driven Apps and Power
Apps do not support Excel workbooks directly. This means you can't use Excel files as the
primary source for these apps, although you can import data from Excel files into Dataverse to
use within these apps.

3. Subarea in Sitemap and Model-Driven Applications

• Subarea in Sitemap: In Power Apps, the sitemap is the navigation structure of Model Driven
Apps. The sitemap defines the various sections and links in the app. A subarea can be added to
the sitemap to show custom pages such as dashboards or tables. This is useful for customizing
the navigation and organizing the app's structure for users.
• Model Driven Applications for Backend: Model Driven Apps are typically used to build
applications that interact with a backend database. These apps are tightly integrated with
Microsoft Dataverse, which stores and manages data. Users can build apps that connect to
backend services, making them suitable for businesses that require data management
capabilities like customer relationship management (CRM) systems or enterprise resource
planning (ERP) systems.

4. Desk Flows and KPIs

• Desk Flows: Desk Flows are a type of workflow automation used within Power Automate, which
is part of the Power Platform. They help automate tasks such as sending emails, updating
databases, or triggering actions in other systems. Desk Flows are typically used to streamline
business processes and make them more efficient. They can be triggered by specific events or
run on a scheduled basis.
• KPIs (Key Performance Indicators): In Power Apps, KPIs are used to track the performance of
specific business processes or goals. For example, a company might use a KPI to track sales
revenue, customer satisfaction, or project completion rates. These KPIs can be visualized in the
app using charts or graphs to help users easily track progress.

5. Power BI Integration
• Power BI Service: Power BI is a business analytics tool that helps organizations visualize their
data and share insights. In the context of Power Apps, Power BI can be integrated to provide
rich data visualizations such as dashboards, reports, and analytics. The Power BI service is used
to publish and share reports within the Power Apps environment.
o Workspaces: Workspaces in Power BI are containers for organizing your reports,
datasets, and dashboards. They allow users to collaborate on data analysis and manage
access to the reports.
 o Dashboards: Dashboards in Power BI are interactive visual displays that bring together
different data sources and visualizations into a single view. These dashboards can be
added to Power Apps to provide users with real-time insights.
o Reports: Reports in Power BI are a collection of visuals that provide deeper insights into
the data. They allow users to explore data in more detail and perform analysis.
• Power BI Reports in Power Apps: Power Apps can integrate with Power BI to display visual
reports directly within the app. This allows users to see relevant data analysis without needing
to leave the app interface. These reports can include charts, tables, and other visual elements.
• Measures: Measures in Power BI are calculations used to analyze data. They are typically used
to calculate totals, averages, percentages, and other metrics. Measures can be displayed in
Power Apps as part of the Power BI integration to provide dynamic insights into the data.

6. Sandbox Environment for Development and Testing

• Sandbox Environment: A Sandbox environment is used for development and testing in Power
Apps. It is separate from the production environment to ensure that development work does
not affect live systems or data. Developers can experiment, build new features, or test changes
in a safe space before deploying them to the production environment.
• A Power Apps app in a Sandbox environment can be shared with other users within the same
Microsoft Entra ID tenant. This allows collaboration on development projects without impacting
the production environment.
• Typical Environment: The typical environment in Power Apps is limited to a single user and
expires after 30 days. This environment is primarily used for personal or small-scale testing.
• The default environment in Power Apps cannot be backed up. This environment is
automatically created for each tenant, and it is used for quick testing or simple applications.

7. Microsoft Dataverse for Teams Environment

• Microsoft Dataverse for Teams: This is a data platform for Teams that allows users to store and
manage data within Microsoft Teams. The environment is restricted to users who are members
of a specific team, and it allows users to create and manage Dataverse tables for use in Power
Apps and Power Automate.
• The Dataverse environment can only support a single instance, and it is essential for connecting
apps and workflows within the Teams environment.

8. Power Apps - Usage in Various Business Scenarios

• KPIs: KPIs are used to track and measure performance against defined objectives. In Power
Apps, KPIs can be integrated into dashboards and reports to visualize how close or far the
business is from meeting its goals.
• Charts:
o Pie Chart: Used to show the relationship between parts of a whole.
o Line Chart: Used to display data over time or show trends.
o Map: Used to associate quantity data with geographic locations, helping visualize
regional performance or trends.

Conclusion:
Power Apps, along with tools like Power BI and Microsoft Dataverse, offers a comprehensive platform
for building applications, automating workflows, and analyzing data. It is essential to understand how
these tools work together to build powerful, data-driven apps and reports for business solutions. The
sandbox environment provides a safe space for development, and integrating KPIs and Power BI into
your apps ensures that users can track performance and make data-driven decisions effectively.
Let me know if you need further clarifications or if you'd like more details on any specific concept!