Introduction

The era of open-ended AI ideation is ending. What’s replacing it is disciplined product work. Sessions are no longer judged by how inspiring they sound, but by what they actually enable. Teams aren’t tired of AI. They’re tired of pilots that never ship, noise without signal, and dashboards that can’t prove value.

Brainstorming still matters. But after an expensive huddle, the question that lingers is simple. What did we build that someone can actually use?

You hear it a lot lately. SaaS is dead. ERP is dead. That’s overstated. Deals are still being signed. Platforms are still being bought. What’s really dying is patience. Organizations are reacting to years of bold promises followed by uneven delivery. Capabilities sold as transformative end up incremental. Timelines stretch. Value becomes harder to explain.

Disappointment comes first. Then fatigue. Then frustration. Eventually it shows up where it always does. Tighter budgets. Slower buying cycles. Less trust in the partners brought in to help. Not because the models don’t work, but because the outcomes haven’t matched the rhetoric.

That tension is reshaping how leaders think about AI and transformation. Ideas alone aren’t enough anymore. Activity isn’t progress. What matters is whether the work leads to something shippable, measurable, and owned. If it doesn’t, it blends into the growing pile of initiatives that sounded promising and changed very little.

That shift in expectation is the real story.

Fear of Being Left Behind

A major driver behind many of these costly sessions is fear. Fear of being left behind. AI is everywhere and it’s moving fast. Organizations don’t have to wonder if their competitors, suppliers, or customers are investing in it. They are. That creates pressure to act. Invest now. Build now. Ship something now. And that pressure isn’t imagined. It’s justified.

The problem is what happens next.

Too many teams stop at awareness. We know the market expects AI. We know our competitors are using it. So motion becomes the goal. More tools. More pilots. More demos. Less clarity. The focus turns outward when it should be turning inward.

The harder questions get skipped. Is AI creating business value? Are operations actually better, or just different? Are employees more effective, or simply surrounded by tools they didn’t ask for? When those answers are unclear, the issue isn’t speed. It’s intent.

Knowing others are “doing AI” doesn’t make an organization stronger. Improvement does. That requires stepping back from the noise and being honest about what’s working, what isn’t, and why. AI has to earn its place like any other serious capability. Through outcomes, not excitement.

This is where many strategies start to wobble.

Educate

I recently participated in a hackathon, and the problem showed up almost immediately. The group didn’t have a baseline. Not on the tools. Not on the environments. Not on how anything connected. We could have pushed through and checked the box. That would have been easy. It also would have been meaningless.

The issue wasn’t effort or intelligence. It was context. Basic concepts like environments and connectors became blockers, not because they were complex, but because they were unfamiliar. That raised an uncomfortable question. Who owns that gap? The organization? The facilitator? Me? The goal was to move fast and show what the tools could do. Without shared understanding, speed just amplified confusion.

What helped wasn’t more features. It was grounding. A short deck. High-level. No hype. What each tool does. Where it fits. How the pieces connect. That alone changed the room. Once everyone had a shared mental model, we could build. No-code and low-code tools did the rest. The work improved. The conversation shifted.

That’s when the real lesson landed.

We didn’t need better tools. We needed more time to educate before execution. AI is still intimidating for a lot of people. The anxiety is real, especially for those who fear displacement. That fear doesn’t come from the technology itself. It comes from not understanding how humans stay in the loop and where judgment still matters.

Education isn’t optional. It’s the prerequisite. Organizations either invest in it deliberately or pay for it later through rework, confusion, and missed value. Tools don’t fail on their own. They fail when people are asked to use them without context.

Move with Intent

Once education is in place, the next step is execution. Not rushed execution. Intentional execution.

A colleague shared something that stuck with me. The best hacks start with use cases people already recognize. Real work. Familiar pain. Problems the room doesn’t need explained. When everyone can rally around the same use case, momentum follows. When they can’t, even strong builds struggle to land.

For this hack, I came in top-heavy. Too much solution. Not enough grounding. Combined with the earlier education gap, it could have gone sideways fast. We started with the tech when we should have started with the work.

If you want value from a hackathon, poll the group first. Ask simple questions. What task eats up your time every week? What work do you dread because it’s manual? What would make your day easier if it disappeared? Those answers matter more than any roadmap or demo.

What came out of this hack wasn’t flashy. It didn’t need to be. We used a SharePoint list, built a Copilot Studio agent, and added two flows to review vendor documents for compliance. Work that was previously manual became automated. No tab switching. No new windows. The value was immediate because it showed up where the work already happens.

That’s the difference intent makes. If we had identified that use case upfront, we could have scoped tighter and built cleaner. What took eight hours might have been much closer to production-ready. Not because we worked harder, but because we worked on the right thing from the start.

Don’t Take My Word for It

Collaboration between consultants and organizations matters more than most people admit. Real collaboration means challenge. You’re writing the check. We need you for references and repeat work. The incentives are aligned. So push us.

If an explanation doesn’t make sense, say so. If the value isn’t clear, ask why. That tension is healthy. It leads to better thinking, better designs, and better outcomes. It keeps everyone honest.

This work is expensive. AI credits cost money. Implementations cost money. Time costs money. And something will get implemented whether you’re in the loop or not. Staying silent doesn’t reduce risk. It just shifts it.

A lot of fatigue doesn’t come from bad intent. It comes from disengagement. Being too hands-off. Not asking why a solution is framed a certain way. Sometimes the answer isn’t an agent. It’s an automation. Sometimes that automation just needs a prompt. Other times it needs semantic search, OCR, or better data upstream.

The effort might be small. It might be significant. It might stretch the budget. That’s part of the work. What causes problems is assuming the first idea is the right one and letting it move forward unchecked.

The road to poor implementations is paved with good intentions. The antidote is simple. Stay involved. Ask questions. Challenge assumptions. That’s how AI stops being noise and starts delivering value.

Conclusion

AI isn’t failing organizations. Undisciplined execution is.

The shift happening right now isn’t about tools, platforms, or models. It’s about expectations. Leaders are no longer impressed by ambition alone. They want evidence. They want things that work. They want outcomes they can point to and defend. That’s not resistance to AI. That’s maturity.

Fear will keep driving investment. That won’t change. Education will keep determining whether those investments pay off. That shouldn’t be optional. And execution, when it’s grounded in real use cases and challenged at every step, is what separates progress from noise.

Hackathons, pilots, and workshops can still be powerful. But only when they’re anchored in shared understanding, familiar work, and clear intent. Otherwise, they become expensive rehearsals for things that never ship.

The same goes for partnerships. Consultants don’t need blind trust. They need engaged counterparts who ask hard questions, demand clarity, and stay involved. That pressure doesn’t slow things down. It prevents waste. It makes the work better.

AI will continue to move fast. Budgets will continue to tighten. Patience will continue to thin. The organizations that succeed won’t be the ones doing the most. They’ll be the ones doing the right things, in the right order, for the right reasons.

Educate first. Execute with intent. Stay involved. Challenge everything that doesn’t clearly deliver value.

That’s how AI stops being a distraction and starts becoming a capability.

For years I built automations wrong. It wasn’t that I didn’t know the technology. I was asking the wrong questions. A mentor taught me something that changed how I work: focus on the outcome. Transparent moment here — there were times I didn’t serve my customers as well as I could have because my thinking was too tactical, too event-driven, and not anchored to the goal.

Most automation workflows follow the same pattern: a trigger fires, actions run, decisions branch, and then the workflow stops until it fires again. Those steps matter. But when you step back and ask what all of those steps are actually trying to accomplish, you land on a more important question. What is your goal?

I meet clients constantly and they almost always lead with the same question: “can this tool meet my needs”? That’s fair. But here’s what I’ve learned. Every tool requires some concessions. If it can’t get you to your goal, it’s not the right tool regardless of how many features it has.

I want your business. That’s honest. But more than that, I want to earn the kind of relationship where you come back whether we sign this SOW or not, whether it’s next week or two years from now. That only happens if I actually help you get somewhere.

That question applies to how I run my own day too. I started asking myself what success actually looks like before I sit down to work, and the answer shaped everything. I want one place that reflects my entire day. Meetings, tasks, notes, all current, all in one spot. That goal is what drove me to build the morning process I now run every day with Claude Cowork as the orchestrator.

The Technology

The stack is intentionally minimal. Claude Cowork acts as the orchestrator, the intelligence that decides what needs to happen and in what order. It connects to Notion via the Notion MCP server, which gives it the ability to read and write directly to my Notion workspace. An AI orchestrator, a communication protocol, and a single workspace destination.

Each morning, the process kicks off by pulling my meetings for the day and placing them into a Notion database. From there it creates a daily digest, a dedicated entry that surfaces those meetings alongside the tasks I need to complete. It also creates a daily notes page and links it directly into the digest so everything is connected before I’ve touched a single thing manually.

Why the Goal-Driven Aspect Matters

Here’s where most automation falls short. It runs a checklist. Step one, step two, step three, regardless of what’s already been done, what’s changed, or what’s actually needed. That’s not intelligent orchestration. That’s a script with better branding.

What I wanted instead was a system oriented around a goal: my day workspace is current and usable. That’s it. Everything else, syncing meetings, creating the digest, linking notes, refreshing tasks, is in service of that goal. The orchestrator doesn’t ask what did I do yesterday. It asks what does today’s workspace need right now.

That distinction matters because my day doesn’t stop at 8am. Meetings get added, priorities shift, and sometimes I need the digest to reflect something that happened after the morning run. A goal-driven system handles that naturally. A midday refresh doesn’t restart the workflow from scratch. It checks what’s stale and updates only what needs updating. The digest gets updated, not recreated. The notes page preserves what I’ve written. Meetings that changed get synced and the ones that didn’t are left alone.

The Real Goal

What I’m ultimately working toward is managing my entire day from one place. Not a dashboard, not a report. A living workspace I can trust to be accurate whenever I look at it. The morning process gets it ready. The daytime refresh keeps it honest. Claude Cowork stops being an automation tool and starts being something closer to a daily operating system.

The goal isn’t to run a workflow. The goal is to always know where things stand.

Intro

The Power Platform is one of the most capable low-code ecosystems available today. Power Pages, Dataverse, Power Automate. When used together, teams can deliver real business solutions quickly, often without writing a single line of code.

But every platform has boundaries. And when those boundaries are crossed, users feel it immediately.

This is the story of a client who built the right solution on the right platform until scale turned a 60‑minute processing delay into a serious risk to adoption. The fix was not a wholesale rewrite or a departure from Power Platform. It was a single, targeted Azure Function that reduced processing time to under five minutes.

---

The Setup: A Well-Designed System With a Hidden Ceiling

The client built a customer intake system using Power Pages. Users completed a detailed, multi-question form, and each answer influenced which recommendations would be unlocked for their profile. Those recommendations were stored and managed in Dataverse.

The decision engine lived in Power Automate. When a form submission arrived, a flow iterated through every question, evaluated the response, applied business rules, and wrote the appropriate recommendations back to Dataverse.

From a design standpoint, the solution made sense. The logic was clear, the flow was readable, and for a time, it worked exactly as intended.

Until it didn’t.

---

The Breaking Point

The issue was not flawed logic. It was the execution model.

Power Automate processes loops sequentially. Each question required its own iteration. A check, a condition, and one or more Dataverse writes. Multiply that by dozens of questions per submission and the cost became obvious.

A single form submission took close to 60 minutes to fully process.

At low volume, this delay was tolerable. Users submitted a form and eventually saw their recommendations appear. But as usage increased, the system began to strain.

Submissions backed up. Users refreshed pages, assumed something had broken, or abandoned the process altogether. Support tickets increased. What had once been an inconvenience became a user experience problem that threatened confidence in the entire platform.

---

The Pull of Staying Low-Code

The initial instinct was to optimize the existing flow. Could loops be consolidated? Could conditions be simplified? Could parallel branches help?

The hesitation was understandable. The client had invested heavily in Power Platform. Their team knew it well, governance was in place, and introducing custom code meant new pipelines, monitoring, and skill sets.

But after profiling the flow, the conclusion was unavoidable. The bottleneck was structural. As long as the logic ran inside a sequential loop, no amount of tuning would produce the performance gains the platform needed.

---

A Surgical Fix

Rather than re-architect the system, we proposed a targeted change: move the recommendation processing logic out of Power Automate and into a JavaScript Azure Function.

Not a rewrite. Not a migration away from Power Platform. Just a surgical swap.

The Azure Function would receive the form submission data, evaluate all recommendation rules in a single execution, and write the results back to Dataverse in one pass. No per-question looping. No waiting for each iteration to finish before starting the next.

---

Building the Bridge

The most time-consuming part was not the code. It was extracting the business logic.

The recommendation rules lived across dozens of Power Automate actions, conditions, and expressions. Translating that into JavaScript meant reverse-engineering the flow, rule by rule.

We worked closely with the client to document every decision path, including edge cases and conditional dependencies that were not immediately obvious from the flow diagrams. Some rules were simple mappings. Others involved layered conditions such as “if Question A is X and Question C is Y, unlock Recommendation Z.”

The Azure Function connected to Dataverse using the Web API, with proper authentication, logging, and error handling built in. Unlike the original flow, the new solution provided clear, centralized visibility into execution and failures.

Testing was deliberate. We ran historical submissions through the function and compared the results to the Power Automate outputs, ensuring parity. Edge cases that had occasionally caused the flow to stall or skip records were handled explicitly in code.

---

The Result

The impact was immediate.

Processing time dropped from 60 minutes to under five minutes, a reduction of more than 90 percent.

Users submitted forms and saw recommendations populate almost immediately. The backlog disappeared. Support requests stopped. Most importantly, the platform could now scale without performance degrading as submission volume increased.

The broader architecture remained intact. Power Pages continued to handle the front end. Dataverse remained the system of record. Power Automate still orchestrated other workflows. The Azure Function simply replaced the one component that needed a different execution model.

---

The Bigger Lesson

Low-code does not mean no-code forever.

The Power Platform excels at accelerating delivery and empowering teams. But scalable solutions require understanding where the platform’s strengths end and where specialized tools belong.

The success of this project was not about abandoning Power Platform. It was about identifying a specific constraint, choosing the right tool to address it, and integrating that tool cleanly so the rest of the system continued to function exactly as before.

If your Power Platform solution is hitting performance limits, the answer is not always “optimize the flow.” Sometimes, it is a few hundred lines of code in exactly the right place.

Facing a similar challenge? We help teams strike the right balance between low-code speed and custom-code performance.

1. Introduction
2. The Role of Proof of Concepts
3. Rapid Prototyping
4. Conclusion

Introduction

As a consultant, I receive many questions about the Power Platform and its viability as a SaaS solution:

• “Is it secure?”

• “Is it mature enough to handle enterprise-grade solutions?”

• “Why not just use a ‘pro’ developer?”

These are all valid questions because they ultimately point to a larger, fundamental question that organizations typically have — and it can often be summed up with one word: HOW.

While “why” is often the first lens through which we view a problem, I’ve found that dwelling too long on the “why” can sometimes create more uncertainty than clarity. “Why” tends to be conceptual, inviting philosophical or theoretical discussions that don’t always lead to actionable steps. On the other hand, “how” shifts the conversation toward execution. It’s grounded, specific, and provides a strategy to address the questions at hand.

Take security, for example. If someone asks me why the Power Platform is secure, I could say, “It’s built on Microsoft’s trusted infrastructure.” While this is a fair response, it often leads to more follow-up questions: “Why is Microsoft’s infrastructure trusted?” or “Why should I believe it’s secure for my use case?”

Instead, focusing on the how delivers a clearer picture. For instance, how is the Power Platform secure? Through Azure Entra ID (formerly Azure AD), which enforces strong authentication, conditional access, and Single Sign-On (SSO). It goes further by integrating Multi-Factor Authentication (MFA) to add an extra layer of protection against unauthorized access. This level of detail gives key stakeholders in organization such as the CIO, the developer, or IT, tangible reasons to trust the platform.

The same shift from “why” to “how” applies when organizations are exploring the Power Platform’s broader potential. And this is where Proof of Concepts (POCs) come in.

The Role of Proof of Concepts

Proof of Concepts bridge the gap between “why” and “how.” They take abstract ideas and translate them into tangible solutions. A POC allows an organization to validate a concept, ensuring it meets their specific needs before committing to a full-scale implementation.

For example, when someone questions the Power Platform’s ability to handle enterprise-grade solutions, a POC can demonstrate how the platform seamlessly automates workflows, integrates data, and scales to meet business demands. It provides a real-world answer to the hypothetical “what ifs.”

By focusing on the how with a POC, we not only provide clarity but also give stakeholders the confidence they need to invest in the solution. POCs empower decision-makers to move forward with certainty, backed by a tangible demonstration of the platform’s capabilities.

Rapid Prototyping

When it comes to the Power Platform, one of Microsoft’s standout features is its low-code/no-code approach. While planning and requirements gathering remain basic necessity for any enterprise solution, the development time is reduced.

Take Canvas Apps as an example. These are web applications, but unlike the earlier days of web development, where every pixel and element had to be meticulously coded, Canvas Apps simplify the process. They allow developers to visually design the interface by dragging and dropping components onto a canvas. This lets them spend more time focusing on integrating and leveraging backend data sources—whether through Power Automate flows or connectors that directly link the app to the necessary data.

This shift in development approach transforms timelines. What used to require four weeks of intensive coding can now be accomplished in two weeks. The focus shifts from manual coding to refining security, optimizing processes, and achieving meaningful business outcomes.

Yes, investing time and resources in the Power Platform is a commitment, but it’s one that accelerates outcomes. Development on the platform allows us to either achieve success more quickly or “fail fast,” providing valuable insights along the way.

When we fail fast, we uncover lessons that inform better decisions and sharper strategies. When we succeed, we’re not just building solutions—we’re celebrating the realization of a clear path forward. Either way, the Power Platform ensures we’re moving with purpose, minimizing delays, and maximizing the value of our efforts.

Conclusion

If you’re using an M365 license, whether it’s E5 or a lower tier, you already have access to the Power Platform. Chances are, these tools are at your fingertips, yet they might be overlooked in favor of subscriptions to other software.

This is where a Proof of Concept (POC) on the Power Platform becomes invaluable. A POC will do one of two things:

1. Draw you in – It can showcase the Power Platform’s potential, demonstrating its value as an enterprise solution tailored to your needs.

2. Drive you forward – It can help you reach a clear conclusion, whether that’s investing in the Power Platform or exploring alternative solutions.

But here’s the key: how would you know if you didn’t try it?

A POC offers the opportunity to explore, test, and validate the Power Platform’s capabilities within your unique business context. It’s a low-risk, high-reward approach to uncovering whether this suite of tools can transform your processes and deliver the outcomes you’re seeking.

Thank you for reading!

1. Introduction
2. Solution
   1. Step 1: Microsoft Forms
   2. Step 2: Microsoft Planner
      1. Create New Plan
         1. Select ‘New Plan’
         2. Name your plan
         3. Set Privacy and Sensitivity
         4. Create
      2. Buckets
         1. Creating New Buckets
         2. Add new bucket
         3. Enter bucket name: {Name of your bucket}
         4. Tasks
   3. Step 3: Power Automate
      1. Trigger
         1. When a new response is submitted
         2. Action (Get response details)
         3. Action (Update task details)
   4. End to end test

---

Introduction

I believe Microsoft 365 licenses often go underutilized, with many businesses purchasing them without fully exploring their potential. Time and again, I implement solutions for enterprise clients whose needs might not initially seem to require all M365 apps. However, I see these applications as building blocks for powerful solutions in today’s workplace.

I’m passionate about empowering organizations to achieve more, and I believe Microsoft shares this vision, as reflected in the capabilities offered in their standard licenses. One app with great potential is Microsoft Planner. While Planner isn’t as feature-rich as Project or DevOps, it’s a strong alternative to tools like Trello and the former and can significantly benefit task management.

In this discussion, we’ll explore how to enhance Planner using Power Platform, particularly Power Automate. You’ll gain insights into Planner itself and see how Power Automate extends its functionality with M365 components. Best of all, this solution doesn’t require premium licensing—so if you have at least a Business Standard license, you’re good to go!

---

Solution

Our solution will utilize three main components: Microsoft Forms, Microsoft Planner, and Power Automate.

• Front-end: We’ll use Forms to collect input from prospective customers.
• Automation: Power Automate will process this input, creating a follow-up task in Planner for each prospect.
• Back-end: Planner will guide the onboarding journey for each customer. Once they’re onboarded, their information will be stored in a SharePoint list, ready for use in a Canvas App for customer management (to be introduced in the next discussion).

This streamlined approach ensures a smooth transition from prospecting to customer onboarding.

---

Step 1: Microsoft Forms

We’ll start by creating a basic form in Microsoft Forms, which is fortunately very user-friendly. The field types are limited, so it’s hard to go wrong here. For this solution, Forms is a solid choice since we’re only collecting general data—not sensitive information. It’s akin to signing up for a newsletter (unless, of course, it’s from a political party during election season!). Overall, Forms is a safe and straightforward option for our data collection needs.

For clarity, Microsoft Forms provides several field types, including choice, text, date, ranking, Net Promoter Score, file upload, rating, and Likert scale. In our form, we’ll use the text field type for each of our four questions, with all fields set as required. The fields will be:

1. First Name
2. Last Name
3. Email
4. Reason for contacting us

This setup keeps things simple and captures just the essential information.

---

Step 2: Microsoft Planner

The next component of our solution is Microsoft Planner. There are multiple ways to create a plan in Planner, but since the goal is to encourage users to explore business applications they already have, we’ll stick with the standard, non-premium approach.

For fully automated plan creation, the Graph API for Planner can be used, either through a custom connector or by making HTTP requests in Power Automate. However, for this solution, we’ll take a straightforward approach by manually creating the plan directly in the Planner interface.

Create New Plan

Navigate to Planner and take the following steps:

Select ‘New Plan’

Name your plan

Set Privacy and Sensitivity

Create

Buckets

When you create your plan in Microsoft Planner, you’ll see it displayed in a board view or Kanban view, where each category is referred to as a bucket. You can customize these buckets based on your onboarding strategy for prospects, organizing them in a way that best fits your workflow.

Creating New Buckets

Follow these steps to create new buckets. You can create as many as needed for your process. For example, I created three buckets: ‘To do,’ ‘Won,’ and ‘Lost.’

Add new bucket

Enter bucket name: {Name of your bucket}

Tasks

Each bucket holds tasks that are linked to it. While you can create tasks manually, we rely on automation to handle this. When a new form submission is received, a task will automatically be created in the ‘To do’ or starting bucket.

---

Step 3: Power Automate

Our flow will be simple: we’ll take the form responses and automatically create a Planner task to follow up with the client.

Trigger

When a new response is submitted

When a new form response is submitted, our flow will trigger automatically. Make sure to select the correct form from the dropdown menu in Power Automate to ensure the flow works with the form you’re using.

Action (Get response details)

The next step in the flow is to add the action to Get Response Details from the form submission. Select the same form as the Form Id that you want to receive responses from. Then, use the dynamic content from the previous step to set the Response Id and retrieve the submission details.​

The only available text field we can use is the Title field. To make it work, we’ll use dynamic content from the Get response details action, specifically the First Name, Last Name of the submitter. This information will be combined in the Title field so the agent in Planner will easily identify who to follow up with.

Action (Update task details)

After creating the task, we need to update its details to include relevant information from the submitter, such as their email address. Additionally, we will add a checklist to help the agent track the necessary steps for completing the task efficiently.

Using the dynamic content from the previous action, we will set the Task Id, update the Description field with the necessary data (such as the submitter’s email), and create a checklist item to ensure the agent follows up by emailing the prospect.

End to end test

---

1. Introduction
2. Bookings – 30000 Foot Overview
3. Our Solution
4. Building Bookings Site
   1. Step 1 – Bookings Homepage
   2. Step 2 – Create Shared Bookings Page
   3. Step 3 – Add a new service
   4. Service configuration
5. Creating Appointment Spreadsheet
   1. Step 1: Launch OneDrive
   2. Step 2: Create Excel Workbook
   3. Step 3: Establish a formatted field using Data Validation to generate a dropdown menu
6. Creating Power Automate Flow
   1. Step 1: Select Flow Type
   2. Step 2: Configure Flow
7. Conclusion

Introduction

I remember my second IT leader always emphasizing the importance of leveraging out-of-the-box solutions. That initially clashed with how I envisioned my tech career. I imagined myself as a coder, creating innovative, never-before-seen applications. However, over time, I realized the true value lies in making the most of the tools and features already available on our platforms. While it’s possible to build an API for nearly anything, we have to consider that others will maintain what we create. I’ve learned that just because we can build something, doesn’t mean we should. The focus should always be on delivering value without overcomplicating the solution.

One of the questions I often ask myself as a consultant is why a business customer would purchase Microsoft 365 Business Licensing and not fully utilize its features. Is it due to a lack of knowledge? Are users simply sticking to familiar tools like Word, Outlook, and Excel? Whatever the reason, I believe we should aim to maximize the value of our existing licensing and platform(s) before seeking external services that could be recreated in-house or eliminating redundant software to save costs.

It is not my intent to talk anyone out of purchasing a platform that they are familiar with. However, I want customers to know what they already have available with their Microsoft 365 subscription. In some cases, newer customers to the Microsoft 365 ecosystem aren’t fully aware of all the services and tools they’re paying for. For example, I have found that customers are unaware of their access to Power Apps and Power Automate—tools that can unlock tremendous potential for customization and automation.

---

Bookings – 30000 Foot Overview

When you hear “Microsoft Bookings,” what comes to mind? Or do you even think about Microsoft Bookings at all? If not, you’re not alone. I like to think of Bookings as a web-based interface for Outlook because it essentially builds on Outlook’s scheduling capabilities, like creating Teams meetings. In some ways, Bookings is similar to Calendly, though it lacks support for multiple backend calendars.

If you’re reading this, you likely already have, or are considering, a Microsoft 365 license. Thanks to the Power Platform’s flexibility, integrating with external services like Calendly is quite simple, especially with its available API connector. However, the focus of this article is on maximizing extensibility without incurring extra costs beyond your standard business licensing. As of this writing, the Calendly connector is classified as a premium feature, which means additional charges for using it in automation or apps—approximately $15 per month for Power Automate and $20 per user per month for Power Apps.

---

Our Solution

We want to provide our clients with the ability to book appointments with us. After the booking is confirmed, we will send an email to the client containing details on how to remit payment before the upcoming appointment. Using Power Automate, we’ll automatically log the booking details into a spreadsheet. This will include the client’s name, meeting description, meeting notes, meeting date, and a boolean field to track whether payment has been received before the scheduled appointment.

---

Building Bookings Site

Step 1 – Bookings Homepage

To get started, navigate to Bookings – Admin – Outlook (office.com). Once you arrive at the site you will see the homepage (pictured below).

Step 2 – Create Shared Bookings Page

Next we’re going to create our booking page. There are two ways to create a booking page.

1. Create from scratch
2. Clone an existing booking page

During this demo, we will create our page from scratch. To begin, select “Create from scratch,” which will launch a creation wizard with the following options:

• Name – Name of Booking Page
• Logo – Company logo. I would use a vector graphic of some sort just so image does not get distorted
• Business type
  • Healthcare
  • Recruiting
  • IT Support
  • Education
  • Financial Services
  • Sales
  • Other

Step 3 – Add a new service

Once our Bookings page has been created, the next step is to add services that will be displayed to users. When creating a service, there are several categories with configurable options, including:

• Basic Details
• Availability Options
• Assign Staff
• Custom Fields
• Notifications

These settings allow us to tailor the meeting scheduling experience to fit both our availability and the needs of our clients.

Service configuration

As we configure the basic settings for our new service, you’ll learn how the booking system works. Feel free to explore and configure additional options for your service during this demo.

The options we are going to configure can be found under the Basic details tab.

• Name
• Description
• Location
• Duration
• Buffer Time
• Cost
• Maximum number of attendees

We will also include a custom field to capture how customers discovered our company.

---

Creating Appointment Spreadsheet

Let’s focus on our outputs; we will utilize a spreadsheet to monitor whether a customer has paid for their appointment. We will store our spreadsheet on OneDrive.

Step 1: Launch OneDrive

1. To access OneDrive navigate to office.com
2. From our app launcher Select the OneDrive logo to launch OneDrive

Step 2: Create Excel Workbook

1. Click the Plus (+) sign.
2. Choose ‘Excel Workbook’.
3. Enter the following column headers for the workbook: Client Name, Meeting Description, Meeting Notes, Meeting Date, Paid.
4. Highlight the first row, then go to the ‘Styles’ tab and choose ‘Format as Table’.
5. Tick the box that says “My table has headers”.
6. Click ‘OK’.

Step 3: Establish a formatted field using Data Validation to generate a dropdown menu

1. Select the “Paid” field.
2. Choose the Data tab from the ribbon.
3. Click on Data Validation.
4. From the Allow dropdown, choose List.
5. Enter a comma-separated list with the values true, false.
6. Click Apply.

---

Creating Power Automate Flow

Step 1: Select Flow Type

1. To create our automation to process newly created appointments navigate to make.powerautomate.com
2. Select Create
3. Select Automated cloud flow as flow type
4. Name flow
5. Select Bookings Trigger “When a appointment is Created”
6. Select Create

Step 2: Configure Flow

1. Sign in to the Bookings calendar using the same credentials you used to create the Bookings page.
2. Add the Excel action “Add a row into a table.”
3. Fill in the required details for the action, including file location, document library, file name, table name, and any other necessary fields.

---

Conclusion

While it’s easy to turn to familiar tools or third-party platforms, the true value lies in unlocking the full potential of your existing Microsoft 365 subscription. By harnessing the power of the platform—specifically tools like Power Apps and Power Automate—you gain a comprehensive solution that can streamline processes, drive productivity, and reduce unnecessary costs.

Microsoft 365 isn’t just a collection of isolated applications; it’s a fully integrated platform designed to help you build solutions that fit your unique business needs. Whether you’re automating workflows or creating custom apps, the flexibility and extensibility of Power Platform allow you to create tailored solutions without the complexity of building from scratch or relying on external services.

By investing in this platform as a solution, you’re empowering your business to do more with less—maximizing the value of what you already have while ensuring that any custom developments are truly meaningful and efficient. With the right approach, complex problems can be solved in simpler, more effective ways, giving you the agility to grow and adapt without over complicating your tech stack. Businesses can not only streamline processes and enhance productivity but also avoid unnecessary costs. The goal should always be to maximize the value of the tools at hand, ensuring that any custom development or external service is truly adding value. After all, the power of the platform is in its flexibility and extensibility, often making complex solutions easier than we might initially imagine.

1. Introduction
2. Solution
3. Demo
   1. Step 1
   2. Step 2
   3. Step 3

Introduction

I’ll see if I can manage this in 20 minutes. I’m currently at a terminal in O’Hare, about to head to Las Vegas for the Power Platform Conference, and I’ve just thought of an intriguing scenario for which I recently devised a solution in a canvas app.

The print functionality in Canvas Apps, while serviceable, is not the best. I found a workaround by utilizing OneDrive’s native capabilities to print a PDF.

Solution

For demonstration purposes, my example is abbreviated. Initially, I had to generate a PDF using Power Automate and Microsoft Word templates, which would then be printable by the user. In the first version, I created the PDF and emailed it to the user, who could then print the attachment. However, this method necessitated that they access Outlook to retrieve the email.

My second approach was to determine how to print the PDF directly from the app, maintaining the format as it appeared when generated in Word. I considered creating a PCF but decided against it due to budget constraints. I experimented with opening and closing the PDF in OneDrive via the browser, attempting to manipulate the URL parameters for use in the app to prompt the browser to initiate printing. Unfortunately, this method was unsuccessful.

As I reflected, I began to count the number of clicks. As developers, our aim is to reduce the number of clicks required for a user to complete a task, since an excess can lead to irritation. My objective was to enable users to complete the printing task in fewer than five clicks, with the app managing the interaction directly, rather than having to press a button, wait for an email, retrieve the attachment, and then print.

I utilized Power Automate to create a Word document, convert it to PDF, save it to OneDrive, retrieve the sharing link for the app, launch the PDF in a new tab, and then print the document.

This enabled me to achieve my objective of printing the document in fewer than five clicks.

Demo

Again our demo is a bit short

Step 1

Add your document library as your data source.

Step 2

Use a button to set a global variable by employing a lookup function linked to your document library, utilizing the ID as the lookup criterion to fetch a single record. Apply dot notation and set the variable using ‘Link to item’ as the parameter.

Encapsulate the variable within the Launch function, set the target to ‘new’ to open a new tab, and it will initiate the launch of your PDF.

Step 3

Click the print button.

I had an interesting question posed to me recently. The customer was using a Model Driven app and wanted to format a 10-digit number as a phone number. I thought sure, create a JavaScript web resource and have it do its jazz after the user entered the 10-digit number prior to submission of the record.

The customer requested we use no code because they have a strict process for checking in code. So I suggested the following.

1. Create a Power Automate flow that runs when a record is created or updated
2. Write the following formula into phone number field: concat('(', substring(triggerBody()?['text'], 0, 3), ') ', substring(triggerBody()?['text'], 3, 3), '-', substring(triggerBody()?['text'], 6, 4))

Configuration of flow

I don’t consider myself a Power Platform savant, but I will say this: it’s a lot of fun to take the best components of the Power Platform and craft a solution that works for customers. My primary responsibility is to recommend the best possible solution using the most suitable tools available. What does that mean in practice? For instance, I wouldn’t try to build a reporting canvas app with complex PowerFx patterns. Instead, I would create the reports in Power BI and embed them in the app if needed.

The same concept applies to the integration between Power Automate and Power Apps. Why struggle with complex patterns and many lines of PowerFx when you can leverage Power Automate to handle backend processing? Power Automate is designed to handle these tasks efficiently.

But what if you need feedback from Power Automate within your app? If your processing takes less than two minutes, you’re in good shape. But those pesky edge cases do exist, and there will be times when processing might take a bit longer. That’s when a bit of ingenuity and creativity come into play.

Polling

Have you heard of polling? It’s a process where we repeatedly check a database to see if a specific condition, we’re looking for has been met. In a canvas app, we can implement this by using a timer. When the timer finishes, the app checks Dataverse, SharePoint, SQL, or another data source to see if the condition has been satisfied. If it has, we provide feedback directly to the app. If it hasn’t, the polling continues until the condition is met or until a counter mechanism or variable that stops the polling after a set number of attempts.

Step 1: Setup Timer

In our canvas app we want to add the timer control and add the following parameters to the each respective property listed below:

Property	Value	Description
Duration	6000	Timer duration will be 6 seconds
OnTimerEnd	If( IsBlank( LookUp( colTestTimer, Id = 0 ).Column1 ), UpdateContext({ctxEmptyCol: true}), UpdateContext({ctxEmptyCol: false}) )	If Column1 in the colTestTimer collection is empty, set the context variable ctxEmptyCol to true; otherwise, set it to false. If the context variable is false, then the timer will stop.
Repeat	true	The timer will continue to repeat until the polling results are satisfactory.
Reset	!ctxEmptyCol	Reset the timer once all conditions are fulfilled.
Start	ctxEmptyCol	Initiate the timer as Column1 in the collection is empty.

Step 2: Test

To test our timer, we will require two buttons: one to create the collection with Column1 being empty, and another to initiate a write to Column1 and stop the polling.

Button 1

In the OnSelect property of the first button, paste the following code:

ClearCollect(colTestTimer, {Column1: Text(Blank()), Id: 0}); UpdateContext({ctxEmptyCol: true})

Button 2

In the OnSelect property of the second button, paste the following code:

UpdateIf(colTestTimer, Id = 0, {Column1: "Not Empty"})

Test

Launch the application. Press the first button to initiate the timer and fill the collection. Allow the timer to complete several cycles, and once you’re prepared, hit the second button to refresh the collection. Upon the timer’s completion, it will check the collection, recognize that the condition has been met, and cease polling.

Conclusion

In this article, the focus is on polling a collection; however, your options are not confined to this collection alone. It’s crucial to use polling judiciously and construct patterns that do not impede your app’s performance. An example of this is polling a table to check if a file has been created and linked to a record. Undoubtedly, you can discover numerous intriguing use cases to further this concept.

1. Introduction
   1. Leveling Up Your Power Automate Game with Expressions
   2. Why Expressions Matter
   3. Working with JSON Files Using Expressions
   4. Real-World Example: Inspecting a File from FTP
   5. Benefits of Using Expressions
2. Solution
   1. Step 1
   2. Step 2
   3. Step 3

Introduction

Leveling Up Your Power Automate Game with Expressions

When I first started using Power Automate, there were a few things I wish I had known that would have saved me time and frustration. One of the biggest lessons? Mastering expressions. Expressions in Power Automate are like a secret superpower that can take your automation to the next level.

Why Expressions Matter

Expressions let you handle logic and data transformations directly within your flow. For example:

• Instead of using a Condition action to validate if outputs meet specific criteria, you can use a single expression to evaluate the data inline.

• This makes your flows more efficient, cleaner, and often faster.

Working with JSON Files Using Expressions

Let’s talk about working with JSON files—a scenario many of us face when automating workflows.

Instead of:

1. Taking the content of a JSON file.

2. Saving it to SharePoint (or another location).

3. Opening the file to inspect its contents.

You simply use an expression in Power Automate to directly parse and view the content of the JSON at runtime.

For instance:

• Use the json() expression to convert file content into a readable JSON object.

• This lets you work with the data directly in the flow without needing to save or manipulate the file externally.

Real-World Example: Inspecting a File from FTP

Imagine this scenario:

• A file is generated on a server and fetched into Power Automate using the SSH – FTP connector.

• Instead of copying this file to SharePoint just to review its contents, you can apply an expression like json(outputs(‘Get_file_content’)) to convert the file content directly into JSON format.

• This approach enables you to extract, validate, or manipulate data from the file immediately during the flow’s runtime.

Benefits of Using Expressions

1. Efficiency: Skip unnecessary steps like saving files or creating extra conditions.

2. Flexibility: Work with complex data structures, like arrays and objects, without additional processing.

3. Cleaner Flows: Reduce the number of actions in your flow, making it easier to manage and debug.

Solution

Step 1

Create a Power Automate flow with a “Button” trigger.

Step 2

Add a Compose action, and in this action, write the following expression.

json(base64ToString('ewogICAgImludm9pY2VOdW1iZXIiOiAiSU5WLTAwMSIsCiAgICAiaW52b2ljZURhdGUiOiAiMjAyNC0xMS0yOCIsCiAgICAiZHVlRGF0ZSI6ICIyMDI0LTEyLTI4IiwKICAgICJjdXN0b21lciI6IHsKICAgICAgICAibmFtZSI6ICJKb2huIERvZSIsCiAgICAgICAgImFkZHJlc3MiOiAiMTIzIE1haW4gU3RyZWV0LCBDaXR5dmlsbGUsIENvdW50cnkiLAogICAgICAgICJlbWFpbCI6ICJqb2huLmRvZUBleGFtcGxlLmNvbSIKICAgIH0sCiAgICAiaXRlbXMiOiBbCiAgICAgICAgewogICAgICAgICAgICAiZGVzY3JpcHRpb24iOiAiUHJvZHVjdCBBIiwKICAgICAgICAgICAgInF1YW50aXR5IjogMiwKICAgICAgICAgICAgInVuaXRQcmljZSI6IDUwLjAsCiAgICAgICAgICAgICJ0b3RhbFByaWNlIjogMTAwLjAKICAgICAgICB9LAogICAgICAgIHsKICAgICAgICAgICAgImRlc2NyaXB0aW9uIjogIlByb2R1Y3QgQiIsCiAgICAgICAgICAgICJxdWFudGl0eSI6IDEsCiAgICAgICAgICAgICJ1bml0UHJpY2UiOiA3NS4wLAogICAgICAgICAgICAidG90YWxQcmljZSI6IDc1LjAKICAgICAgICB9CiAgICBdLAogICAgInRvdGFsQW1vdW50IjogMTc1LjAsCiAgICAiY3VycmVuY3kiOiAiVVNEIgp9'))

Step 3

Run our flow to see the JSON