OwlExpress365 – How we improved your Wizard Onboarding

Intro

The wizarding world is safe once again. He Who Must Not be Named has finally been defeated, and the taint of dark wizardry is gone once again. But the threat remains. How can the wizarding world nurture the next generation of wizarding talent, to prevent the rise of the next dark wizard, while also offering a top-notch onboarding experience for students of all backgrounds – wizard or muggle born alike? An improved Wizarding Onboarding eXperience (WOX) is essential to ensure wizarding schools keeps attracting the world’s finest wizards and witches.  

Introducing OwlExpress365, an innovative new digital solution from House Elves Limited, designed to assist wizarding schools across the globe to identify, nurture and onboard new students. Infusing the latest innovations from a low-code and artificial intelligence standpoint, our end-to-end solution is designed to benefit everyone involved as part of onboarding new wizards to your wizarding school – from initial identification, through to invitation and collating all required information to ensure students are ready and enthused to start at your school. Deliver an exceptional experience to your teachers, students and parents, whilst ensuring necessary compliance against dark magic regulations and ministry requirements for each new student. Contact our friendly House Elf developers today to find out more! 

Use Case

Providing a great WOX for all students is at the cornerstone of our solution. We have created a seamless onboarding solution, reducing the time taken to submit a successful application, integrating with contract solutions and improving wizard satisfaction for students, all the while looking out for the next generation of Death Eaters.

Solution Overview

Students and Guardians

That initial owl is a key cornerstone to the historic new student onboarding, but we have improved the initial notifications, taking into account weather notifications and location to reduce the impact on an owls health. This has been done by integrating with Link Mobility, where we send an SMS with the invitation letter. This invitation now includes a link to register on our new and improved portal, https://owlexpress.app. Once registered, students can update their profile, provide information, and interact with our own knowledgeable chatbot, “Ask Hermione”, driven by a Copilot Studio agent.

Once the student has accepted their invitation, and the professors at the school have checked their submitted documentation, we get a signed agreement from their guardian. This allows all important agreement relating to the risky business of educating a wizard is concluded, and the parents / guardians also agree to pre-requisites such as book and equipment lists. Through this, the school can device that the wizard’s family is receiving adequate support and kept in the loop.

The entire solution is driven by a Power Platform base, supplemented by first party and third party solutions. This showcases the effectiveness of a low-code platform for any business solution.

Professors and Administators

Teachers are using a custom made Model Driven App, based on the first part Dynamics Customer Service. Tailored to closely align with the application process, prospective students are first segmented from the raw data received from various external sources, historical events recorded within the CRM system or information added by the professors or administrators.

Once the segment is created, prospective students and their application is created. The data source contains various characteristics for the students, such as charismatic, plant lover, bold that will augment the student profile. If one of these characteristics could align the student to the dark arts, we have an approval process. Only once all heads of hourse agree that the student will not pose a risk to the school will their application be able to continue. This process automation removes the communication and miscommunication that can allow the dark lords servants to flourish.

An application will have various documents that are required to be assessed, evidence of magical ability and approval contracts. These can be easily uploaded using the Resco PCF, allowing multiple files to be added at once.

The Application process has a central business process, which steps through the onboarding process. Once the process moves to communication, an Owl or SMS triggered to invite the prospective student to apply and provide further information. This is all handled with Power Automate and LINKMobility.

The professor will assign a house, and once checking all the documents the process is moved to Confirmation, where a contract is sent to the students guardians. This is all automated, with IP confirmed signatures to ensure full transparency and governance of the process

Overall, our ERD is below

Fabric Fera Verto

Analytics is at the cornerstone of our solution, as only through effective analytics can we address several requirements most common to wizarding schools and protect the future of our schools. This includes:

  • The ability to visually “slice and dice” student information, to create segments for upcoming student cohorts without the admins doing the segmentation needing a deep understanding of the data model.
  • Support for flexible data ingestion sources, that can be tailored for each organisation. For example, different muggle citizen data API’s for each country.
  • Ability to access and view data “on the go”, as teachers apparate between classrooms

Power Query dataflows provide a scalable and effective means of consuming data from a variety of sources, such as flat file and publicly available APIs. This is a key benefit of our solution, as each wizarding school will have different ingestion sources that need to be accommodated. For this first school the following datasources were integrated from various sources using Power Query. All these have been brought into one semantic datamodel and used to enrich each other:

  • Postal Adress data from UK postal service
  • Student Dataset from “SnitchsOps” school
  • SharePoint lists from muggle schools for student data
  • Dataverse student for alumni students

Data is then surfaced within a Power BI report, embedded in the Professors Application management Model Driven App, consolidating all information into an easily accessible experience:

The report has a couple of visual slicers and filters and display the “Potential Students” in the right hand side. This way the users always see the result of the filters in realtime:

The same information can then be viewed on a mobile device with relative ease:

For the user experience we are utilizing the extensibility of Power BI besides the Fabric data integration capabilities. Using Power BI Embedded we extended the Power BI report showing the data of the semantic model with a custom action “Export Segment”. This way the user can use the visual filters and slicers of the report while seeing the live result of these. As soon as they are satisfied, they can use the “Export Segment” actions to copy the students within the filters to the Segment within the Model Driven App. This triggers the Application process will be automatically started for each of these students.

Fabric Troubles

Unfortunately, we were not able to fully maximise our usage of Fabric, due to issues starting the Fabric trial:

Assuming this issue was overcome, we had planned to further use Fabric by implementing the following:

  • Fabric pipelines to handle the data ingestion to and from Microsoft Dataverse
  • Implement a lakehouse for staging all data, rather then using a dataflow gen 1 and semantic model.
  • Implement “big data” processing for all historical wizarding school data, to generate more useful analytics via machine learning prediction. For example, can we predict the level of support a new student would need, based on their parentage, characteristics and location?

Low-code Charms

Power Platform extensibility lends itself nicely to OwlExpress, and how we can facilitate our end-to-end process. The process starts with the embedded Power BI Segmentation report in the OwlExpress365 Model Driven App. The users can segment on external data import to Microsoft Fabric within Power BI with great usability and without the knowledge of the data model in the back:

Power Fx is used within the custom page, and as part of button that assesses a young wizard’ss previous actions, to then categorise accordingly. AI prompts are used to evaluate potentially semi-complex sentences and grade them accordingly, as a mechanism to identify potential dark wizards

Throughout our model-driven application, users have ready access to a business process flow, that helps to easily guide them to the next step, as well as providing a nice “at a glance” view for any student application:

Although requiring pro-code capability to initially implement, the various PCF controls acquired by third party vendors, such as Resco, provides an effective way for low-code developers to extend out their applications for ease. For example, Resco’s file upload control provides an easy to support more complex upload operations that are not available natively. Low-code developers would struggle to build something similar, but with available PCF controls, this becomes a breeze to configure:

Pro-code Potions

We created different potions to empower our solution.

We have the student’s portal as a Netlify static website integrated with Dataverse.

Two PCF components were created by our team for this challenge:

  • Padfoots PowerBI Putter which allowing us to create the segmentation is using the PowerBI Embedded and the PowerBI extensions to read the selected data and post that to the PCF output properties.
  • MaraudersMap which is using Azure SignalR to track everyone and push their presence in the map. It is also using the microphone to listen to your charms and reveal its secrets.

The serverless Azure SignalR service was implemented using dotnet Azure Functions.

In addition, we also authored some Dataverse plug-ins that did something unusual – triggering business logic based on the Associate message, a scenario that the team was unfamiliar with. Further details can be found on this blog post here.

Student Portal / Frontend

For the students we didn’t use a Power Platform component because of licensing, the potential students don’t have user licenses and cost wise it wouldn’t be cost-effective. For that reason we created a custom frontend built with the Astro framework, https://owlexpress.app

The following tech stack was used:

  • Astro Framework
  • Base Framework for static web apps
  • TailwindCSS
    • CSS compiler
  • Daisy UI
    • TailwindCSS component library
  • Azure B2C
    • User authentication with social media or local accounts
  • Dhino
    • Integration with Dataverse with authenticated external users, connecting with Azure B2C

Available login options in Azure B2C

Students receive an invite code via mail from Dataverse if their application reaches the stage “Communication”. The invite code is generated via plugin and stored in relation to the Student record. It also generates a login link (example: https://owlexpress.app/login?code=C0NIQWP28F ) for the student which will do the following when clicked:

  • Direct student to the Azure B2C login page
  • After successful login a Dataverse Custom API is called and links the Azure B2C Entra Object Id with the student record who is linked to the provided invite code.

dhino utilizes Azure API Management and Azure Functions for connecting with Dataverse and authenticating against Azure B2C. This is used to read the student profile from Dataverse and the student profile provides a form for the student to update data and provide additional data. The frontend is fully responsive:

Padfoot’s Power BI Putter

This PCF solves a couple of technical challenges.

First is embedding the PowerBI report in the PCF component. We started from the Microsoft react based example, but we had to overcome some complications.

The embedded PowerBI was extended using the PowerBI JavaScript API’s to include a command in one of our visuals that would allow us to export the segmented data.

Certainly, the Test-Driven Development approach helped us shorten the delivery cycle with this component as we didn’t have prior experience with those APIs and we got to use the time earned to go through the documentation and achieve success.

Authenticating the user using Microsoft Entra ID needed a little bit of trial and error to be able to overcome all the Power Platform limitations.

Marauder’s Map

Tracking where users are is the most important feature of this component. To achieve this, it is using the Azure SignalR Service so that each user can share their location. This information is being shown on an actual map that has the information hidden and can be opened and closed using voice commands.

Azure SignalR Service

Even though the authors have a lot of experience with SignalR, the Azure SignalR Service was something not yet explored. As expected, there were a lot of peculiarities to the service that required a lot of documentation reading (going through the same pages more than once).

The Microsoft sample projects were really useful to quick start the development.

Digital Transformation

Dynamics 365 Customer Service forms a cornerstone of our solution, as several of its functionality areas lends itself nicely to our scenario:

  • Using Knowledge Articles both as an internal resource and a knowledge source in our “Ask Hermoine” chatbot:
  • Taking the existing Case table and retooling it as our “Applications” table, complete with field customisations and a new Business Process Fow. Adapting this table saved considerable amount of time compared to creating it from scratch, including the ability to tailor features such as the Case ID to suit our scenarios.

Without these capabilities, it would have taken us significantly longer to build out our solution.

ALM Magic

We achieve ALM primarily via two mechanisms:

  • For our single Dataverse solution, Owl Express 365, we use Power Platform Pipelines to handle the movement across all environments. In addition, we have incorporated a flow approval process to ensure that a dedicated release manager always approves new releases before they are deployed to any environment and also enabled Git integration, to ensure changes are exported out to our Azure Repos Git repository (see next point)
  • For all other components including (but not limited to) third-party solutions, PCF controls and any form of custom code, we use an Azure Repos Git repository to host all resources. YAML pipelines are used to automatic import of key assets into all required environments:

ALM can only be truly achieved when all aspects can be documented fully, to ensure that everyone in the organisation is familiar with the discrete processes. Our ALM document, linked below, goes into fuller detail regarding what has been implemented:

To further develop what we have from an ALM perspective, we would plan to fully implement the Configuration Migration Tool (CMT) to handle the movement of important configuration data between our environments. This would be fully incorporated within our Git repository and then executed automatically via Azure Pipelines.

Magic Matrix

By tapping into some of the other features and services across the Microsoft 365 stack, our solution drives further value from existing investments. In particular, we can point the following key features in the OwlExpress product:

  • Mail-enabled queues in Microsoft Dataverse, that integrates with an Exchange Online mailbox to support the sending / receiving of emails

Integration into Microsoft Teams, for modern flow approvals and for our “Ask Hermoine” chatbot, which has been built using Copilot Studio.

Using SharePoint as a potential staging site for wizarding schools’ bespoke data, that would then be ingested into Fabric:

Wizarding schools using our solution can be confident of the many avenues that are open to integrate across the entire Microsoft 365 stack, and to afford opportunities to further maximise existing investments.

Owl Express – Application Lifecycle Magic

Howl to do ALM.

OwlExpress365 – ALM Manifest 

Development and Deployment Approach  

We do have some rules defined how development should happen and be planned in general, all around ALM (Application Lifecycle Management). There can be some differences for each product in terms of their complexity and circumstances. 

Technical and development-specific rules: 

  1. Solution and Components should all have the same publisher.  
    There should be only one Publisher for all Products that should be used across all components and solutions. 
     
  1. The technology approach and implementation are crucial for the scalability of the product and should be chosen wisely at the beginning of the project. 
    Deprecated functionality needs to be replaced as soon as possible and not even considered in the first place.  
     
  1. Every solution must be available as unmanaged in an own environment which is part of the tenant. Each solution should only have changed and newly developed components and no dependencies on non-product-related solutions.  
    The Environment must contain access for global Administrators and the Development Team.  
  1. Solution components must follow internal specific naming conventions. (e.g., icons: hel_*name of the icon’_icon.svg) 
  1. Solutions contain a changelog providing the latest changes and updates made to the solution  
  1. The solution is connected to a git repository. Changes are tracked automatically, while commits happen after crucial changes and before updates.  
    All commits must contain a speaking comment to provide context of recent changes.  

Deployment 

Our target is to continuously improve our deployment process with fewer manual steps. We distinguish today in three different processes of deployment: 

  • Code Component / Custom Control Deployment 
  • Solution Deployment  
  • Release Distribution 

Each of these processes comes with a different scope, restrictions, and requirements. But all of them should be based on the ALM (Application Lifecycle Management) Approach.  

Code Component / Custom Control Deployment 
Accessed by: Developers 
Purpose: Deploy changes to Dev
Functionality: Build the desired branch version of the code repository (e.g., Custom Control, JavaScript, Plugin, Application) and update the target dev environment with the selected version. 

Solution Deployment 
Accessed by: Maker, Developers, Product Owners 
Purpose: Build and deploy the desired Solution version to UAT And Production Environments 
Handled by: Power Platform Pipelines  
Functionality: Check-in changes in the Repository, Export the latest version from DEV Environment, Quality Check on Export (Solution Checker) , Build Solution via Build Environment (unmanaged), potential Automated Testing, Export Solution as managed, potential Quality Checks, Store Artifact as managed in Repository, Deploy managed Solution to QA / Test Environment  

(Example pot. Solution Deployment)  

Release Deployment 
Accessed by: Product Owner 
Purpose: Build and store release-candidate Solution version  
Handled by: Build and Power Platform Pipelines  
Functionality: Build Solution via Build Environment (unmanaged) / direct by code stored in repository, Automated Testing, Export Solution as managed, Quality Checks, Store Artifact as managed in Repository 
Long-Term: Build AppSource Update Package and deploy 

Automated deploying of solutions minimizes the risk of human errors during that precise process. Especially with a larger team and multiple versions and branches, we want to be more than sure that all the functionality, features, and fixes we brought into the product are part of the solution we deploy.  
It opens accessibility as well for Testers and QA’s who do not need to have a full understanding of the manual deploying process.  

Product Artifact 

The final artifact we produce at the end of each development and deployment cycle is not only the technical product but our idea of how to leverage all the different and innovative aspects of the Power Platform for our customers and their end-users.  
 

OwlExpress365 – Tech Stack & Environments 

Power Platform 
Environments 

  • HOST
    Owl Express Host Environment: https://owlhost.crm.dynamics.com/ 
  • DEV 
    Owl Express Dev: https://owlexpressdev.crm.dynamics.com/ 
  • UAT 
    Owl Express UAT: https://owlexpressuat.crm.dynamics.com/

All Environments are organized in the same Environment Group “Owl Express.” They are also managed and organized with Security Groups to organize access.  

With a security group and role-specific permissions as security roles, we have full control about  the access to each environment and don’t interfer with other environments on the tenant.   

Solution Concept 

We currently drive a single-solution approach for customizations and development, that includes all custom components and changes we perform on top of Dynamics and Power Platform. AI and Copilot development is not included here, there is a separate solution to enable deployments and development in parallel.  

All changes are tracked with the Git integration to Azure DevOps and pushed to the repository with major changes and deployments.  

https://dev.azure.com/owl-express/_git/Owl%20Express

Changes are deployed to separate Dev branch. Via Pull Request and additional review by at least one other person than the author, changes can be merged into the main branch for productive usage.  

Deployment  

All dev solutions are transported automatically from the dev environment as managed to the UAT and Production environment. With the Power Platform Pipelines, we can trigger a UAT only deployment or a full deployment, which covers UAT and Production.  

The pipeline is triggered from the Dev Environment. During the validation and publishing, we generate a new artifact in the Host environment and increase the version number. The final deployment happens through SPN, which requires additional approval (posting to Teams) for the production environment.  

The version number is set up to meet the following criteria: 

MajorVersion.MinorVersion.Date.NumberOfDeployments 

Release Notes are AI-generated while we maintain custom release note via Configuration Page, this provide functional context and technical details.

Further Solution Distribution 

The Power Platform Catalog is an additional source to distribute our solutions within the tenant. With each crucial change, the developers are publishing a new update to the catalog. The request will be verified and approved if all criteria are met.  

Afterwards the new update is available in the catalog for makers and low code developers.  

Dependent solution deployment 

OwlExpress uses some third-party solutions. These will be deployed as managed solutions to the different environments. The deployment happens via Azure DevOps Pipelines: 

After discussing internally between Azure DevOps Pipelines and GitHub Actions, we decided to stay centralized in Azure DevOps.  

The following third-party solutions are used: 

  • dhino 
    Purpose: Authentication of external users against Dataverse Data (OwlExpress app) 
  • Solutions 
    – dhino_API_Core_1_0_0_23_managed.zip 
    – dhino_Authenticate_1_0_0_27_managed.zip 
    – dhino_Fetch_Core_1_0_0_58_managed.zip 
    – dhino_Forms_Core_1_0_0_2_managed.zip 
  • PCF Tag Control 
    Purpose: Add Characteristics to a Student via a tag control on the form directly  

     
  • Solutions 
    – OPC.PowerApps.PCFControls.zip 
  • Resco PCF Control: File Uploader 
    Purpose: Used to attach Files to an Student Application  

  • Solutions
    – pcf-file-uploader-1.0.0.0.zip 

PCF Development 

PCFs are being created using a Test-Driven Development approach. We are also using cdsproj based solutions to simplify the build and deployment to the target environments. The cdsproj enables us to create the solution zip file easily and import that using the “pac cli” or the Power Platform Tools from Azure DevOps. 

The full source code is also stored in the used Azure DevOps Repo, to aim for a full centralized development surronding  

Frontend / Static Web Apps 

The frontend app “Owlexpress.app” is developed as a custom static web app using HTML / CSS / JSX. It is checked in to a GitHub repository with automated deployment triggers for the connected Netlify sites. Netlify was chosen because it offers the best support for static web apps when using them in a hybrid mode with server-side rendering which we need for the authentication part. 

Tech Stack 

  • Astro Framework 
    Base Framework for static web apps 
  • TailwindCSS 
    CSS compiler 
  • Daisy UI 
    TailwindCSS component library 
  • Dhino  
    ntegration with Dataverse with authenticated external users 

Environments 

  • DEV 
    Locally on machine 

Deployments 

Deployments are triggered by pull-requests on the main branch and are executed within the Netlify deployment system. This was chosen because Netlify supports all the server-side rendering capabilities needed for the authentication part of the static web app. All secrets are set up as environment variables to keep them outside the repository. 

Fabric / Power BI 

We maintain alignment with all Dataverse environments by having the following Power BI workspaces configured: 

All development activities are carried out within the DEV workspace. We then leverage Pipelines in Fabric to deploy changes into each downstream environment. This allows us granular control when deploying components and to view potential “diffs” between environments: 

AI and Copilot  

Copilot related components are structured in a separate solution to the already existing customizations. Components used across multiple agents are organized in solution-aware component collections.  

Because creating a new agent generates a various number of components, we decided to split. Also to potentially deliver our solutions without AI for different Regions. Europe, looking at you.  

As all components are part of the Power Platform solution that is on the Dev / Test and Production structure of the Power Platform we can use existing Power Platform Eco-System including Pipelines for the deployment and also publish the AI components to the Power Platform Catalog.  

Have your school under control with Marauder’s Map, incuding mobile app and searching in multiple ways

14:41: Updated to include additional information around embedding the map in a mobile app and searching in multiple ways.

You want to see if other professors are around in the school? We found a magical map in the School form of our OwlExpress app. The Marauder’s Map is using Websockets magic to track everyone on the school premises Right Now.

It also is using device embedded voice recognition to understand your spells, you need to say: “I solemnly swear that I’m up to no good.” if you want to see the map.

When you are done and want to hide the map you must say: “Mischief Managed!”.

Do you like the glossy pixels of this map?

Mobile Map

We have also managed to embed this into a canvas app for a mobile delivery for sneaky students upto no good.

Searching in many ways

We have also introduced a glossy new feature for searching our student database in multiple magical ways, searching via standard text boxes, searching by scanning a business card, drawing a students name and utlising Copilot.

Everyone needs AI – Witches and Wizards too!

The area of AI and Copilot has started and finally has reached the wizarding world. The Ministry of Magic is using several AI-based features to automate their Letter heavy processes.

And now it’s also time that school like Hogwarts use AI to support students and upcoming students with their application process.

This follows certain guidelines to protect the magical users privacy and the right handling of sensible data.
We don’t want to spill the tea about death eater, unforgiving curses or you-know-who don’t we?

First of all, we want to protect the privacy of the users and internal business data. Such as the information about our students and their applications

This sensible data is excluded from our externally accessible HermioneAI. We only make that available as knowledge base for specific teachers on Microsoft Teams.

Additional the authentication itself is based on Microsoft Entra, to limit the risks of leaking sensible data.

This makes general and internal knowledge available to selected teachers of the school:

In this example, we use AI to search for specific information from Dataverse and display internal data that has been summarized and collected for easy access to the End User Wizard.

The handling of information and authentication is different on our web application: https://owlexpress.app/chat

As this is publicly available, mainly for students going through the application process, no authentication is necessary. Also these users don’t have access to internal data and only rely on Hermione’s general knowledge. Which already is huge.

Similar to the internal chat experience, the external relies on security measurements to avoid certain topics or harmful content. This for example covers Death eaters, You-Know-Who and the dark side of magic in general, but also jailbreak attempts

So, if a potential student or any other user of the chatbot on the website asks about joining the dark side, forbidden spells or details on You-know-who, we won’t help here

Plug N’Play: Modern Flow Approvals with Microsoft Teams

Approval processes are common for every organization across the globe, including wizarding schools. They arguably hold a more important place then ever with the rise of artificial intelligence, as a “human in the loop” approach can avoid some of the shortcomings with the technology, such as hallucinations. For our solution OwlExpress, we have two primary requirements in this area:

  • The release manager must receive a notifications in Microsoft Teams to approve all releases into our downstream environments.
  • If a prospective student is suspected to have characteristics that could make them a future Death Eater, then we again need to bring this to the attention of several teachers in Microsoft Teams to review and record the outcome.

For the first requirements, we can tap into our Power Platform Pipelines host environment which is fully configured to support automated ALM for our solution:

There is no support for native approval creation as part of Power Platform Pipelines, so we must instead create a cloud flow to orchestrate this:

For the second requirement, we’ve blogged already on how this solution works. So for the purposes of this blog here, we can just focus on the “good stuff” – the end result approval received in Microsoft Teams:

By having the approvals appear in Microsoft Teams, we can not only solve several business requirements, but also show the benefit of the unified platform.

Lets go mobile

Our professors are active people, always flying around and disaparting between location, so we need to ensure that they can select and review applications for wizardry schools on the go.

Power BI mobile view

Mobile version of PowerBI Segmentation report

This dedicated verson allows interactive on the go.

Mobile Model Driven Apps

For individual students, we reduced the displayed content for mobile devices, the unnecessary address data is not shown on mobile devices, improving the usability of the application while remote.

Showing desktop experience
Mobile version of the app

Pro Code + Low Code = More Fun For All

Badges Claimed: Power User Love, Go With the Flow

Sometimes it’s quite fun to mix together plug-ins and cloud flows. The key advantage of a plug-in is we can more flexibly specify our logic and ensure we can run things synchronously; whereas with cloud flows, it’s a great tool for background processing or “simple” automations, while also providing some discrete functionality not available to plug-ins, such as modern approvals. Mixing these tools together can only lead to good things, and would surely make Professor Slughorn proud.

Let’s first of all set the scene: our OwlExpress solution needs to flag whenever a young student is processed by the tool containing a Characteristic that could be concerning. For example, any student with the “Parsletounge” characteristic is almost certainly a potential heir of Slytherin, and needs to be watched carefully. So we need automate the following steps to help make this process smooth:

  • On Associate of a new Chracteristic, check it’s value and, if it’s one of concern, update a flag on the Student (Contact) record accordingly to indicate a possible future death eater.
  • Once this flag is updated, send out an approval so that a Teacher can check this manually and make a decision either way. Human in the loop here is crucial to avoid any bias from automated decision making, and to ensure the school does not get sued 😉

There is no out of the box trigger for Associate with cloud flows, but fortunately. this is where a plug-in can come to the rescue. First we see an example below of the code we use:

This presented an interesting challenge, as no one on the team had previously written a plug-in for this message. One interesting thing to note is that when registering the plug-in step, it’s not possible to specify a primary / secondary entity. This is why the code has to do some specific checks for the relationship name:

Everything works fine with the code, and once the appropriate flag field is updated, we can then finalise the remaining requirements using a cloud flow:

A teacher can then review and faciliate an auditable mechanism for the human reached decision, saving a great deal of time and effort in having to analyse prospective student profiles manually. We think this is a really great way of mixing together both of these tools to automated a business process!

The benefits of mixing magic with ancient magic

Our OwlExpress solution needs to get the list of possible future wizards from a different set of data sources. We are merging these data into a PowerBI report so that the segmentation can be easily done using the slicers in a more intuitive way.

This Report is integrated into an MDA using a PCF control that House Elves Limited created that can save the segment chosen by the user using the Export Segment command.

This will trigger a Power Automate flow that will create the applications for all future students of the chosen segment.

To integrate the PowerBI report the following API’s are being consumed:

The PCF component has been developed using Test Driven Development and Storybook which allows you to fail fast and often and reach success faster.

The component is a react/virtual component, which simplifies a lot the separation of concerns into different components.

The code has been structured using the best practices for PCF components. We are using a Solution Project to simplify the build of the Solution that contains the component.

To standardize the build and deployment process and to ensure that the PCF Version is always kept in sync with the containing Solution version a couple of PowerShell scripts have been written. This helps also with the Azure DevOps pipelines because these can be simplified to execute the exact scripts that the developer executes on their machine.

Leaked Email: The Existential Risk

Kreecher, I don’t even know where to begin. This technology is deeply concerning. What if a dark wizard was to reverse it and use it to hunt and identify innocent wizarding children? And with no human oversight at all??? Remove this from the platform immediately!!!

Argus Diggory

CEO, House Elves Limited

————— Original Message —————
From: Argus Diggory [argus@householdelveslimited.co.uk]
Sent: 23.01.2025 15:57
To: Kreecher [kreecher@householdelveslimited.co.uk]
Subject: Promising New Platform Feature

Master Argus,

My team have been very productive this sprint with this new muggle technology of “AI Prompts” for our OwlExpress service. We are delighted to have now produced a prompt that can help to categorise wizards based on their history of magical activity.

We have tested this extensively and can see some excellent resuts, therefore allowing us to automatically tag activities we have collected about young wizarding children in Dataverse with the appropriate rating value:

I’m sure, dear master Argus, you will be most pleased at this opportunity to automatically decide the fate of young wizarding children across the globe, with little or no human oversight required.

Awaiting your feedback

Kreecher

We Love our Sponsors

Our solution would not be possible wihtout the hard work and dedication of our sponsors solutions, enabling magical abilities we would not be able to reproduce and transforming our solutions with wizardy love.

Link Mobility

Our first process is to send an Owl with the letter to invite prospective wizards and witches to their school. If the wizard is an area which doesn’t have good owl coverage, due to extreme weather conditions, muggle political infighting or just too far away, we send them a text with their invite

This is done via Link Mobility in Power Automate, utilising their API to send out an invite to our Static Web App Portal.

This is received by prospective sorcerors as a text message

Oneflow

Once the prospective candidate has filled out their details and qualified for the next stage, we need to get agreement from their parents or guardians to allow them to attend wizarding school, and ensure they agree to go to diagon alley to get the wizarding items to prepare the new wizard for school.

This is enabled by the Contract templates and capablities of Oneflow solution.

Firstly we set up a template, then using their API, create a contract based on that template. and sent to the parent of the prospective students.

The parents then get to sign in to Oneflow to enter their details as well as the students and confirm they agree to the terms, all seamless!

Resco

For Resco, we had an abundance of choice to use their PCF components. This control bring usability to the platform easily.

We embedded the multi attachment uploader into our applicaiton process, allowing uploading of many documents all at once in an easy and user friendly manner.

PCF Gallery

Finally, not content with just those 3, we have used a PCF control from the PCF Gallery. This control is a Tag Picker, which allows quick and easy association and disassociation of records via the many to many relationship.

We used this to allow a simple, user-friendly process to associate characteristics to our potential sorcerors.