Enabling seamless communication between the backend and frontend is a must for delivering smooth user experiences. For our solution, we leveraged three powerful Azure cloud APIs to facilitate a direct line of communication between our backend and frontend, optimizing the process of running and analyzing conversations with a bot service.
In our case, we needed to ensure that the backend and frontend could communicate efficiently with a bot service, run conversations using an AI model, and analyze the interactions to improve the user experience—all while keeping things fast and responsive.
To achieve this, we turned to Azure and integrated three critical APIs:
Direct Line API (Bot Service): For communication between the backend and the bot.
Azure OpenAI API: To power the AI-driven conversations.
Azure Language Service API: For analyzing the conversation and extracting valuable insights.
Like a shapeshifter, Low Code apps need to adapt to any device. This app can do so with container and adding or removing flexible height when needed. Now with these potions we can look good on any device.
#Chameleon
Now we will create a Flow which only input is the user´s Full Name and it will return a score for each user based on a filtered table for the user. This score will classify each user as a “Ron”, a “Hagrid” or a “Snape” depending on their working hours.
A Ron is usually someone that doesn´t do much in their team and could try to participate more every now and then.
Or maybe, our honorable jury feels like its a good idea delegating some work in the hackaton to their Digital Twins and free up some time for “Me time”? Well, we thought about this already, as in our Wayfinder Academy, we really needed you to help us in interviewing students that send us their applications to get help on defining the faculties they truly belong to. So, given how busy you are, we used Elai.IO to generate videos that visualize you running an interview.
It went so well, that we went further to implement Copilot Agents (WE LOVE THEM!!!) so that they, fed by the data related to you and available, will provide real time experience for the students going thru the interview or getting some mentorship as if they are talking to you and not your digital twin.
Our modernized learning path for our students, makes it easier for us to track mischief. If they use our Dobby bot and ask for a uspisicous spell or potion, we as teachers would like to know. We wouldn’t risk a to develop an evil wizard again would we.
We are able to track these mischievs in our solution, but we also want the students to take accountability.
That’s where Oneflow came to the rescue. Its seamless integration with Dynamics allowed us to manage mischievement contracts directly within our solution. Students can now sign their “I must not tell lies” agreements with ease, and we can monitor every step—from creation to completion—all in one place.
The contract gets created in Power Automate containing the student’s full name, and is dynamically mapped to the mischief record and sent to the student.
When the student sign the contract, we can automate our solution by utilizing the powerful OneFlow trigger to update the Mischievement status to “Resolved”.
In today’s fast-paced development environments, efficiency and speed are essential to delivering quality applications. A critical part of this process is the deployment pipeline—especially when packaging code and pushing it to production. Manual workflows can slow down progress and lead to inconsistencies. But what if we could automate this entire process? That’s exactly what we did by integrating Terraform into our workflow, which significantly improved our productivity. Clearly, we needed a solution that would streamline this process, reduce errors, and make deployment faster. That’s where Terraform came in.
Automating with Terraform: The Game-Changer
Terraform is an infrastructure-as-code tool that allows us to define and manage infrastructure through code. By automating the workflow using Terraform, we were able to create a smooth, reliable, and repeatable deployment process. Here’s how it helped us:
1. Automated Code Packaging
With Terraform, we set up an automated process that packages our application code whenever there’s a new change. Instead of developers manually running scripts to package their code, Terraform automatically takes care of it. This ensures that the code is always packaged correctly, reducing human error and saving developers valuable time.
2. Seamless Code Deployment
Once the code is packaged, Terraform sends it directly to the application. This is a huge improvement from previous workflows where developers had to take several manual steps to push the code to different environments. Now, Terraform takes care of everything, enabling us to deploy code with a single command.
3. Time Savings and Increased Productivity
By automating the packaging and deployment workflow, developers can focus on what they do best: writing code. With a single command, they can push updates and changes to the application, significantly speeding up the release cycle. This leads to faster development times, quicker iterations, and ultimately, increased productivity across the entire team.
In the bustling chaos of the ACDC Hackathon, we faced a peculiar challenge. Our project needed to process data from a Harry Potter API containing spell names and add them as products in Microsoft Finance and Operations (FO). However, before creating new products, we had to ensure that duplicates weren’t accidentally added.
A traditional solution would involve filtering existing records in FO—a task that’s as slow and resource-heavy as brewing Polyjuice Potion without instructions. With limited time and resources, we knew there had to be a faster, more creative way.
The Hack: Dataverse as a “Logical Trap”
Instead of overloading FO with complex filtering operations, we turned to Dataverse and found a unique, “dirty” shortcut to handle this problem efficiently.
Here’s how it works:
The Spell Log Table: We created a custom log table in Dataverse, where each row represents a spell. The table’s key field is the spell name.
The Power Automate Flow:
The flow periodically retrieves spell data from the Harry Potter API.
For each spell, it attempts to add a new row to the Dataverse log table.
The Logical Trap:
If adding the row fails (due to the spell name already existing as a key), we know the spell is a duplicate and skip further processing.
If the row is successfully created, the spell is new, and the flow proceeds to create a product in FO.
This clever use of error handling as a control mechanism allowed us to avoid the inefficiencies of traditional filtering.
To better visualize the process, here’s a snapshot of the Power Automate flow at work:
Why This is a NaSTY Hack
This approach bends conventional methods in favor of speed and efficiency:
Creative Use of Errors: We transformed API errors (failed row creation) into a functional feature of our workflow.
Unorthodox Logic: Instead of directly querying FO for existing records, we let Dataverse act as a “pre-check” system, cutting down on processing time.
Quick and Effective: While not the cleanest or most standard solution, it’s perfect for a fast-paced hackathon setting.
Rapid Implementation: Leverages Dataverse’s existing capabilities, saving development time.
Hackathon-Ready: Delivers results quickly, aligning with the fast-paced nature of the event.
Challenges and Caveats
Of course, no hack is without its downsides:
Not “Best Practice”: Feels a little like cheating and may confuse future developers unfamiliar with the context.
Potential Fragility: Relying on error handling for functionality might lead to issues in more complex scenarios.
The Verdict
This nasty hack is a testament to the power of creativity under pressure. By thinking outside the box, we turned a potential bottleneck into an efficient, elegant workflow.
And isn’t that what hackathons are all about—solving problems with a mix of ingenuity, magic, and just a hint of chaos?
So, with Yurii the Wise, we are connecting our Bluetooth device to the internet.
This article describes implementing an IoT device: a Bluetooth to MQTT gateway. The idea is to implement a device with both Bluetooth and Wi-Fi connectivity. Then, all captured data from the BLE can be streamed to the IoT Gateway.
The controller is M5Stick C plus2, based on the ESP32 System on the Module.
We implemented the firmware in the Arduino IDE, which can be used to create a fallback Wi-Fi access point to initialize the Wi-Fi and MQTT connection details. The firmware was written in C++ language using the Arduino framework. We also flipped the bit to turn on the Bluetooth proxy oximeter automatically and turned on the screen to render average values of the SpO2 and BPM.
How does it work?
We used the following external library:
PulseOximeterLib library to interact with the Pulse Oximeter device. This lib provides the parsed pulse data as well.
WiFiManager facilitates the onboarding process when the device creates the Fallback Access point to configure the Wi-Fi and MQTT connections.
We are building the firmware with the Single-responsibility principle to encapsulate the logic of interaction with different peripheral devices and make the logic of main.ino file as clean as possible. Unfortunately, making it work in that couple of days was impossible, and the result was unstable. But stay tuned; we will release the repo with the worked code soon.
One of the standout features of our solution is its ability to interact directly with APIs. The beauty of the solution lies in its simplicity—no complex setup required. You can communicate with the Sorting Hat using nothing more than text input. Right now, you can interact with the solution through the Hat itself, but it doesn’t stop there. You can also access it through your phone, Sorting Hat integrates seamlessly with tools like Microsoft Teams, bringing the power of intelligent communication right into your workspace.
Thanks to an iframe integration, you can embed the Sorting Hat interface directly into your website or application. Our partners at LogiqApps have already implemented this solution with impressive results, using it to enhance their user experience and streamline communication on their platform.
While the most user-friendly options are accessible through the Hat, phone, and integrations like Teams or iframes, sometimes you need a more technical approach. For those who like to dive into the guts of the system or if you’re facing a more urgent need, you can communicate directly with Sorting Hat through Postman. This might seem like a step back in terms of convenience, but it’s a testament to the flexibility of the solution.
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.
Faruk the Fabricator who travelled all the way from sunny Istanbul, got really frozen outdoors. So he came back unusually alerted and went straight into work, to warm up.
Data activators is up. When failure is close, our Fabricator will know.
An alert has been set for the KPI column. When it falls below a certain value we send an email and alert the user.
More will come with table based data activators. This is just the beginning.
Faruk the Fabricator is just warming up…
PS: we claimm PlugNPlay badge for the sending notifications to TEAMS
