Solestyles Boutique’s Digital Transformation – Alternative Option – Power Pages
Solestyles Boutique’s Digital Transformation – Part 7 – Alternative Power Pages Option Following go-live and communication with a number of connections, I was asked about Power-Pages and what would Power Pages actually bring for a client like Solestyles Boutique. Whilst this has not been deployed to Solestyles boutique, I have permission to use the information discussed in the previous 6 posts as a factor in helping readers understand Power Pages in a more experienced (real world based) and more knowledgeable scenario. Thank you Solestyles Boutique. Introduction – Why Consider Power Pages? Following the deep dive into Solestyles Boutique’s licensing TCO in Post 6, a striking insight emerged: By shifting 2080 customer seats from Premium Per App licences (£9.20/seat/month) to a Power Pages portal, we could slash that line item by over 60 %. That equates to potential savings upwards of £10 000 per month, without compromising the core ordering experience. Note: Solestyles’ current solution wasn’t originally designed or developed for Power Pages. However, after reviewing the total cost of ownership, the management team are now evaluating Power Pages as a viable alternative for customer-facing ordering in the future. But what exactly is Power Pages, and why might it be the right fit for high-volume, customer-facing scenarios like Solestyles’ ordering portal? In this post I explore: What are Power Pages? Microsoft’s low-code web-portal platform built on Dataverse. How it differs from Canvas Apps and Model-Driven Apps in both capabilities and licensing. The key benefits it brings; scalable external authentication, built-in content delivery, responsive design and more. An alternative cost model; subscription and pay-as-you-go meters that align expenses with actual usage. Trade-offs to consider – offline support not available, UI customisation limits and portal throughput. For anyone looking to serve thousands of customers through a branded, data-driven website while keeping licence spend predictable; Power Pages is a compelling option. Let’s start by unpacking what Power Pages really is, and how it can power the next generation of Solestyles’ online storefronts. What Is Power Pages? Microsoft Power Pages is the evolution of Power Apps Portals; a secure, enterprise-grade, low-code SaaS platform for building data-driven websites on top of Dataverse. Released as a standalone product in 2023, Power Pages combines the familiarity of Power Platform with new tooling and capacity-based licensing tailored for external (anonymous or authenticated) users. The Five Design Studio Workspaces Power Pages’ browser-based Design Studio organises all portal development into five focused workspaces: PagesDrag-and-drop no-code components; text, images, lists, forms, Power BI reports and custom PCF controls; onto your web pages, using responsive templates that adapt to any device. StylingApply built-in themes or author bespoke CSS and JavaScript to match Solestyles’ brand identity, with live preview across breakpoints. DataManage your Microsoft Dataverse tables, columns, views and forms in-context defining which data drives each portal component, and enabling inline creation of new Dataverse schema. SetupConfigure site properties (URLs, languages, regional formats), environment variables, page templates and advanced site settings such as enabling custom domains or integrating external CMS services. SecurityDefine Microsoft Entra ID (formerly Azure AD) and Entra External ID authentication providers, assign web roles, configure table and row-level permissions, and enforce GDPR compliant privacy settings. Key Differentiators vs. Canvas and Model-Driven Apps Capability Canvas Apps Model-Driven Apps Power Pages Target users Internal staff/mobile Internal back-office External customers & partners UI approach Free-form drag-drop Form-and-view driven Page-and-section based, responsive Offline support Yes No No Authentication Microsoft Entra ID / B2C Microsoft Entra ID Microsoft Entra ID, External ID, local identity Licensing model Per-User / Per-App Per-User Capacity packs (authenticated/anonymous) Supported scenarios Task-oriented apps Complex processes High-volume, data-driven portals Why Power Pages for Solestyles’ Ordering Portal? 60 % licence savings by shifting 2080 customer seats to capacity packs instead of Per-App licences. Brand-first web UX with full control over HTML/CSS/JavaScript delivering a polished boutique feel. Scale to thousands of concurrent visitors via built-in CDN and caching, without per-seat overhead. Dataverse-native data integration: reuse existing product, order and customer tables, plus Power Automate flows, without additional glue code. In the next section, we’ll dive into the specific retail-focused features, catalogues, carts, checkouts and order history that you can build in Power Pages to rival any modern ecommerce site. Key Capabilities for a Retail Portal Power Pages delivers a suite of built-in features tailored for ecommerce and self-service scenarios. Here’s how Solestyles Boutique could leverage them: Catalog Browsing & Search List Components: Drag-and-drop galleries show products with configurable filters (category, size, colour). Entity Lists: Advanced search with server-side paging and sorting on Dataverse tables. Relevance Tuning: Use column-based weighting to surface bestsellers at the top. Add-to-Cart & Checkout Entity Forms: Custom forms capture cart items, quantities and options. Multi-Step Processes: Use Liquid templates and Power Automate for multi-stage checkouts (review, payment selection, confirmation). Embedded Payment Providers: Securely integrate Stripe or Adyen via JavaScript or Custom Connector calls. Order History & Self-Service Authenticated Lists: Show users their past and in-progress orders by filtering a Dataverse view by their contact record. Editable Forms: Allow address updates or cancellation requests via in-portal forms with server-side validation. Custom Branding & Responsive Design Themes: Configure corporate colours, fonts and logo in the Styling workspace. Liquid & CSS: Inject custom HTML/CSS snippets for bespoke layouts ensuring the portal matches the Solestyles boutique aesthetic on all devices. These capabilities mean customers enjoy a seamless, branded shopping experience while Solestyles reuses its existing Dataverse schema and automation flows without extra integration layers. Architecture & Data Integration A robust Power Pages solution sits on a clear, maintainable architecture that reuses Solestyles Boutique’s existing Dataverse backbone. In this section, I’ll map out the core components; portal metadata, business tables, entity permissions and explore how to embed Canvas experiences or PCF controls and integrate with external CMS or e-commerce services. Dataverse as the Single Source of Truth At the heart of Power Pages is Microsoft Dataverse, which stores both your portal configuration (webpages, content snippets, site settings and web role mappings) and your business data
Solestyles Boutique’s Digital Transformation – Part 6 – Power Platform in Action – Lessons Learned
Solestyles Boutique’s Digital Transformation – Part 6 – Power Platform in Action – Lessons Learned Introduction: Why a Series Wrap-Up? Solestyles Boutique’s journey across the Power Platform has been a story of transformation; from paper invoices and spreadsheets to a seamless blend of Canvas apps on the shop floor, Model-Driven portals for administrators, robust Power Automate flows and dynamic Power BI analytics. After five long and in-depth posts, it’s time to step back, reflect on what has been achieved and explore how these lessons apply to any business regardless of their size, location and complexity. This final post will: Recap the core value of each platform component and the problems they solved. Extract universal take-aways, guiding principles for low-code success. Walk through a real-world licensing example, using a 20-store Solestyles boutique example scenario to illustrate the latest Power Platform licence models and Dataverse storage considerations. Gaze into the future, with AI-driven innovations and Copilot for Power Platform that promise to reshape how we build and use low-code solutions. Whether you’ve followed every post in the series or are joining here for the first time, this wrap-up will help you connect the dots, avoid common pitfalls and chart a clear path forward; empowering your organisation to harness the full potential of the Power Platform. Let’s begin with a quick stroll through the series highlights. Series Recap: From Canvas to Analytics Over the last five posts, I have guided Solestyles Boutique from paper-bound chaos to a fully integrated, low-code platform powering every aspect of its business: Post 1: From Paper Trails to Platform PowerThe stage is set for replacing aging spreadsheets and invoices with a unified Dataverse backbone establishing the central repository for products, orders and customers, and defining the business drivers for a mobile-friendly, secure system. Post 2: Designing Solestyles’ Canvas AppNext,a tablet-optimised Canvas App is crafted for shop-floor staff: a simple gallery-to-detail-to-cart flow, fully offline-capable, with “Add to Cart,” checkout screens and a seamless “Pay Now” integration that syncs back to Dataverse. Post 3: Unlocking Power Apps Model-DrivenFor the back-office, a Model-Driven App is introduced: rich order and inventory forms, Custom Business Process Flows for approvals, embedded Power BI dashboards, and role-based security that gives assistants and managers just the data they need. Post 4: Mastering Power AutomateManual business process flows were then automated; payments, order creation, stock adjustments and special-order notifications with solution-aware flows. Error-handling scopes, retry patterns and scheduled low-stock reports ensured every process ran reliably while Teams alerts kept the buying team in the loop. Post 5: Power BI Analytics Deep DiveFinally, a star-schema model in Power BI was built, authored DAX measures like Total Sales and Stock Turnover, designed interactive dashboards aligned to the Solestyles brand, and implemented refresh strategies from incremental to near real-time so managers always see the freshest insights. Together, these posts form an end-to-end blueprint: a single “Solestyles Boutique” solution where Canvas Apps, Model-Driven Apps, Automation and Analytics work together. Universal Takeaways for Any Business While Solestyles Boutique’s story is unique, the principles that powered its transformation apply to organisations of every size and sector. Here are the five pillars to guide your own Power Platform journey: 1. Embrace a Single-Solution Mindset Whether you’re building a Canvas App for frontline staff, a Model-Driven portal for managers, or flows and reports to automate and analyse your data, house everything in one solution container. This approach streamlines ALM, keeps versioning consistent and makes it trivial to migrate from Dev to Test to Production without breaking connections or losing environment-specific settings. 2. Design with the User at the Centre Never underestimate the power of user-centred design. Conduct discovery workshops to map out every persona’s daily tasks: Shop assistants need offline galleries and quick-add cart functionality Store managers want clear dashboards and approvals in one place Executives require high-level trends at a glance. Prioritise intuitive navigation, responsive layouts and just-in-time guidance (like Business Process Flows and in-app help) to maximise adoption and minimise training overhead. 3. Treat Data as Your North Star Centralise all product, order and customer information in Dataverse and resist the urge to scatter data in spreadsheets or ad-hoc lists. A clean, well-modelled data layer (with lookups, calculated and roll-up columns) underpins every Canvas App screen, flow logic and Power BI report. By enforcing referential integrity and reusing environment variables and connection references, you ensure that every component reads from and writes to a single source of truth. 4. Build Resilience & Observability Real-world systems need to tolerate failures; offline-first caching for poor connectivity, run-after and retry patterns for transient API errors, logging failures into Dataverse or Application Insights for post-mortem analysis, and scheduled health checks that alert you before small issues become business-critical outages. Adopt these patterns early to maintain continuous operations and build stakeholder trust. 5. Embed Governance from Day One It’s easy to start small and spiral into shadow solutions. From the very first commit, define Data Loss Prevention policies, enforce security roles and field-level permissions, establish naming conventions and version controls, and leverage the CoE Starter Kit to monitor maker activity and policy compliance. A lightweight governance layer preserves agility while ensuring your platform scales securely. By internalising these universal take-aways; single-solution ALM, user-centric design, data-first architecture, resilient operations, and proactive governance; you’ll be well equipped to replicate Solestyles’ success in your own organisation. Licensing & Storage: A Solestyles Boutique (Potential Future) Case Study All prices are accurate up to and including 2 July 2025 and exclude VAT. Costs are based on an annual purchase rate, but divided into a monthly price record. These estimates adhere to Microsoft’s latest published list prices and recommended best practices balancing full functionality with cost efficiency. High-Level Summary Over the last few years, Solestyles Boutique has has grown from a single shop on a West Yorkshire high street to a multi-channel retailer juggling in-store sales, weekend pop-ups and an online storefront to a business that now has 20 stores
Solestyles Boutique Digital Transformation – Part 5 – Power BI Analytics Deep Dive
Solestyles Boutique’s Digital Transformation – Part 5 – Power BI Analytics Deep Dive In today’s data-driven retail landscape, rapid access to clear, actionable insights is just as critical as a flawless customer experience on the shop floor. While Solestyles Boutique’s Canvas App empowers front-line staff and the Model-Driven App guides back-office workflows, neither can surface high-level trends or forecast demand on its own. Enter Power BI: Microsoft’s flagship analytics platform that transforms raw data into rich, interactive dashboards. Solestyles Boutique has grown from a single shop on West Yorkshire high street to a multi-channel retailer juggling in-store sales, weekend pop-ups and an online storefront. Yet when management needed to answer simple questions: “Which collection is underperforming this week?” or “How many black loafers remain in Stock?” they found themselves cobbling together Excel exports and lists, with data often days out of date. Decisions made on stale figures carried real risks: Stockouts Missed promotions, and Overstretched cash flow To close this gap, Power BI was introduced as the central analytics layer feeding the low-code power platform. Why Power BI for Solestyles? Because: Seamless Dataverse Integration – The Canvas and Model-Driven apps already write every sale, stock adjustment and customer interaction into Dataverse. Power BI connects natively via DirectQuery for live views or import mode with incremental refresh for a single source of truth. Tailored Refresh Measurement – Whether triggering hourly imports in Premium capacity or employing DirectQuery for near real-time stock levels, refresh schedules were configured that match Solestyles’ operational tempo – no more end-of-day surprises. Rich, Interactive Visuals – Beyond static tables, intuitive dashboards were crafted to empower managers to spot issues before they escalate: Daily sales trends, Stock-turn rates, Heat maps of customer locations, and What-if analysis for upcoming launches Embedded and Accessible – Dashboards live not only in the Power BI service but are embedded directly into the Model-Driven Admin portal and surfaced in the Canvas App. Anywhere a decision is made, the latest metrics are just a tap away. These innovations together with seamless direct connectivity to Dataverse and support for both import-mode and DirectQuery, mean that store managers, procurement leads and the executive team can all explore sales velocity, stock-turn rates and seasonal trends in real time. In this post, I’ll dive into how Solestyles configures, models and visualises its data in Power BI, ensuring every decision is backed by the freshest possible insights. I’ll take you step by step through the: Connection of Power BI to Solestyles’ data, Modelling a star schema tailored for retail analytics, Writing DAX measures that capture key performance indicators, and Designing dashboards that keep the business agile. By the end of this post, you’ll have a blueprint for turning raw Dataverse records into strategic insights ensuring your own personal decisions are guided by the Soulstyles experience and example information. Connecting to Your Data Sources Before building your Power BI visuals, you must establish dependable, performant connections to your operational data primarily housed in Dataverse (recommended), with supplementary sources for Canvas App collections. I’ll explore the two main Dataverse methods (Connector vs OData), strategies for pulling in Canvas App data, and how to blend multiple sources with Power Query. Dataverse Connector vs. OData Feed Power BI Desktop offers two first-party options for Dataverse: Power BI Dataverse Connector Uses the Tabular Data Stream (TDS) protocol for both Import and DirectQuery modes. Recommended for most scenarios because it supports server-side filtering, relationships and choice columns natively. Prerequisite: The Dataverse TDS endpoint must be enabled in your environment (admin setting in the Power Platform Admin Center). OData Feed (Common Data Service Legacy) Exposes an OData v4 endpoint to query tables via HTTP GET requests. Best suited for small, read-only extracts or when leveraging dataflows to migrate between environments. Lacks full support for choice columns and can incur pagination-related performance issues on large tables. Recommended approach: Use the Dataverse Connector in Import mode for datasets under 100 MB, switching to DirectQuery for real-time needs (e.g., live stock levels). Reserve OData for lightweight dataflows or niche migration tasks. Importing Canvas App Collections Your Canvas App caches critical lookup tables; example – categories, suppliers and static lists; in local collections. To mirror these in Power BI: Expose Collections via SharePoint or Azure Data Lake If a Canvas App saves collections to SharePoint lists, connect via SharePoint Online List in Power BI: Source = SharePoint.Tables(“https://yourtenant.sharepoint.com/sites/solestyles”, [Implementation=”2.0″]) Alternatively, use Power Automate to write collections to an Azure Data Lake Gen2 CSV or Parquet file (large data storage option); then ingest with the Azure Data Lake Storage connector. Refresh Coordination Schedule your Power Automate flow that exports collections immediately before your Power BI dataset refresh to ensure lookup tables stay in sync with Dataverse. Combining Multiple Sources with Power Query Once connected, blend Dataverse tables and Canvas App collections in Power Query: Merge Queries In Power Query Editor, use Merge Queries to join fact tables (e.g., Orders) with dimension tables (Products, Contacts, colCategories). Query Folding For DirectQuery and the Dataverse Connector, ensure transformations (filters, column selections) fold back to the source to minimise client-side processing. Check each step’s View Native Query to confirm folding. Data Type & Privacy Settings Explicitly set column Data Types (Date, Decimal, Text) in the first transformation step to avoid errors. Configure Privacy Levels per source (Organizational for Dataverse, Public for Azure Data Lake) in File → Options → Privacy to prevent unnecessary data isolation throws. Security and Governance Considerations Row-Level Security (RLS) Define RLS roles in Power BI Desktop to restrict users to their allowed data slices (e.g., managers see all regions, store staff only their own). Credential Management In the Power BI Service, store credentials in the dataset’s Data source credentials pane choosing OAuth2 for the Dataverse connector so that each user’s security roles apply at query time. Gateway Requirements For on-premises Data Lake or SharePoint data, ensure the On-Premises Data Gateway is configured in
Solestyles Boutique Digital Transformation – Part 4 – Mastering Power Automate
Solestyles Boutique’s Digital Transformation – Part 4 – Mastering Power Automate Introduction: Why Power Automate? Automation is the invisible engine that propels modern digital experiences. For Solestyles Boutique, the Canvas App and Model-Driven App have laid the groundwork; a mobile-first interface for staff on the shop floor and a structured, process-driven portal for administrators. Yet behind every tap on a “Pay Now” button or click of “Process Order,” there must be a reliable, secure mechanism to process payments, update stock levels, send notifications and orchestrate business logic. That mechanism is Power Automate. Power Automate sits at the heart of the end-to-end solution, seamlessly connecting user-facing experiences to back-office processes and external systems. It transforms manual, error-prone tasks into resilient flows that can retry on failure, log every step for auditing and adapt to changing business requirements without a single line of custom code. Whether it’s validating a customer’s payment, notifying the buying team of special orders via Microsoft Teams or sending a daily low-stock report to the procurement lead, Power Automate makes each step repeatable, observable and governed. In this post, you will learn not only how to create individual flows, but how to build them solution-aware, ensuring they travel with the rest of your components from Development to Test to Production. I’ll explore error-handling patterns that prevent failures from going unnoticed, demonstrate key flow design patterns for payment orchestration and scheduled reports, and preview advanced techniques like Adaptive Card approvals and custom connectors that enable Solestyles Boutique to adapt quickly to new opportunities. By the end of this post, you’ll appreciate how Power Automate is more than just a background service: it’s the vital link that binds together UI, data and business outcomes across the Power Platform. Let us begin by setting up the solution-aware flows and configuring the environment variables that underpin them. Setting Up Solution-Aware Flows Before you author a single step in Power Automate, it’s essential to anchor your automations inside the same Solestyles Boutique solution you created for Canvas and Model-Driven Apps. This guarantees that your flows, connectors and configuration travel together through Development, Test and Production, preserving environment-specific settings and security boundaries. Establishing Your Flow in the Solution Open Power Apps Maker – Browse to https://make.powerapps.com → Solutions → Solestyles Boutique. Create a New Cloud Flow – Click New → Cloud flow → Automated cloud flow (or “Instant” if you prefer a button-trigger). Name and Trigger – Name: e.g. OrderProcessingFlow Trigger: choose When an HTTP request is received (for Canvas-driven payment) or When a record is created (Dataverse) Save – Your blank flow now lives in the solution, not in your personal environment, ready to inherit shared variables and connections. By authoring directly within the solution, the flow’s GUID, permissions and dependencies move seamlessly whenever you export or upgrade the solution package. Defining and Consuming Environment Variables Rather than hard-code endpoints or keys, store them in solution-scoped variables: Add Environment Variables – In Solestyles Boutique solution, click New → Environment variable three times to create: PaymentGatewayURL (URL) PaymentGatewayKey (Secret) NotificationEmail (Text) Reference in Your Flow – Inside your flow, any action that needs the gateway URL or key can now select Environment variable from dynamic content ensuring the same configuration is used in Dev/Test/Prod, with only the variable values differing per environment. Creating and Binding Connection References Each connector action in Power Automate should use a connection reference defined at the solution level: Add Connection References – Click New → Connection reference and add: Dataverse (for record creation/updates) Office 365 Outlook (for customer emails) HTTP with Entra ID (for secure calls to third-party APIs) Bind Actions to References – When you insert a Dataverse “Create a record” step, ensure the Connection dropdown shows CR_Dataverse rather than a personal connection. This makes the flow fully portable. Managing Flow Permissions & Service Accounts Automations often need elevated rights without relying on a single user: Use Service Principals or Managed Identities – For HTTP or custom connectors, configure an Entra ID app registration and assign it a role (e.g., Dataverse service principal). Grant Flow Owners – In the flow’s … → Manage permissions, add your integration account or a dedicated “Solestyles Automation” service account with Co-owner rights so the flow runs under a predictable, monitored identity. Enforce Principle of Least Privilege – Only grant each service principal the minimum table privileges (e.g., Create on Orders, Update on Products) needed for the flow to succeed. Why This Matters By embedding your flows within the solution, referencing variables and connection references, and using service-level identities, you achieve: Portability: Flows work identically across environments with no manual re-configuration. Security: Credentials are never exposed in plain text and run under dedicated service identities. Governance: All automation logic resides under the same ALM pipeline as apps and data models. With your flows now solution-aware, let’s move on to the patterns that make them resilient; error handling, scopes and retries. Error Handling & Scope Patterns In any robust automation solution, you must assume that: External services can fail Data may be malformed, and Network interruptions can occur. Error handling and Scope actions in Power Automate provide the mechanisms to catch, manage and recover from these issues ensuring your flows remain resilient and transparent. Below, I explore essential patterns for grouping logic, configuring retries and creating fallback paths. Grouping Logic with Scope Actions A Scope action acts as a container for a series of steps, enabling you to treat them as one logical unit: Insert a Scope Within your flow, select New Step → Control → Scope, and name it Main Scope. Populate the Scope Add actions such as HTTP: Call Payment Gateway and Parse JSON inside this scope. Benefits Scope results appear as a single block in run history for clarity. You can apply run-after conditions on the entire scope rather than individual actions. Configuring run-after for Retries and Fallbacks Every action within Power Automate supports a run-after setting, allowing
Solestyles Boutique Digital Transformation – Part 3 – Unlocking Model-Driven Apps
Solestyles Boutique’s Digital Transformation – Part 3 – Unlocking Model-Driven Apps Introduction: Why a Model-Driven App? Although the Canvas App empowered shop-floor staff to browse inventory, capture orders and assist customers at pop-up events, managers and administrators needed a complementary solution offering structured forms, guided processes and embedded analytics. The Model-Driven App delivers exactly that: “a declarative, metadata-driven experience built on Microsoft Dataverse that emphasises robust data modelling, rich user interfaces and process automation all achieved with minimal custom code.” By adopting a Model-Driven approach, Solestyles Boutique maintains complex relationships across Products, Orders, Customers, SpecialRequests and InventoryAdjustments tables, ensuring referential integrity and automatically deriving roll-up metrics. Business Process Flows shepherd critical workflows whether approving supplier markdowns or onboarding new partners through multi-step, conditional stage-gates that enforce business rules at each juncture. Role-based security configurations grant managers visibility over every order while assistants only see their own, thanks to table permissions and field-level security. At the same time, embedded dashboards surface essential KPIs, stock-turn rates, average order values and seasonal trends directly within the app, removing the need to switch to a separate BI portal. In this post, I’ll guide you through building the Solestyles Model-Driven App from the ground up; defining tables and relationships in Dataverse, crafting custom forms and views, implementing business logic with rules and flows, and embedding rich dashboards that bring your data to life. Whether you’re an IT professional transitioning from spreadsheets or a business user looking to tame complexity with low-code tools, you’ll see how Model-Driven Apps can become the administrative backbone of your organisation. Let’s get started. Setting Up Your Solution & Model-Driven App Rather than splinter multiple solutions across your environment, the optimal approach is to keep both your Canvas and Model-Driven apps in a single solution container – Solestyles Boutique (created in part 2). This single repository ensures consistent Application Lifecycle Management (ALM) practices, simplifies environment migrations and centralises governance. Locate or Create the Solution Container Open the Power Apps Maker Portal – Head to https://make.powerapps.com and sign in. Check for “Solestyles Boutique” – In the left-hand pane, click Solutions. If Solestyles Boutique appears, select it and proceed to 2.2. If not, click New solution and enter: Display Name: Solestyles Boutique Name: solestyles_boutique Publisher: Solestyles Publisher Version: 1.0.0.0 Click Save to create the container. Having a single solution container means that every component; Canvas App, Model-Driven App, Power Automate flows, and even Power Pages; travels together through development, test and production. Add Your Model-Driven App Open “Solestyles Boutique” Solution – In the Solutions list, click on it. New Model-driven app – From the command bar, select New → App → Model-driven app. Configure Basic Settings Display Name: Solestyles Admin Portal Name: solestyles_admin_portal Keep default client options (responsive across devices). Select Create – Power Apps launches the App Designer, ready for navigation setup. Because the app resides inside our main solution, it automatically inherits environment variables, connection references and versioning settings that were defined earlier for the Canvas App. Design the Sitemap The sitemap defines the user navigation in your Model-Driven App: In App Designer, choose Sitemap. Add Areas: Sales (icon: 🛒) Inventory (icon: 📦) Customers (icon: 👥) Under each Area, add Groups and Sub-Areas pointing to tables: Sales → Orders, OrderLines Inventory → Products, StockAdjustments Customers → Contacts Save and Publish the sitemap to make navigation live. Reuse Environment Variables & Connection References Since you already added these when setting up the Canvas App, simply confirm: Environment Variables DataverseURL SharePointSite PaymentGatewayKey Connection References CR_Dataverse CR_SP CR_Payment No need for new variables or references unless introducing new integrations like Teams webhooks or custom connectors. Best Practices One Solution, Many Apps – Bundle Canvas, Model-Driven, flows and pages in Solestyles Boutique. Consistent Naming – Use prefixes (app_, site_, flow_, env_) for clarity. Document in Solution – Leverage description fields on each component to explain purpose. Version Control – Increment solution version on each publish and commit the exported ZIP to your repo. By centralising your components in one solution and reusing configuration artefacts, you streamline ALM, reduce duplication and position Solestyles Boutique for rapid future enhancements. Dataverse Entity Modelling A solid data model is the foundation of every Model-Driven App, and for Solestyles Boutique I crafted an extensible schema in Microsoft Dataverse that accurately maps products, orders and customer entities along with their interdependencies. By defining dedicated tables for each core object, establishing lookup fields to enforce referential integrity, and implementing advanced Choice, Calculated and Roll-Up columns, I created a single source of truth that automatically derives and summarises vital business metrics. This design not only streamlines data capture and consistency but also delivers real-time insight into sales performance, order status and customer activity without the need for additional workflows. Core Tables Overview Beginning by reviewing the five primary tables: Products – Catalogue of footwear and accessories, with fields for Name, SKU, Category, UnitPrice and InStock. Orders – Header records capturing OrderNumber, Customer (lookup to Contacts), OrderDate, DeliveryMethod and Status (choice column). OrderLines – A child table linked to Orders, detailing each line item with Product (lookup), Quantity and LineTotal (calculated). Contacts: Customer records, storing FirstName, LastName, Email, Phone and Address. InventoryAdjustments – Logs manual stock changes, with fields for Product (lookup), AdjustmentType (choice) and QuantityDelta. Configuring Lookups & Relationships To maintain referential integrity across our Dataverse tables I defined precise lookups and leveraged the platform’s built-in relationship management. In the Orders table, I added a lookup field called Customer (schema name crb_Customer) that points to the Contacts table. This ensures every order is explicitly tied to a contact record, making it trivial to fetch customer details without manual joins. Moving to the OrderLines table, I created two additional lookup fields: one linking each line item back to its parent Order, and another referencing the Product it represents. As soon as these lookups are in place, Dataverse automatically provisions the corresponding N:1 and 1:N relationships. You can confirm these associations under each table’s Relationships tab where you’ll
Solestyles Boutique Digital Transformation – Part 2 – Designing Solestyles Canvas App: A Mobile-First Experience
Solestyles Boutique Digital Transformation – Part 2 – Designing Solestyles Canvas App: A Mobile-First Experience Introduction When you step onto the shop floor at Solestyles Boutique, the first thing you notice is the ease with which our team can now check stock, launch special orders and capture customer requests, all from the same tablet they once used to scan barcodes in fringe-signal car parks. This transformation stems from one pivotal component of the Power Platform solution; the Canvas App. In this second part of the Solestyles blog series, I’ll explore how I crafted a truly mobile-first experience, optimised for speed, simplicity and real-world unpredictability. In the previous post, you saw how tedious paper invoices and chaotic spreadsheets hampered everyday operations and drove our small West Yorkshire boutique to seek a unified, low-code backbone. Now it’s time to talk about the frontline interface. Why choose a Canvas App over other options? What design decisions would allow our shop assistants juggling deliveries, pop-ups and in store customers to navigate thousands of SKUs without a single spin of the wheel? Over the next few sections, I’ll trace the Canvas App’s evolution from its first rough wireframes through to a polished, delegable search screen. You’ll learn how I linked directly to Dataverse and SharePoint Online, organised data into collections for lightning-fast lookups, and engineered the navigation so that any required screen lies just one tap away. Along the way, I’ll share the formulas and patterns (anonymised); like multi-field delegable filtering and offline sync queues that turned a simple gallery into a robust, resilient tool, capable of handling everything from a rogue power cut to a deluge of weekend footfall. Whether you’re already designing your own Canvas App or simply curious about how low-code can revolutionise the customer facing edge of your business, this journey through Solestyles tablet interface should spark ideas and give you practical technical ideas to borrow. So grab your iPad, find a quiet corner of your boutique and let’s dive into the next section, where I’ll set up those crucial data connections and lay the foundations for every screen to come. Setting Up Your Solution & App Before a single control goes on canvas, it’s vital to establish a robust, solution aware foundation. By creating a proper solution and app record and by embedding environment variables and connection references; this ensures that your Canvas App is portable across environments, secure by design and easy to maintain. Creating the Solution Open Power Apps Maker Portal – Go to https://make.powerapps.com and sign in. Navigate to Solutions – In the left-hand navigation pane, click Solutions. New Solution – At the top of the Solutions list, click the New solution button. Define Solution Properties: Display Name: Solestyles Boutique Name: solestyles_boutique Publisher: {{YourPublisherPrefix}} – You can create a new one if one does not exist – don’t ever use the default publisher! Version: 1.0.0.0 Save – This creates an empty solution container for all your components, apps, flows, variables and more. By packaging everything in one solution, deployments become a matter of exporting and importing a single ZIP file, rather than reconnecting each component manually. Adding the Canvas App Record Select Your Solution – From the Solutions list, click the row for Solestyles Boutique to open its overview. Create a New Canvas App – In the command bar under the solution name, click New > App > Canvas app. Configure the App – Name: Solestyles Boutique App Format: Tablet (16:9) Create – Power Apps Studio launches in a new tab with your solution-bound Canvas App. Because the app is created inside the solution, all subsequent links to environment variables and connection references remain intact across environments. Defining Environment Variables & Connection References Rather than embed connection details in individual screens, store them centrally: Environment Variables – In your solution, click New > Environment variable three times to create: DataverseURL (Text): URL of your Dataverse instance SharePointSite (URL): URL of the SharePoint site for legacy lists PaymentGatewayKey (Secret): API key for your payment connector Connection References – Click New > Connection reference and select: Dataverse – bind to DataverseURL SharePoint – bind to SharePointSite HTTP with Entra ID – bind to PaymentGatewayKey Rename them for clarity (e.g. CR_Dataverse, CR_SP, CR_Payment). These references allow your Canvas App to add data sources without hard-coding credentials, streamlining both development and deployments. Best Practices for Solution-Aware Canvas Apps Consistent Naming – Prefix solution components (app_SolestylesCanvas, env_DataverseURL). Avoid Ad-Hoc Connections – Always use your predefined connection references in Power Apps Studio. Document in the Solution – Use the solution’s Description fields to explain each environment variable and reference. Version Control – Increment the solution version with each release and store exported solution files in your source control system. By investing time upfront to structure your solution and by embedding key settings in environment variables and connection references, you set the stage for a stable, secure and scalable Canvas App that can grow with Solestyles Boutique. Connecting to Dataverse & SharePoint The cornerstone of the Canvas App is its seamless access to Solestyles core data: product catalogues, order histories, and customer records; housed in Dataverse, alongside legacy inventory logs stored in SharePoint. Rather than hard-code connection details into each screen, I embraced solution-aware connections and environment variables to ensure consistency across development, test and production environments. At the heart of this approach lies the Data pane in Power Apps Studio. Within the Solestyles solution, I first created two environment variables: DataverseURL pointing to the boutique’s Dataverse instance SharePointSite referencing the SharePoint Online site hosting the legacy lists These variables live in the Solution but outside of the Canvas App, allowing us to migrate the entire solution package without manual reconnects. In the Canvas App’s Data pane, I then added two Connection references, each bound to its respective environment variable. Once configured, the app draws on these references for every data operation, greatly reducing drift between environments and ensuring consistent security settings. Organising
Solestyles Boutique Digital Transformation – Part 1 – From Paper Trails to Power Platform
Solestyles Boutique’s Digital Transformation – Part 1 – From Paper Trails to Power Platform Introduction Note!! Names and Details have been anonymised to ensure security is maintained. When Solestyles Boutique – a family-run fashion retailer tucked away in the heart of West Yorkshire – reached out to me during a career break, their back-office processes were creaking under the weight of growth. What began as a cosy High Street shoe shop had expanded into weekend pop-ups and a modest online store, yet inventory remained tracked on paper printouts, stock levels were updated in confusing Excel files, and customer orders arrived via phone calls, emails and handwritten order forms at weekend pop-ups. The result? Delays, errors and frustrated staff. In early 2024, I embarked on a mission to replace this aging process that used manual systems with a single, unified low-code platform built on Microsoft Power Platform. Over the course of several months (in my own time and at no cost), I learned, developed, designed and delivered an end-to-end solution that would empower shop-floor assistants, give managers administrative depth, automate routine communications and surface the insights Solestyles needed to plan for the seasons ahead. In part 1 (this post) of the journey, I’ll share the rich business context, the detailed requirements that were unearthed, and the technical hurdles that were overcome to lay a rock-solid foundation for the boutique’s digital future – all anonymised to protect the company. Understanding Solestyles World Solestyles Boutique trades on personalised service and exclusivity. Their shelves brim with limited-edition trainers, artisan-crafted heels and independent-designer handbags. Customers appreciate the one-to-one styling advice and the ability to pre-order upcoming drops, but the internal processes struggled to keep pace. Every morning, the shop manager would rifle through a jumble of paper invoices and Excel sheets to confirm stock levels before opening the doors. If an item sold out at lunchtime, the assistant on duty had no quick way to tell a customer when a new delivery would arrive. Meanwhile, head office wrestled with sales figures scattered across multiple files, making it almost impossible to forecast demand accurately particularly during peak weekends and seasonal promotions. Solestyles owner (a good friend) knew that, without a robust digital backbone, the business risked inventory mishaps, lost sales and overworked staff. The brief was clear: “Replace the tangle of spreadsheets and paper forms with a modern, mobile-friendly system that would unify data, simplify everyday tasks and deliver real-time insights all while keeping costs sensible for a small Yorkshire business.” Translating Needs into Requirements Our discovery workshops with Solestyles team surfaced five interwoven needs. First, all product and order data had to reside in a single, secure repository. Second, shop assistants needed a tablet-optimised interface they could use on the shop floor or at off-site events. Third, managers required a powerful back-office console to oversee inventory, authorise special orders and manage customer records. Fourth, customers deserved timely updates, order confirmations, “ready for collection” alerts, and delivery notices without manual email writing or management. Finally, the owner and directors wanted visual dashboards that distilled sales trends, stock-turn rates and seasonal peaks into clear, actionable graphs. Beyond these functional aims lay a series of non-functional imperatives: Data security was paramount: Solestyles handles customer addresses and payment references, so role-based permissions would ensure that only the right eyes see sensitive records. Performance also mattered: any screen in the shop-floor app had to load in under two seconds on a standard 4G connection and, recognising the boutique’s modest IT budget, the solution had to be maintainable by in-house staff after delivery. Clear naming conventions, solution-aware documentation and a minimal reliance on pro-developer code. Technical Challenges and Creative Solutions Converging those requirements into a single Power Platform solution brought its own set of challenges. As a project team and after discussions and comparisons, the team chose Dataverse as our central database, but modelling the relationships between products, orders and customers demanded careful design. I created lookup tables and roll-up fields to calculate metrics such as “Days to Ship” and “Average Basket Value” dynamically, ensuring referential integrity without duplicating data. On the shop-floor side, an optimised Canvas App was developed for iPad use. A deceptively simple product-search screen hid complex delegation logic: by favouring delegable functions like “StartsWith” and indexing critical columns, I sidestepped the 500-record filter limit and consistently delivered sub-two-second load times. Offline capabilities meant that during a power cut or in a fringe-signal car park, staff could still scan stock and queue their updates for automatic sync as soon as connectivity returned. For the management console, a Model-Driven App gave Solestyles senior management team rich, responsive forms and guided process flows; whether approving a markdown, adding a new supplier or reassigning a stock batch. The design layered in business rules to enforce stock thresholds, and embedded the first Power BI dashboard directly into the app, so key performance indicators (KPIs) and trend lines appeared the moment a manager logged in. Automating customer communications and internal alerts fell to Power Automate. I designed resilient flows, complete with scopes and retry scopes, to send order confirmations, dispatch notifications and low-stock warnings. If the email service ever stopped, the fallback branches would trigger a retry rather than drop the notification into a void. Finally, the Power BI model blended real-time DirectQuery connections to Dataverse with imported historical snapshots. This hybrid approach let Solestyles owners pore over day-by-day sales during flash promotions, while still benefiting from speedy, aggregated reports for longer-term planning. Incremental refresh policies were applied to shave hours off overnight data loads, and carefully sculpted measures; Total Sales, Sell-Through Rate, Average Hold Time; that directly aligned with the boutique’s KPIs. Laying the Groundwork for Growth By the time I hand over the first developed and (almost) polished solution, Solestyles Boutique will have transformed from a paper-based operation into a sleek, low-code powerhouse. Shop assistants now handle stock checks and special orders in moments;