Study guide
1.3 Deciding Where Business Logic Runs and Choosing the Right Table Type
Microsoft Power Platform Developer Associate PL-400
Track your progress as you read
Finished sections get a check mark.
1 Introduction, Exam Overview & Developer Toolchain
0.1 PL-400 Exam Facts 0.2 Audience Profile & Required Developer Skills 0.3 The Power Platform Developer Toolchain 0.4 Extension-Point Map & AI in the Developer Workflow
2 Create a Technical Design
1.1 Analyzing Technical Architecture and Choosing Out-of-the-Box vs. Custom Solutions 1.2 Designing Authentication, Authorization, and Security Architecture 1.3 Deciding Where Business Logic Runs and Choosing the Right Table Type 1.4 Designing Reusable Power Apps Components and Custom Connectors 1.5 Designing Dataverse Code Components, Automations, and Integrations
3 Build Power Platform Solutions
2.1 Managing Power Platform Environments for Development 2.2 Dataverse Security Roles for Code Components, Least Privilege & Troubleshooting Operational Security 2.3 Solutions, Managing Dependencies & Solution Layers 2.4 Environment Variables & Connection References 2.5 Power Platform Pipelines & CI/CD with Power Platform Build Tools
4 Implement Power Apps Improvements
3.1 Complex Power Fx Formulas and Functions 3.2 Building Reusable Canvas Component Libraries 3.3 Invoking Power Automate Cloud Flows from a Canvas App 3.4 Troubleshooting Canvas and Model-Driven Apps with Monitor and Browser Debugging Tools 3.5 Optimizing Canvas and Model-Driven App Performance
5 Extend the User Experience
4.1 The Client API Object Model & JavaScript Form Scripting 4.2 Event Handler Registration & Navigation to Custom Pages via the Client API 4.3 Client Scripting Against the Dataverse Web API; Command Bar & Buttons with Power Fx and JavaScript 4.4 PCF Fundamentals: The Component Manifest & Lifecycle Events 4.5 Implementing PCF Component Interfaces; Device, Utility & Web API Features 4.6 Packaging, Deploying & Consuming a PCF Component
6 Extend the Platform: Dataverse Plug-ins & Custom APIs
5.1 Plug-in Fundamentals & the Event Execution Pipeline Stages 5.2 Execution Context & Implementing Business Logic in Plug-ins 5.3 Pre/Post Images & Organization Service Operations in Plug-ins 5.4 Registering Plug-ins with the Plug-in Registration Tool & Optimizing Plug-in Performance 5.5 Custom API Messages & Plug-ins That Implement a Custom API 5.6 Configuring Dataverse Business Events
7 Extend the Platform: Custom Connectors
6.1 Open API Definitions: Building and Extending a Custom Connector 6.2 Authentication and Policy Templates for Custom Connectors 6.3 Importing Definitions and Creating Connectors for Azure Services 6.4 Azure Functions in Custom Connectors and Data Transformation
8 Extend the Platform: Platform APIs & Azure Functions
7.1 Dataverse Web API Operations & OAuth Authentication 7.2 Organization Service Operations, Concurrency, Transactions & Bulk Operations 7.3 Service Protection API Limits & Retry Policies 7.4 Azure Functions for Long-Running, Scheduled & Event-Driven Workloads 7.5 Authenticating to Power Platform with Managed Identities
9 Extend the Platform: Power Automate Cloud Flows
8.1 Dataverse connector triggers/actions, trigger filters & retry policies 8.2 Complex expressions & flow control with error handling 8.3 Sensitive input/output parameters & Azure Key Vault 8.4 Reusable child flows & Microsoft Entra ID service principals
10 Develop Integrations
9.1 Publishing Dataverse Events: IServiceEndpointNotificationService & the Plug-in Registration Tool 9.2 Registering Service Endpoints: Webhooks, Azure Service Bus & Event Hub 9.3 Data Synchronization with Change Tracking & Alternate Keys 9.4 Upsert-Based Synchronization with the UpsertRequest Message
11 Exam Readiness & Practice
10.1 Cross-Domain "Where Do I Implement This?" Decision Framework 10.2 Exam-Day Strategy, PL-400 Item Styles & Study Plan
1.3 Deciding Where Business Logic Runs and Choosing the Right Table Type
Key Takeaways Explain This Topic AI
Only Dataverse plug-ins are guaranteed to run regardless of entry point, because they hook the message pipeline instead of a UI surface.
Business rules and client-side JavaScript are form-scoped and do not enforce logic on API calls, imports, or other non-UI entry points.
Power Automate cloud flows are the right fit for multi-system orchestration and human-in-the-loop approvals, at the cost of asynchronous latency.
Standard tables offer the full Dataverse feature set; virtual tables surface external data without duplication; elastic tables (Cosmos DB-backed) handle high-throughput, semi-structured data.
Not every external data need requires a table at all — a direct connector call is simpler when Dataverse's relational and security model is not required.
Last updated: July 2026
Two of the most consequential design decisions on any Power Platform project are where business logic executes and which table type stores the data . Getting either wrong shows up later as bugs that only occur through certain entry points, or as a table that cannot scale or cannot reach the data it needs.
Where Should Business Logic Run?
Power Platform offers five distinct places to put logic, each with a different execution guarantee, latency profile, and audience.
- Option Executes Runs regardless of entry point? Best for
- Client-side JavaScript Browser, on form events No — form-only Immediate UX feedback, field formatting
- Business rules Client and server, per form No — form-only Simple show/hide, set value, validation
- Dataverse plug-ins Server, inside the event pipeline Yes Logic that must be enforced universally
Power Automate cloud flows Server, async orchestration Trigger-dependent Multi-system workflows, approvals, connectors
Azure Functions / custom code External compute Only if invoked by a plug-in, flow, or connector Heavy compute, external SDKs, long-running work
Client-side JavaScript gives the fastest feedback but only fires in a browser session on a specific form — it enforces nothing if a record is created through the Web API or a data import. Business rules are declarative and portable across model-driven forms (including mobile), but their condition logic is intentionally limited and they share the same form-only weakness as JavaScript for anything beyond simple UX.
Plug-ins are the only option that is guaranteed to run no matter how a record enters or changes in Dataverse, because they are registered directly against the Dataverse message pipeline (Create, Update, Delete, and custom messages) rather than against a UI surface. This makes them the correct choice whenever a requirement says "must always" or "regardless of how the record is created."
Power Automate cloud flows are best when the logic is really an orchestration — calling multiple connectors, waiting for a human approval, or coordinating several systems — because that kind of branching, multi-step logic is painful to hand-code in a plug-in and easy to maintain declaratively. The tradeoff is latency: flows run asynchronously outside the transaction, so they cannot block a save the way a synchronous plug-in can.
Azure Functions are reserved for logic that a plug-in or flow cannot practically host — computation that would exceed a plug-in's two-minute synchronous execution limit, or that depends on an external library/SDK not available in the Dataverse sandbox.
Choosing the Right Table Type
Dataverse supports three table storage models plus the option of not storing data in Dataverse at all.
Standard tables store rows natively in Dataverse. They get the full platform feature set: relationships (1:N, N:1, N:N), business rules, auditing, offline mobile sync, plug-in triggers on every message, and full security-role enforcement. Default choice for any data the solution owns.
Virtual tables map Dataverse table metadata onto data that physically lives in an external system (SQL Server, an OData endpoint, or another line-of-business system) through a data provider. They let model-driven apps, views, and relationships treat external data like a Dataverse table without duplicating or syncing it — the tradeoff is that write support and plug-in trigger coverage depend on what the underlying data provider implements, and many providers are effectively read-focused.
Elastic tables are backed by Azure Cosmos DB rather than the standard relational store. They are designed for high-throughput, high-volume, or semi-structured data — telemetry, IoT readings, logs, or JSON payloads with a flexible schema — where a well-chosen partition key matters more than rich relational modeling. Elastic tables trade away some standard-table capabilities (complex relationship types, certain auditing behaviors) in exchange for horizontal scale and configurable retention.
No table at all — a connector call. When a solution only needs occasional read or write access to an external system and does not need Dataverse's security model, relationships, or offline behavior applied to that data, calling the source system directly through a standard, premium, or custom connector is simpler than modeling a virtual or standard table for it.
Applying the Decision Together
A realistic design combines both decisions: a "must always enforce" pricing rule belongs in a plug-in against a standard table holding order data, while a high-volume sensor-reading feed is better modeled as an elastic table fed by a cloud flow, and a read-only view of an ERP system's inventory is a strong candidate for a virtual table rather than duplicating that data.
Common Design Mistakes to Avoid
Two mistakes recur often enough to be worth naming explicitly. First, teams sometimes model an external system's data as a full standard table synchronized by a scheduled flow, when a virtual table would have avoided the sync job, the staleness window, and the duplicate storage entirely — virtual tables should be the default question whenever "should we copy this external data into Dataverse?" comes up. Second, teams sometimes push high-volume, short-lived event data (page views, sensor pings, application logs) into a standard table , which then suffers from storage growth and degraded query performance; that data almost always belongs in an elastic table , where retention policies and partition-key design were built for exactly this pattern. Recognizing both mismatches — the wrong table type for external data, and the wrong table type for high-volume data — is a frequent exam scenario.