Light Sepia Dark 01Summary Part 1 covered the data model behind a certification Agreement Manager in Microsoft Dataverse: eleven tables, a strict ownership boundary that leaves signing to Adobe Acrobat Sign and document storage to Azure Blob, and a coverage model whose whole purpose is to let certification logic answer a question with a query instead of a judgement call. This part covers the automation built on top of it, and it is written against the environment rather than the specification. I went back into the development org and checked, because a build note written at two in the morning is not evidence. What is there: six cloud flows, all activated, a validation action with a plugin step behind it, Adobe configured with real workflow identifiers, and eight agreement requests that have genuinely run through the process, four of them to Fully Executed. What is not there: the custom API that creates coverage, which was never built. Nothing else is permitted to write coverage, so the coverage table is empty. The interesting part is that the system already says this about itself. 02In This Blog What is actually deployed, verified against the environment, and what the gap between the specification and the org tells you about handing work over. The Scenario: A finished data model that still needed to send agreements, track them, store evidence, and produce coverage. The Approach: A decision table fixing flow against plugin against custom API for every operation, written before any automation existed. The Action: Six solution aware flows, a validation action with a plugin behind it, and Adobe wired to real template workflow identifiers. The Outcome: A process that runs end to end up to signature, and one clearly identified missing component that the validation data names out loud. A half finished system is safe to inherit when it tells you what is missing. It is dangerous when you have to find out. Table of Contents 01Summary→ 02In This Blog→ 03Where Part 1 Left Off→ 04Flow, Plugin, or Custom API→ 05What Is Built, and What Comes Next→ 06The Coverage Gate→ 07Impact→ 08Conclusion→ 09FAQ→ 10Get in Touch→ 03Where Part 1 Left Off The foundation was eleven Dataverse tables in three layers. A configuration layer holding Agreement Type, Agreement Template Version, Agreement Role Definition and Agreement Requirement Policy. A process layer centred on Agreement Request with four parental children: Agreement Party, Agreement Recipient, Agreement Document and Agreement Validation Issue. An evidence layer of Agreement Coverage and Agreement Coverage Scope. Adobe Acrobat Sign for Microsoft Dynamics 365 owns signature execution. Azure Blob Storage owns the binaries. Dataverse owns the business decision. Eight alternate keys hold the integrity guarantees, the strongest being the one that makes a second active coverage for the same scope impossible. Everything below assumes that foundation, because the specification forbade starting automation until the tables, keys, forms and views were finished and validated. That sequencing held, and it is the reason the automation layer is as small as it is. 04Flow, Plugin, or Custom API Most Power Platform builds decide implementation style per developer preference, which produces a system where nobody can predict where a given behaviour lives. This build used one canonical decision table, written before any automation existed. Operation Preferred implementation Escalate to code when Validate Agreement Request Solution aware flow or command action that clears unresolved issues, writes new ones, and updates the validation summary The gate needs synchronous reuse, in which case it is promoted to a custom API Send for Signature Power Automate using the Adobe connector, only after validation leaves no blocker Multiple callers need one stable callable action Adobe status sync Adobe managed app plus a lightweight sync flow where needed Concurrency or idempotency require server side code Retrieve and store documents Power Automate for small files, Azure Function for large ones Blob SDK, managed identity, hashing or retry handling are awkward in a flow Create Coverage Custom API, mandatory. A pure flow is explicitly not acceptable Always, because supersession must be transaction safe Open final document Flow or Azure Function generating a short lived link Managed identity and key vault access are easier in a function Coverage gate Synchronous plugin or custom API Certificate issuance must be blocked immediately rather than eventually The canonical matrix. Deviating from it required a written justification, not a preference. Why coverage creation cannot be a flow Creating active coverage means superseding the previous active row, clearing its key, linking the supersession, and inserting the replacement. A flow performs those as separate operations, so a failure between them leaves the legal entity with either no coverage or two. A custom API performs them in one transaction, which is why the specification made it mandatory rather than preferred. The three custom APIs Validate Agreement RequestRe runs validation, populates the policy reference date if blank, enforces legal review approval where the agreement type demands it, upserts validation issues by alternate key, and returns a summary with blocker and warning counts. Create Agreement CoverageResolves policy and scope, builds the coverage match key, supersedes the prior active row and inserts the new one in a single transaction, creates the scope rows, and moves the request to Coverage Created. Evaluate Coverage GateGiven an account, legal entity, agreement type code, scope context and reference date, returns pass, block or exception with the reason and the coverage identifier that satisfied it. 05What Is Built, and What Comes Next It is worth being precise here, because a diagram of the full design would overstate what runs. The following is what the environment reports, not what the specification asked for. Figure 1: What is running today, and what is designed and waiting The automation, as deployed Component What it does State in the environment Validate Agreement Request Writes a structured issue row for every problem found on a request Custom action and plugin step, both activated FLW-01 Send for Signature Hands the prepared agreement to Adobe Activated FLW-02 Adobe Status Sync Brings signing progress back onto the request and … Continue reading How a Sustainability Certification Nonprofit Automated Agreement Management with Adobe Acrobat Sign and Power Automate →

No Plugin, No Flow: Auto-Propagating Legal Entity Across 18 D365 Tables Using Formula Fields Summary As part of our internal PO (Project Operations) to F&O integration product, every transaction needs to know which legal entity it belongs to — yet no out-of-box mechanism exists to propagate this across the 18+ connected tables involved. We built a zero-code, zero-maintenance solution using Dataverse formula fields: set Legal Entity once on Account, and every related record inherits it automatically. A custom Legal Entity table maps company master records to FO DataAreaId codes, and formula fields chain the value down through the entire relationship hierarchy. Three entities with polymorphic lookups blocked formula traversal — solved with a direct lookup field auto-populated via a Business Rule, requiring no user action. Business impact: eliminated manual per-record entry, removed CRM–FO mismatch risk, and replaced plugin/flow maintenance overhead with pure declarative formula fields. Table of Contents 01 Summary 02 The Challenge 03 What We Built 04 How It Works 05 The One Technical Wall 06 The Outcome 07 The Bigger Point 08 FAQs 09 Conclusion 10 About Me The Challenge In our internal PO (Project Operations) to F&O integration product, every transaction needs to know which legal entity it belongs to — yet no out-of-box mechanism exists to auto-propagate this across the 18+ connected tables involved. The traditional approach? Manual entry, plugins, or complex flows — all high maintenance, all error-prone. What We Built A zero-code, zero-maintenance auto-propagation solution using Dataverse formula fields — no plugin, no Power Automate flow for downstream entities. The core idea: set Legal Entity once on Account. Every related record inherits it automatically. How It Works One custom table — Legal Entity — stores company master records mapped to FO DataAreaId codes (e.g. ac, USMF). One manual input — user sets Legal Entity on Account. That’s it. Everything else is automatic — formula fields chain through the relationship hierarchy. Account (set once) → Contact, Project Contract, Invoice → Contract Lines, Projects → Tasks, Time Entries, Expenses, Actuals, Team Members, Role Prices… The One Technical Wall Three entities — Contact, Salesorders, Invoices, Projects — use polymorphic lookup fields that block formula traversal. Solved by adding a clean direct lookup — cf_accountref — populated automatically via a Business Rule. No user action needed. The Outcome Before After Legal Entity entered manually per record Set once on Account — cascades to 18 tables Risk of mismatch between CRM and FO Single source of truth — always in sync Plugin or flow required for automation Pure formula fields — zero maintenance Existing records needed manual update One-time bulk flow backfilled all records The Bigger Point Data Governance Principle This isn’t just a technical pattern — it’s a data governance principle: in multi-entity implementations, master attributes should live at the top of the hierarchy and flow down automatically, not be re-entered at every level. Formula fields make this possible in Dataverse without a single line of code. Frequently Asked Questions Why not just use a plugin or Power Automate flow instead? Plugins and flows both introduce ongoing maintenance overhead — deployment, error handling, throttling limits, and monitoring. Formula fields are declarative, run natively inside Dataverse, and require no execution infrastructure or upkeep. What happens when a polymorphic lookup blocks the formula chain? Dataverse formula fields can’t traverse polymorphic (multi-target) lookups directly. The fix is a dedicated single-target lookup field, populated automatically by a Business Rule, that formula fields can then reference downstream. Does this approach scale beyond 18 tables? Yes. As long as each new table has a traceable relationship path back to Account (directly or through an intermediate entity), a formula field can be added to inherit Legal Entity without any additional plugin or flow logic. What about records that already existed before this was implemented? A one-time bulk update was run to backfill Legal Entity on existing records. Going forward, all new and related records inherit the value automatically through the formula field chain. Conclusion Legal Entity tracking is a small field with outsized consequences — get it wrong, and financial reporting, cross-entity reconciliation, and downstream automation all inherit the error. The instinct in most implementations is to reach for a plugin or a flow to keep it in sync. This solution proves that’s not always necessary. By anchoring Legal Entity at the top of the hierarchy on Account and letting Dataverse formula fields carry it down through 18 connected tables, we removed an entire category of maintenance — no custom code to patch, no flow runs to monitor, no throttling limits to worry about. The system simply stays correct by design. It’s a reminder that the most resilient integrations are often the ones that need the least ongoing attention. When a platform-native feature can solve a problem cleanly, it usually outlasts a custom-built one. About Me DC Author Deepak Chauhan Consultant and Databricks Certified Data Engineer with 4 years of experience across Dynamics 365, Data & AI, and BI. Building Something Similar? If you’re wrestling with multi-entity data consistency in Dataverse or D365, formula fields might solve more than you expect — before you reach for a plugin or a flow. Get in Touch

Summary A Netherlands-based non-profit sustainability certification organisation reduced manual certification configuration time from hours to mere seconds using Microsoft Power Apps, implemented by CloudFronts. CloudFronts configured a multi-level assessment framework — Scope, Category, Requirement, Criteria — to automate 100% of assessment generation based on user-selected certification types and versions. The solution integrated Microsoft Power Apps with Azure Blob Storage to provide a secure, centralised repository for thousands of pieces of certification evidence, linked directly to each requirement record. Microsoft Dynamics 365 Customer Service was configured to streamline global applicant inquiries with automated case routing across Marketing, Finance, and Info queues. Business impact: eliminated manual configuration errors, provided real-time progress visibility for global applicants, and established a scalable digital foundation for global circular economy standards. Table of Contents 01 Summary 02 Introduction 03 The Business Problem 04 The Solution 05 Implementation 06 Business Impact 07 FAQs 08 Conclusion Introduction In a world where manufacturers and brands are under increasing pressure to prove the sustainability credentials of their products, the rigour and speed of certification processes can directly determine an organisation’s ability to scale its global mission. For certification bodies operating across multiple geographies, managing assessments, evidence, and applicant communication through fragmented manual processes is a bottleneck that no amount of headcount can solve. For one Netherlands-based non-profit at the forefront of the global circular economy movement, this bottleneck was real and growing. Their certification programme, built on a rigorous multi-level standard covering material safety, circularity, and responsible production, was being administered through massive Excel files, disconnected email threads, and manual document searches. This blog documents how CloudFronts partnered with this organisation to replace those fragmented processes with a unified, automated certification platform built on Microsoft Power Apps, Azure Blob Storage, Dynamics 365 Customer Service, and Power Automate, reducing certification setup time from hours to under thirty seconds. The Business Problem The organisation operates as the leading global authority on circular economy certification, serving manufacturers and brands worldwide. Their certification programme evaluates products across categories like Material Health and Circularity, across multiple standard versions — v3.1 and v4.1 — each with its own hierarchy of scopes, categories, requirements, and criteria. Before partnering with CloudFronts, this complexity was managed almost entirely by hand: Each new certification application required assessors to manually configure assessment structures from sprawling Excel files with hundreds of rows, a process that took two to four hours per applicant. Supporting evidence such as product test reports, material declarations, and third-party certificates was stored without a structured system, making retrieval slow and validation unreliable. Neither applicants nor internal assessors had real-time visibility into application status or outstanding requirements, creating persistent communication delays. Managing different certification versions across different scopes manually made scaling the programme globally nearly impossible without proportionally growing the team. The organisation needed a platform that could encode their complex certification logic, automate the heavy lifting of assessment generation, and give every stakeholder a single, reliable view of the certification pipeline. The Solution CloudFronts implemented a comprehensive digital certification ecosystem anchored by a custom Microsoft Power Apps application — the Certification Manager. The platform automates the core logic of the certification standard end-to-end, from application intake through assessment generation, evidence management, and case resolution. Key Components Microsoft Power Apps Core Certification Manager application handling applications, multi-level assessments, and the applicant-facing UI. Azure Blob Storage Secure, centralised repository for all certification evidence, linked directly to individual requirement records. Dynamics 365 Customer Service Configured to streamline global applicant inquiries with automated case routing across Marketing, Finance, and Info queues. Microsoft Power Automate Automation layer handling document upload workflows and notification triggers throughout the certification lifecycle. How It Works, At a Glance The centrepiece of the solution is a version-driven automation engine. When an assessor creates a new certification application and selects the standard version and scope, the backend logic automatically generates the complete assessment structure — all categories, requirements, and criteria — without any manual configuration. What previously took hours now takes under thirty seconds. A custom HTML-based interface within Power Apps provides visual progress indicators, allowing assessors to track completion rates across requirements at a glance. All supporting evidence is stored in Azure Blob Storage and linked directly to the specific requirement record it supports, creating a fully auditable, ISO 17065-compliant evidence trail. Implementation 1 Step 1 Certification Scheme Definition and Version Logic The foundation of the platform is the Certification Scheme Definition module. CloudFronts built a backend logic engine that stores the full structure of each certification version including all scopes, categories, requirements, and criteria as configuration data rather than hardcoded templates. When a user selects a version and scope combination, this engine automatically pulls the correct downstream structure and generates it on the application record. Updates to global standards can be deployed instantly by updating the configuration, with no changes to the application logic required. The four-level assessment hierarchy: Scope, Category, Requirement, Criteria is the structural backbone of the entire certification standard, now encoded directly into the platform. 2 Step 2 Automated Assessment Generation Once the version and scope are selected on a new application, the platform’s automation engine generates the full assessment structure in under thirty seconds, replacing a manual Excel-driven process that previously took two to four hours per applicant. The generated assessment is displayed through a custom HTML interface inside Power Apps, with visual progress indicators showing completion rates at the category and requirement level. Assessors can immediately see which requirements are outstanding, which have linked evidence, and which are ready for review. 3 Step 3 Evidence Management via Azure Blob Storage A core architectural decision was to decouple evidence storage from the Power Platform’s native Dataverse storage. CloudFronts integrated Azure Blob Storage as the document repository, with each uploaded file linked directly to the specific requirement record it supports within Power Apps. This approach delivers high-performance scalability for large evidence files while significantly reducing long-term storage costs compared to storing files natively in Dataverse. Power Automate flows handle upload automation and trigger notifications … Continue reading How a Netherlands-Based Nonprofit Achieved Global Scalability with Microsoft Dynamics 365 CRM and Power Platform →

Summary Many organizations track sales performance using pipeline and won revenue dashboards. However, these views often stop short of showing how much revenue is actually realized. For a services firm based in Houston, Texas, specializing in digital transformation and enterprise security solutions, this gap created challenges in understanding real business performance and tracking commissions accurately. This article explains how a connected sales dashboard was designed to bring together pipeline, contracts, and invoicing—providing a complete view from deal to realized revenue. Sales Performance Dashboard showing pipeline to revenue flow Table of Contents 1. Why This Gap Exists 2. Limitation of Traditional Sales Dashboards 3. From Pipeline to Payment 4. Designing the Dashboard 5. The Value of a Unified View 6. The Outcome Why This Gap Exists In many organizations, all sales-related data exists within Dynamics 365 CRM, including opportunities, contracts, order lines, and invoices. However, reporting is often built in stages based on different business needs. Sales teams focus on opportunities and closed deals, while finance teams rely on contract, billing, and invoice data. Over time, separate reports are created for each purpose. While each report works well independently, they are not always connected in a single flow. As a result, answering simple business questions becomes difficult, such as how much of the won revenue is invoiced, which deals are generating actual revenue, and whether commissions are aligned with realized value. Limitation of Traditional Sales Dashboards Most sales dashboards focus on metrics such as won revenue, win rate, deal size, and pipeline value. These provide a good view of sales activity but do not fully reflect business outcomes. A deal marked as won may still be pending contract execution, split across multiple order lines, or not yet invoiced. This creates a disconnect between reported performance and actual revenue realization. As a result, leadership sees growth in numbers, but lacks clarity on how much value has truly been earned. From Pipeline to Payment To address this, the dashboard needs to follow the complete lifecycle of a deal, from opportunity to realized revenue. Opportunity leads to Total Contract Value (TCV), which flows into contracts, then to order lines, followed by invoices, and finally results in realized revenue. Each stage provides a different perspective, ensuring that reporting captures not just intent, but actual business impact. Designing the Dashboard The dashboard was designed in layers to keep it simple while ensuring full visibility across the revenue lifecycle. The first layer provides a snapshot of sales performance, including won revenue, win rate, deal size, deal age, and lost revenue. Supporting visuals such as revenue trends, industry distribution, and geographic spread help leadership understand overall performance and where the business is coming from. The next layer focuses on what drives revenue. By breaking down data across solution areas, industries, regions, and account managers, the dashboard highlights which segments contribute the most and where future efforts should be focused. Once deals are won, contract-level visibility provides clarity on how revenue is structured. It highlights contract types, classifications, and overall value, helping teams understand how revenue will flow from a billing perspective. The dashboard then moves into order line and profitability insights. This layer connects revenue with estimated cost, margin, and profit contribution, allowing the business to evaluate the quality of deals rather than just their size. Finally, invoice-level visibility completes the picture by showing billed amounts, invoice status, and realized revenue. This ensures that the dashboard reflects actual business performance rather than just sales activity. The Value of a Unified View By bringing all these elements together, the organization moved from fragmented reporting to a single, connected view of sales and revenue. This was enabled by combining data across opportunities, contracts, order lines, and invoices into a unified reporting model :contentReference[oaicite:0]{index=0} The result is improved visibility, better alignment between teams, and more reliable decision-making. The Outcome 1. Clear visibility from pipeline to realized revenue 2. Improved alignment between sales and finance teams 3. Better tracking of commissions based on actual performance 4. Reduced manual effort in reconciling multiple reports We hope you found this blog useful. If you would like to learn more or discuss similar solutions, feel free to reach out to us at transform@cloudfronts.com.

One of the small but frustrating limitations in Microsoft Dynamics 365 is how subgrids handle record creation. If you’ve worked with Opportunities, Quotes, Orders, or any parent–child setup, you’ve probably experienced this: You need to add multiple related records. The system allows you to add them one at a time. Click New. Save. Repeat. It works, but it’s slow, repetitive, and not how users naturally think. Over time, that friction adds up. The Real Problem In our case, an Australia-based linen and garments company, was using Dynamics 365 to manage sales opportunities for hospitality and healthcare clients. Their sales team regularly needed to add multiple products — such as linen packages, garment services, and rental items, to a single Opportunity. These products were organized by categories like: A typical deal didn’t include just one item. It often included five, ten, or more products across different categories. However, the out-of-the-box sub grid experience required them to: There was nothing technically broken. But from a usability perspective, it wasn’t efficient — especially for a fast-moving sales team handling multiple client proposals daily. What they really wanted was simple: Select products by category → Choose multiple items → Add them in one go → Move on. That capability simply wasn’t available within the standard sub grid behavior. Approach Instead of forcing users to follow the repetitive process, we extended the form with a custom solution. We built a lightweight HTML-based interface embedded inside the form. This interface: Once the user confirms their selection, the chosen records are sent to a custom server-side process. From the user’s perspective, the experience becomes: Open selector → Choose multiple items → Click once → All records created. Simple. Fast. Intuitive. What Happens Behind the Scenes While the interface feels straightforward, the actual processing is handled securely on the server. When users submit their selection: This ensures the solution is: The business logic remains centralized and controlled, not exposed on the client side.file. Why This Matters The improvement may seem small at first. But consider users who perform this task daily. Reducing repetitive actions saves time, lowers frustration, and improves overall efficiency. More importantly, it makes the system feel aligned with how users actually work. Instead of adapting their workflow to system limitations, the system adapts to their workflow. That’s where meaningful customization adds value. The Outcome By combining: We created a smooth bulk record creation experience within Dynamics 365. The platform remains intact. The business logic remains secure, and the user experience becomes significantly better. And sometimes, that’s exactly what good system design is about, not rebuilding everything but removing friction where it matters most. We hope you found this article useful. If you would like to explore how AI-powered customer service can improve your support operations, please contact the CloudFronts team at transform@cloudfronts.com.

Dynamics 365 CRM plugins are a powerful way to enforce business logic on the server but choosing when and how to use them is just as important as writing the code itself. In one implementation for a Netherlands-based sustainability certification organization, the client needed their certification journey to begin with a custom application entity while still ensuring that applicant and company details were captured as leads for downstream sales and engagement processes. This blog explores how a server-side plugin was used to bridge that gap, reliably creating and associating lead records at runtime while keeping the solution independent of UI behavior and future integrations. In this scenario, the certification application was the starting point of the business process, but sales and engagement still needed to operate on leads. Simply storing the same information in one place wasn’t enough, the system needed a reliable way to translate an application into a lead at the right moment, every time. That transformation logic is neither data storage nor UI behavior; its core business process logic, which is why it was implemented using a Dynamics 365 plugin. Scenario: Certification Application Not Flowing into Sales Users reported the following challenge: a. A user submits or creates a Certification Applicationb. Applicant and company details are captured on a custom entityc. Sales teams expect a Lead to be created for follow-upd. No Lead exists unless created manually or through inconsistent automatione. Application and sales data become disconnected This breaks the intended business flow, as certification teams and sales teams end up working in parallel systems without a reliable link between applications and leads. Possible Solution: Handling Lead Creation Through Manual Processes (Original Approach) Before implementing the plugin, the organization attempted to manage lead creation manually or through disconnected automation. How It Worked (Initially) a. A Certification Application was submittedb. Users reviewed the applicationc. Sales team manually created a Lead with applicant/company detailsd. They tried to match accounts/contacts manuallye. Both records remained loosely connected. Why This Might Look Reasonable a. Simple to explain operationallyb. No development effortc. Works as long as users follow the steps perfectly The Hidden Problems 1] Inconsistent Data Entry a. Users forgot to create leadsb. Leads were created with missing fieldsc. Duplicate accounts/contacts were createdd. Sales lost visibility into new certification inquiries 2] Broken Cross-Department Workflow a. Certification team worked in the custom entityb. Sales team worked in Leadsc. No structural linkage existed between the twod. Downstream reporting (pipeline, conversion, source tracking) became unreliable. Workaround to This Approach: Use Server-Side Logic Instead of Manual Steps Practically, the transformation of an application into a lead is business logic, not user behavior. Once that boundary is respected, the solution becomes stable, predictable, and automation-friendly. Practical Solution: A Server-Side Plugin (Improved Approach) Instead of depending on people or scattered automation, the lead is created centrally and automatically through a plugin registered on the Certification Application entity. Why a Plugin? a. Executes consistently regardless of data sourceb. Not tied to form events or UI interactionsc. Can safely check for existing accounts/contactsd. Ensures one source of truth for lead and application linkagee. Works for portal submissions, integrations, and bulk imports This is essential for a client, where applications may originate from multiple channels and must feed accurately into the sales funnel. How the Plugin-Based Solution Works The solution was implemented using a server-side plugin registered on the Certification Application entity. The plugin executes when a new application is created, retrieves the necessary applicant and organization details, performs basic checks for existing accounts and contacts, creates a Lead using the extracted data, and finally links the Lead back to the originating application record. This ensures that every certification application automatically enters the sales pipeline in a consistent and reliable manner. Implementation Steps (For Developers New to Plugins) If you’re new to Dynamics 365 plugins, the implementation followed these core steps: Build and Register the Plugin. Once the plugin logic is implemented, build the project to generate the signed assembly. After a successful build: After registration, every new Certification Application will automatically trigger the plugin, ensuring that a Lead is created and linked without any manual intervention. a. Open the Plugin Registration Toolb. Connect to the target Dynamics 365 environmentc. Register the compiled assemblyd. Register the plugin step on the Create message of the Certification Application entitye. Configure the execution stage (typically post-operation) and execution mode (Synchronous or Asynchronous, depending on business needs) To encapsulate, this solution shows why server-side plugins are the right place for core business logic in Dynamics 365. By automatically creating and linking a Lead when a Certification Application is created, the organization removed manual steps, prevented data inconsistencies, and ensured that every application reliably flowed into the sales pipeline. We hope you found this blog useful, and if you would like to discuss anything, you can reach out to us at transform@cloudfronts.com

Traditional business intelligence platforms have historically focused on visualization-charts, KPIs, and trend lines that describe what has already happened. Power BI excels at this, enabling users to explore data interactively and monitor performance at scale. However, modern business users expect more than visuals. They need clarity, reasoning, and guidance on what actions to take next. This marks the shift from dashboards toward true decision intelligence. Business Challenges Most organizations face a similar challenge. Dashboards answer what happened but rarely explain why it happened. Business users depend on analysts to interpret insights, which slows down decision-making and creates bottlenecks. At the same time, data is fragmented across CRM systems, ERP platforms, project tools, and external APIs. Bringing this data together is difficult, and forming a single, trusted view becomes increasingly complex as data volumes grow. Why Visualization Alone Is Not Enough Even with powerful visualization tools, interpretation remains manual. KPIs lack business context, anomalies are not automatically explained, and insights rely heavily on tribal knowledge. This creates a gap between data availability and decision confidence. Introducing Agent Bricks Agent Bricks is introduced to close this gap. It acts as an AI orchestration and reasoning layer that consumes curated analytical data and applies large language model-based reasoning. Instead of presenting raw numbers, Agent Bricks generates contextual insights, explanations, and recommendations aligned to business scenarios. Importantly, it enhances Power BI rather than replacing it. High-Level Architecture From an architecture standpoint, data flows from enterprise systems such as CRM, ERP, project management tools, and APIs. Azure Logic Apps manage ingestion, Azure Databricks handles analytics and modeling, Agent Bricks performs AI reasoning, and Power BI remains the consumption layer. To conclude, dashboards remain a critical foundation for analytics, but they are no longer enough to support modern decision-making. As data complexity and business expectations grow, organizations need systems that can interpret data, explain outcomes, and guide actions. Agent Bricks enables this shift by introducing AI-driven reasoning on top of existing Power BI investments. By bridging the gap between analytics and decision-making, it helps organizations move from passive reporting to proactive, insight-led execution. This marks the first step in the evolution from dashboards to true decision intelligence. We hope you found this blog useful, and if you would like to discuss anything, you can reach out to us at transform@cloudfronts.com

In Microsoft Dynamics 365 CRM, Business Process Flows (BPFs) are powerful tools that guide users through defined business stages. However, when working with Lead-based BPFs that persist into Opportunity, certain platform limitations surface-especially when multiple Lead-rooted BPFs are involved. This blog walks through a real-world challenge I encountered while working with a Houston-based technology consulting and cybersecurity services firm. The firm specializes in modern digital transformation and enterprise security solutions. I explore issues with Lead → Opportunity Business Process Flow (BPF) switching, explain why the out-of-the-box behavior falls short, and detail how I designed a robust client-side and server-side solution to safely and reliably switch BPFs-even after a Lead has already been qualified. How BPFs Work (Quick Recap) It ideally won’t allow a switch, either via brute forcing via client side or server side as – The Problem In my scenario: The Challenge Once a Lead is qualified: This is non-intuitive, error-prone, and inefficient, especially considering the manual effort that goes into it. Solution Overview I implemented a guided, safe, and reversible BPF switching mechanism that: High-Level Architecture This solution uses: Step-by-Step Methodology 1. Entry Point: Opportunity Ribbon Button A custom ribbon button on the Opportunity form: These fields act as a controlled handshake between Opportunity and Lead. 2. Lead OnLoad: Controlled Trigger Execution On Lead form load: if (diffSeconds > 20) { return;} Xrm.WebApi.updateRecord(“lead”, formContext.data.entity.getId(), { cf_shouldtrigger: false}); This ensures: 3. Identifying and Aborting the Existing BPF Before switching: var activeProcess = formContext.data.process.getActiveProcess(); Xrm.WebApi.updateRecord(bpfEntityName,result.entities[0].businessprocessflowinstanceid,{statecode: 1, // Inactivestatuscode: 3 // Aborted}); This is a critical step—without aborting the old instance, Dynamics can behave unpredictably. 4. Switching the UI BPF After aborting: 5. Handling BPF Instance Creation (First-Time Switch Logic) The solution explicitly checks: If it exists: If it does NOT exist (first switch): This dual-path logic makes the solution idempotent and reusable. 6. Server-Side Plugin: Persisting the Truth A plugin ensures that: // Identify BPF typebool isNewBpf = (context.PrimaryEntityName == “new_bpf_entity”); // Resolve related LeadGuid leadId = isNewBpf? ((EntityReference)target[“bpf_leadid”]).Id: ((EntityReference)target[“leadid”]).Id; // Retrieve related Opportunity via LeadEntity opportunity = GetOpportunityByLead(service, leadId); // Determine stages and pathstring qualifyStageId = isNewBpf ? NEW_QUALIFY_STAGE : OLD_QUALIFY_STAGE;string finalStageId = isNewBpf ? NEW_FINAL_STAGE : OLD_FINAL_STAGE;string traversedPath =START_STAGE + “,” + qualifyStageId + “,” + finalStageId; // PATCH 1 – Qualify stageservice.Update(new Entity(target.LogicalName, target.Id){[“activestageid”] = new EntityReference(“processstage”, new Guid(qualifyStageId)),[“traversedpath”] = START_STAGE + “,” + qualifyStageId}); // PATCH 2 – Final stage + Opportunity bindservice.Update(new Entity(target.LogicalName, target.Id){[“activestageid”] = new EntityReference(“processstage”, new Guid(finalStageId)),[“traversedpath”] = traversedPath,[isNewBpf ? “bpf_opportunityid” : “opportunityid”] =new EntityReference(“opportunity”, opportunity.Id)}); // Mark Lead as successfully processedservice.Update(new Entity(“lead”, leadId){[“cf_pluginsuccess”] = new OptionSetValue(1) // Yes}); This guarantees data consistency and auditability. 7. Final UI Sync & Redirect After successful completion:   Xrm.Navigation.openForm({ entityName: “opportunity”, entityId: opportunityId }); From the user’s perspective: “I clicked a button, confirmed the switch, and landed back in my Opportunity—done.” Why This Solution Works ✔ Respects Dynamics 365 BPF constraints✔ Prevents orphaned or conflicting BPF instances✔ Handles first-time and repeat switches✔ Ensures server-side persistence✔ Minimal user disruption✔ Fully reversible Most importantly, it bridges the gap between platform limitations and real business needs. Dynamics 365 BPFs are powerful-but when multiple Lead-rooted processes coexist, manual switching is not enough. This solution demonstrates how: can be combined to deliver a seamless, enterprise-grade experience without unsupported hacks. If you’re facing similar challenges with Lead → Opportunity BPF transitions, this pattern can be adapted and reused with confidence. We hope you found this blog useful, and if you would like to discuss anything, you can reach out to us at transform@cloudfronts.com

Integrating Microsoft Dynamics 365 (D365) with external systems using Azure Logic Apps is a powerful and flexible approach—but it’s also prone to missteps if not planned and implemented correctly. In our experience working with D365 integrations across multiple projects, we’ve seen recurring mistakes that affect performance, maintainability, and security. In this blog, we’ll outline the most common mistakes and provide actionable recommendations to help you avoid them. Core Content  1. Not Using the Dynamics 365 Connector Properly The Mistake: Why It’s Bad: Best Practice:  2. Hardcoding Environment URLs and Credentials The Mistake: Why It’s Bad: Best Practice:  3. Ignoring D365 API Throttling and Limits The Mistake: Why It’s Bad: Best Practice:  4. Not Handling Errors Gracefully The Mistake: Why It’s Bad: Best Practice:  5. Forgetting to Secure the HTTP Trigger The Mistake: Why It’s Bad: Best Practice:  6. Overcomplicating the Workflow The Mistake: Why It’s Bad: Best Practice:  7. Not Testing in Isolated or Sandbox Environments The Mistake: Why It’s Bad: Best Practice: To conclude, Integrating Dynamics 365 with Azure Logic Apps is a powerful solution, but it requires careful planning to avoid common pitfalls. From securing endpoints and using config files to handling throttling and organizing modular workflows, the right practices save you hours of debugging and rework. Are you planning a new D365 + Azure Logic App integration? Review your architecture against these 7 pitfalls. Even one small improvement today could save hours of firefighting tomorrow. I hope you found this blog useful, and if you would like to discuss anything, you can reach out to us at transform@cloudfronts.com.

Have you ever needed to pull data out of Dynamics 365 but didn’t know where to begin? Whether you’re building a report, wiring up a Power App, or feeding data into another system, OData is your friend. In just a few clicks, you’ll be able to write simple HTTP requests to retrieve exactly the records you want—no complex code required.  What Is OData and Why It Matters OData (Open Data Protocol) is a standardized way to query RESTful APIs. Microsoft Dynamics 365 exposes its entire data model via OData, so you can:  This means faster development and fewer custom endpoints.  1. Finding Your Web API Endpoint  https://yourorg.crm.dynamics.com/api/data/v9.2 That’s your base URL for every OData call. 2. Exploring Entities via Metadata  Append $metadata to your base URL:  GET https://yourorg.crm.dynamics.com/api/data/v9.2/$metadata  You’ll get an XML file listing all entities (contacts, accounts, leads, etc.), their fields, data types, and navigation properties. Tip: press Ctrl + F to search for your entity by name.  3. Core OData Query Options  a. $select – Return Only What You Need  GET https://yourorg.crm.dynamics.com/api/data/v9.2/contacts?$select=fullname,emailaddress1,jobtitle This limits the payload to just those three fields, making responses smaller and faster.  b. $filter – Narrow Down Your Results  GET https://yourorg.crm.dynamics.com/api/data/v9.2//contacts?$filter=firstname eq ‘Ankit’ Operators: eq (equals) ne (not equals) gt / lt (greater than / less than) Combine with and / or :  GET https://yourorg.crm.dynamics.com/api/data/v9.2//contacts?$filter=statecode eq 0 and jobtitle eq ‘Consultant’ c. $orderby – Sort Your Data GET https://yourorg.crm.dynamics.com/api/data/v9.2/contacts?$orderby=createdon desc  Newest records appear first.  d. $top – Limit Record Count GET https://yourorg.crm.dynamics.com/api/data/v9.2/contacts?$top=5  Great for previews or testing.  e. $expand – Fetch Related Records  Example: Get each contact’s full name and its parent account name in one request:  GET https://yourorg.crm.dynamics.com/api/data/v9.2/contacts?   $select=fullname,parentcustomerid   &$expand=parentcustomerid_account($select=name) parentcustomerid is the lookup field  parentcustomerid_account is the navigation property  Nested $select limits expanded fields  Another example: Expand opportunities with customer account info:  GET https://yourorg.crm.dynamics.com/api/data/v9.2/opportunities?$expand=customerid_account($select=name,accountnumber) Finding Expandable Names In your $metadata, look for lines like:  <NavigationProperty Name=”parentcustomerid_account” Type=”Microsoft.Dynamics.CRM.account” />  Use that Name value in your $expand.  Putting It All Together Suppose you want all active contacts at “Contoso” and their account names:  GET https://yourorg.crm.dynamics.com/api/data/v9.2/contacts?$filter=statecode eq 0 &$expand=parentcustomerid_account($filter=name eq ‘Contoso’; $select=name)&$select=fullname,emailaddress1  Conclusion:  OData might sound technical at first, but once you get the hang of it, it becomes one of the most powerful tools in your Dynamics 365 toolbox. Whether you’re building integrations, reports, or simple automations, OData gives you the flexibility to query exactly what you need—without relying on custom development.  Start small. Open your environment, locate the Web API URL, and try your first $select or $filter query. Once you’re confident, move on to advanced options like $expand and $orderby.  Call to Action:  Need help designing smarter OData-based solutions or integrating with Power Platform tools? Reach out to our team today and we’ll help you build something great.