Tag Archives: Code Connoisseur

Final Submittion – OUR JOURNEY AT ACDC 2O26

Posted on by

Problem statement: We came to ACDC Hackaton 2026 with an ambition to solve the problem that exist in supply chain, that affects everyone involved. Global spare-parts supply chains are slow, fragile, carbon-heavy, and often fail when parts are obsolete, or manufacturers no longer exist.

Original Solution we wanted to build: CraftPortal replaces shipping with digital “crafting,” using AI and cloud technology to match, recreate, and produce parts locally- fast, resilient, and sustainable. It was, however, focused on the idea from ou perspective and plan to refine this concept during the hackathon.

Evolution Journey: and then happened why we love ACDC Hackaton for.

– “Put the Customer in focus”, said Sara on the opening day, our beloved judge on Digital Transformation category.

So, we worked on the idea to enrich our web application solution to include the ISV package and give our potetial customer with UI and UX they recognize well, namely M365, Power Platform, BizApps.

– “I love your futuristic concept…” said Mikael from Redstone Realm perspective and inspired us to combine Microsoft 365 / Dynamics 365, SharePoint, Teams, and Azure

“Simple code screenshot is not enough, show me how it solves your problem”, noted Keith (Code Connoisseur),  and we challenged the status Quo and wanted to generate bigger impact…. So what we did is

“Turn data into insights….”, reminded Cathrine from Data, AI and Analytics, and we revised our data model focusing to build a solid fondation for our solution, so we could start to map external data sources and motiveted us to explore RAG.

“Everything you have there has to be there for a strong reason” warned us Fredrik from Low-Code angle in the start, and we critically reviewed our ecosystem to follow strict focus on the power of the low code.

“No security holes” declared Scott on Governance and Best Practices and you don’t mess with Scott. No fluff, we need a proper best practice focused ALM and Governance for the whole application.

As a result of continued brainstorming during these 3 days, and dialogue, our refined Solution started to look like this: … scroll down:)

DIGITAL TRANSFORMATION

The Concept

Supply chains are slow, fragmented, and carbon-heavy. Parts ship across the world when they could be printed locally. CraftPortal changes this – a marketplace where recipes travel through the portal, parts get made nearby. Faster. Greener. Smarter.

Customer needs a part. Can they print it? Yes – browse marketplace, select blueprint from IP Owner, print, deliver. No – publish a tender, receive bids from Manufacturers, select, award, contract, they print, deliver. Two paths. Same portal.

We built two paths to CraftPortal. A SaaS web application for users who want to jump straight in. And an ISV package for customers who want CraftPortal wired into their Microsoft 365 environment.

Users choose: Web App or Power Apps:

Customers who prefer Model Driven App get a clean, familiar UI – the Power Apps experience they already know, tuned for digital inventory workflows:

But they can surely use our fancy web app. Vendors – IP Owners and Manufacturers – use the Portal interface. They browse public tenders, submit bids, upload recipes, manage contracts, track orders. All through Power Pages.

Value & Monetization

CraftPortal sits in the middle of every transaction. Recipe rented? We’re there. Part printed? We’re there. That’s the value.

Monetization options:

  • Subscription – monthly/annual access to the platform
  • Transaction-based – percentage per recipe rental, per tender, per print job

Or both. Base subscription for access, transaction fee for volume.

LOW-CODE

Low-Code: The Redstone Behind CraftPortal

We built CraftPortal in 3 days. A marketplace. Tender flows. Vendor management. Document automation. AI agents and Power pages portal. How? Low-code.

The Building Blocks are as follows:

Power Pages for the Portal. Model Driven Apps for back office. Power Automate for every flow. Copilot Studio for autonomous agents. Dataverse for data. Generative Pages for dashboards.

We wired it together with clicks, not code.

The Low-Code Highlights

  • Autonomous agents – Copilot Studio detects Dataverse changes, posts to Teams, triggers RPA
  • RPA integration – Power Automate Desktop opens Bambu Lab Studio and clicks Print.
  • Teams + SharePoint + Dataverse – Fully automated channel and document location creation via Power Automate
  • Generative Pages – KPI dashboard pulling live Dataverse data
  • OneFlow contracts – Power Automate creates and sends contracts for signature
  • Link Mobility SMS – Automated bid notifications
  • Custom Connectors – ISV package API integration
  • FetchXML Builder – Low-code query generation (we click buttons, it writes XML)

Deep Dives

Want the details? We documented everything here:

The Result

A full digital inventory platform. Built by a small team. In 3 days. Low-code made it possible.

CODE CONNOISSEUR

Low-code gets you far. But sometimes you hit a wall – a custom UI that doesn’t exist, real-time updates that Power Automate can’t handle, or an API that needs to be built from scratch. That’s when we switch gears. Pro-code fills the gaps.

We have various code projects and components in our solution:

  1. PCF Control. That allows customers to order the appropriate equipment that should be printed. Client Side Salsa | Arctic Cloud Developer Challenge Submissions
  2. Power Pages Portal. That manages turning basic Minecraft resources into different tools and help clients to find an appropriate vendor for printing adapts to all devices and screen sizes. Chameleon | Arctic Cloud Developer Challenge Submissions
  3. Web Portal for the 3D printer. Using this custom local web portal we manage our printer device. Crafting, Crafting, Crafting…. Category: Pro Code  | Arctic Cloud Developer Challenge Submissions
  4. Model builder app – which is helping customer recover lost recipes from the single shot; Right now – bring real-time data to the app | Arctic Cloud Developer Challenge Submissions
  5. Azure Function – used to communicate with the external vendor API. ISV Package – the missing link | Arctic Cloud Developer Challenge Submissions

DATA, AI, ANALYTICS

The Dashboard

Our CraftPortal KPI Dashboard brings it all together. Built with Generative Pages and React, pulling live data from Dataverse:

  • Summary cards – Total Projects, Open Projects, Total Bids, Wandering Traders
  • Project Status Distribution – Donut chart showing lifecycle states
  • Bid Conversion – Submitted vs selected bids
  • Win Rate by Trader – Performance leaderboard
  • Projects per Month – Trend analysis over time
  • Top Wandering Traders – Gamified rankings

Light mode. Dark mode. Minecraft item icons from the official API. Business intelligence with a blocky twist.

We built the foundation. Dataverse as our core. Power BI dashboards for KPIs – tender status, bid conversion, vendor performance, projects per month. Live telemetry streaming from our IoT-connected Crafting Tables via Azure IoT Hub. Real-time monitoring of print jobs, temperatures, and device health.

Last year we went deep on Microsoft Fabric – Medallion architecture, Data Activator triggers, the whole pipeline. We didn’t want to repeat ourselves.

The Vision

The vision was fun: a custom Knowledge-based Copilot powered by Fabric. Pull external data from the official Minecraft API (GitHub – PrismarineJS/minecraft-data: Language independent module providing minecraft data for minecraft clients, servers and libraries.)

via Azure Data Factory. Deploy a proper RAG pipeline – chunking strategies, metadata filtering, semantic search, hybrid search, custom retrievers. Debunk RAG the right way.

Unfortunatley, we barely finished the data platform in time. The RAG adventure stays on the roadmap.

Sometimes three days isn’t enough. But the foundation is solid. The diamonds are waiting to be mined.

GOVERNANCE & BEST PRACTICES

Essence

Our goal during the hackathon was to show the complex implementation of the project with different aspects of the implementation.

When it comes to even the industry focus switched to AI related topics it still requires advanced level of the solution design to enable existing services for the LLM.

That is why we mentioned advanced level technologies such as: Azure Local, Lighthouse, and IoT Hub.

At the same time complex solutions usually require more effort for implementation. By following best practices of each piece of that puzzle, we are increasing the overall success rate of the delivery. ISV Package – the missing link | Arctic Cloud Developer Challenge Submissions

REDSTONE REALM

We created our business solution using Microsoft technologies - Open AI, Azure DevOps LLMs, Azure Function, Outlook and Microsoft teams. Check out the article ISV Package – the missing link | Arctic Cloud Developer Challenge Submissions

By deliberately meeting and exceeding every requirement across Digital Transformation, Low-Code, Pro-Code, Data & AI, Redstone Realm, and Governance & Best Practices – while continuously refining our solution through your direct feedback – we believe CraftPortal represents the complete ACDC vision, and we thank the judges for challenging us, guiding us, and inspiring us to build something truly worthy of this win.

Thank you for ACDC 2026!

With love, team LogiQraft.

PS! We really wanted to share a PREMIERE of our final movie with you, before the official release so here you go https://www.youtube.com/watch?v=KV2p3FNTLNI

ISV Package – the missing link

Posted on by

We’ve shown you the concept. The roles. The flows. The tech stack. Now let’s talk about how this actually lands in enterprise.

The simple Steve logs into an external portal. Rents recipes. Publishes tenders to print from manufacturing vendors. Monitors production and delivery status. All from the portal interface.

Works great.

But enterprise Steve, the one working at Equinor, IKEA, or Siemens -+doesn’t just browse marketplaces. Enterprise Steve has:

  • An ERP system
  • A CRM system
  • Procurement workflows
  • Approval chains
  • Compliance requirements
  • IT policies

Enterprise Steve needs CraftPortal connected to his world. His tenant. His systems. His processes.

The ISV package bridges these two worlds. Customer data stays in customer tenant. CraftPortal handles the marketplace, IP Owners, Manufacturers, the recipe catalog.

No workflow fragmentation. No copy-paste between systems. No “let me check the other portal.” One flow. Connected.

What Customer Get

Power Platform Components

ComponentCraftPortal Examples
TablesTenders, Recipes, Vendors, Manufacturers, Bids, Projects, Parts
DashboardsTender Overview, Production Status, Vendor Performance
PCF WidgetsRecipe Viewer, 3D Model Preview, Status Tracker
Power Automate templates“New Tender → Notify Vendors”, “Bid Awarded → Create Project”, “Part Printed → Update Inventory”
Security ModelRoles: Procurement Manager, Vendor, Manufacturer, Viewer

What We Get

  • AppSource listing = discoverability, Microsoft co-sell, enterprise credibility
  • Do this right and CraftPortal becomes invisible infrastructure — always there, impossible to replace

That’s not a customer. That’s a permanent relationship.

The tech stuff

Our ISV package includes two data integration flows. Custom Connector for on-demand requests — direct calls to CraftPortal API when you need real-time actions. Cached Core Data for near real-time sync — we push core data into the customer’s environment via Azure EventGrid into Azure SQL and Dataverse. Why both? Cached data enables full delegation in Power Apps. No query limits. Instant performance. Citizen developers query local tables instead of external APIs. CraftPortal data that feels like their own.

The Code

Azure Function Trigger & Interface

Trigger Type

1) HTTP-triggered Azure Function (API Gateway)

  • Used for synchronous operations and for publishing events
  • Secured via Azure AD authentication

2) Event Grid–triggered Azure Function (Event Processor)

  • Subscribes to Event Grid topic events
  • Processes vendor integration asynchronously
  • Updates Dataverse with final status/result

Interface Characteristics

  • REST-style endpoints
  • JSON request/response payloads
  • Versioned route (example):

/api/v1/vendor/operation

The Release

Power Platform Environment Strategy

Source control strategy

Repo structure (example)

  • /solutions/<SolutionName>/ (exported source using Power Platform CLI/PAC)
  • /pipelines/ (YAML for CI/CD)
  • /tests/ (integration test scripts, Postman collections, Playwright scripts, etc.)
  • /docs/ (release notes templates, runbooks)

CI Pipeline

CD Pipeline

Building the ISV package deliverable

An ISV-style deliverable usually includes:

Managed solution ZIP(s)

  • Core solution (managed)

Installation guide

  • Required licenses and prerequisites
  • Import steps
  • How to set environment variables
  • How to create/bind connections
  • Security roles to assign

Configuration workbook

  • List of env vars, defaults, required values
  • Connection references mapping
  • Any URLs/endpoints

Release notes + known issues

  • What changed, what to verify

Support / troubleshooting

  • Common import errors
  • How to re-run failed flows
  • Health check steps

Infrastructure as a code

In our solution, we are using both managed power platform ISV and dedicated cloud infrastructure for them.

It means that each customer should deploy his own Azure infrastructure to unlock Power Platform solution distributed via the AppSource.

We are introducing it via the one click Azure infra deployment process. Model driven app has dedicated admin App which is Allowing user run call the deployment by himself after the main package installation.

Referance: https://learn.microsoft.com/en-us/azure/azure-resource-manager/templates/deploy-to-azure-button?WT.mc_id=IoT-MVP-5002324

Deployment

Note: The selection of the resourcegroup is not part of the BICEP / ARM template. It expects a resource is available. This selection is provided by the portal.

To support that scenarios, We need to provide the all the required bicep files, which are the blueprints for the Azure Services.

Benefits of Bicep

Bicep provides the following advantages:

  • Support for all resource types and API versions:
  • Orchestration
  • Repeatability

The following examples show the difference between a Bicep file and the equivalent JSON template. Both examples deploy a storage account:

Directory Structure

Deployment.

We are using couple of Docker compose files for prod and dev deployment.

It allow us simplify the infrastructure for the local development setup.

Keep in mind that the main rule of using docker-compose: No sensitive data should be hardcoded inside, all environment specific details must be placed to the .env file.

We are following a classic approach with private azure docker registry (ACR) to store frontend and backend docker images.

How to convince IP Owners?

The idea behind is receive all the benefits of owning the infrastructure + extra features of the Platform owner(LogiQraft) like dedicated, specifically designed AI services, Proactive monitoring system, etc…

To make it work, we are using Azure Lighthouse + Managed Identity.

How it works:

  1. The customer delegates a scope (subscription / resource group) to you via Azure Lighthouse. 
  2. Your identity in your tenant (this can be:
    • a Managed Identity, or 
    • a service principal/app)

is granted a role on their resources through that delegation.   

  1. You then query their Application Insights / Log Analytics data using your identity, and Azure enforces the delegated RBAC.

Why Lighthouse is ideal:

  • No need to create/maintain identities in every customer tenant
  • Customers can revoke access easily 
  • Scales across many tenants
  • We assume that IP Owners would be careful to share their IP and by following this approach we are addressing their concerns
Categories: Redstone Realm , Governance & Best Practices , Code Connoisseur , Digital Transformation

Badges:  Power Of The Shell, ACDC Craftsman, Plug N’ Play

Glossy Glossy Glossy!

Posted on by

Badge: Glossy Pixels 

Category: Code Connoisseur  

Step into a Minecraft-style Power Powers portal where crafting meets collaboration. With customer placing orders and Alex bringing them to life, our system turns resource requests into crafted equipment through a smooth, intuitive workflow. Wrapped in a shiny, pixel-perfect interface that looks great on any screen, this experience proves that even blocky worlds deserve beautiful, responsive design. 

Customer profile page: 

In case customer wants to order some equipment, he goes to the Projects page.  

Then he chooses an equipment, for example Nether Machine Gear. 

And in gamified mode using drag and drop put ingredients to the slot and receive the result. 

After this Alex response to the request and makes the equipment. 

Alex profile page: 

Alex goes to the Pending Requests. 

Requests page: 

Then Alex clicks on the Start button responding to the request from the customer. 

The interface is designed with a dark, high-contrast Minecraft-inspired theme, combining pixel-style typography with modern, glossy components. Clear visual hierarchy, bold status colors, and card-based layouts guide users naturally through ordering, bidding, and crafting flows. Subtle gamification elements like drag-and-drop crafting slots and progress states make complex actions feel intuitive and engaging. Every screen is fully responsive, ensuring the pixel-perfect experience stays smooth and readable across different screen sizes. 

Categories: Code Connoisseur. Technically it was described in Chameleon article because this is the same portal. 

Craft Portal KPI Dashboard – Metrics Explanation

Posted on by

 

This document explains the key performance indicators (KPIs) and visual metrics used in the Craft Portal dashboard. The dashboard is implemented using Generative Pages with React and integrates with Microsoft Dataverse for data retrieval. Minecraft API assets are used to enhance the visual design with authentic item icons. 

Theme & Display Modes 

The dashboard supports both Light Mode and Dark Mode.  

Light Mode: 

Dark Mode 

KPI Definitions 

1. Summary Cards 

These cards provide a high-level overview of procurement activity: 

  • Total Projects: Total number of Projects in the system. 
  • Open Projects: Projects currently open for bidding. 
  • Total Bids: Total number of bids submitted across all projects. 
  • Wandering Traders: Total number of registered vendors. 

2. Project Status Distribution 

A donut chart showing the distribution of projects by status (Draft, Open, Closed, etc.). This helps users quickly understand the current lifecycle state of all projects. 

3. Bid Status Distribution 

This chart visualizes the ratio between submitted bids and selected (winning) bids, helping procurement teams evaluate bid conversion efficiency. 

4. Win Rate by Trader 

A horizontal bar chart displaying each trader’s win rate as a percentage of bids won versus bids submitted. 

5. Projects per Month 

This chart shows how many projects were created per month, allowing stakeholders to identify trends, seasonality, and workload distribution over time. 

6. Top Wandering Traders Leaderboard 

A ranked leaderboard displaying traders based on total wins. This gamified view encourages competition and makes vendor performance easy to compare. 

7. My Projects Table 

A detailed table listing all projects with sorting and search capabilities. Users can drill into and view individual projects directly from the dashboard. 

Dashboard Overview Screenshot 

Technical description for the Code Connoisseur category. 

Generative Pages with React 

This dashboard is built as a Generative Page component, which allows for dynamic, AI-assisted UI generation within the Microsoft Power Platform ecosystem. The component is written in TypeScript/React and utilizes: 

  • Fluent UI React Components (@fluentui/react-components) for base UI elements 
  • Custom Minecraft-styled components for visual theming 
  • DataGrid for tabular data display with sorting and filtering 

Microsoft Dataverse Integration 

The dashboard connects to Microsoft Dataverse using the dataApi prop provided by the Generative Pages runtime. 

Minecraft Item Icons 

All icons in the dashboard are sourced from the Minecraft API, a free public API that provides official Minecraft item and block images. 

https://minecraft-api.vercel.app/images/items

Chameleon

Posted on by

The Power Pages portal that manages turning basic Minecraft resources into different tools and help clients to find an appropriate vendor for printing adapts to all devices and screen sizes. 

We can consider 3 types of devices and Cascading Style Sheets (CSS) pixels for them:  

  1. Laptops/Desktops; Screen resolutions: 1920, 1440, 1280 px 
  1. Tables; Screen resolutions: 1024, 768 px 
  1. Mobile phones: 320-414 px 

Here it is important to mention that CSS pixels are logical units used by browsers to keep websites readable on high-density screens, while screen resolution is the actual number of physical pixels. 
The browser uses device pixel ratio to map CSS pixels to real pixels, so layouts stay the same size across devices. 

Let’s see how the different parts of Power Pages portal main page adapt to all these devices:  

Header with the menu. 

    1. Laptop/Desktop (1920 px, 1440 px, 1280 px) () 

    Across different laptop and desktop screen sizes (1920 px, 1440 px, 1280 px), the layout remains consistent, with width being the primary variation. Next, we will review how the interface appears on tablet and mobile screens. 

    2. Tables 

      1024 px 

        768 px 

          3. Mobile phones (320-414px) (the difference in width of page) 

            “Portal features” block. 

              1. Laptop/Desktop  1920 px 

              1440 px and 1280 px (The page width varies while the components remain responsive.) 

                1. Tables 

                1024 px 

                  768 px 

                    1. Mobile phones (320-414) px 

                    “Simple process” block. 

                      1. Laptop/Desktop (1920px, 1440px, 1280px) (The page width varies while the components remain responsive) 
                      1. Tablet (1024px, 768 px) (The page width varies while the components remain responsive) 
                      1. Phone (320-414 px) (The page width varies while the components remain responsive) 

                      “Active tenders” block. 

                        1. Laptops/Desktops  1920 px 

                        1440, 1280 px (The page width varies while the components remain responsive) 

                          1. Tables. (1024px, 768 px) (The page width varies while the components remain responsive) 
                          1. Mobile phones: (320-414 px) (The page width varies while the components remain responsive) 

                          Technical Overview 

                          This project is a React single-page application. It uses client-side routing via React Router to support multiple user flows, including public pages, a protected vendor portal, and an admin area. The application is written in TypeScript, ensuring strong typing and safer refactoring, and follows modern React patterns for component composition and state management. 

                          Project Organization 

                          Key Technologies Used 

                          • React 18 
                          • TypeScript 
                          • React Context API 
                          • Modern component-based UI architecture 

                          Client Side Salsa

                          Posted on by

                          Category: Code Connoisseur

                          Description of solution: 

                          Crafting equipment in Minecraft lets you turn basic resources into useful tools, weapons, and armor. Better equipment helps you gather materials faster, survive dangerous mobs, and explore harder areas more safely and efficiently. 

                          To allow customer to order the appropriate equipment that should be printed, we created a PCF control that allow to choose an item from hundreds of different. 

                          Let’s see how it works: 

                          We have a Recipe table where the customer can create a request to build the item. 

                          If we go to the form, we have two fields Name and Description. For the Name field we activated the PCF control, so the form looks like at the picture: 

                          Click on the search button and the modal dialog will be open with a more than thousand items to choose. Here we have possibility to choose the type of item and search by the name or description. 

                          And when customer choose the item, the name, description and small image are set to the fields on the Recipe Model-driven app form. 

                          Using external API: 

                          PCF control receives all Minecraft items thorough public Vercel api:  

                          https://minecraft-api.vercel.app/api/items

                          Let’s look at the code structure: 

                          index.ts – main file with our control 

                          components/MinecraftItemPicker.tsx – React UI component 

                          services/MineCraftItems.service.ts – logic and data 

                          styles/MinecraftItemPicker.styles.ts – styles for component 

                          types/Minecraft.types.ts – data models/interfaces 

                          Performance 

                          • The control cache external data in a dedicated service and reuse it across renders and dialog openings. 
                          • Images are lazy loaded reducing initial load time and avoiding UI blocking. 

                          Maintainability 

                          • The project follows a separation of responsibilities: PCF lifecycle (index.ts), UI components, services, styles, and domain types are isolated in dedicated folders. 
                          • External API access and business logic are encapsulated in a service layer, that allows to make future changes easier or replacements with a low risk. 
                          • The structure closely aligns with Microsoft PCF sample conventions, making the codebase easy to understand for new developers.