echo3.co

ADHD, generalisation, and why I've never wanted to specialise

2026-07-19T00:00:00Z

TLDR: diagnosed with ADHD at 51, after decades of suspecting it myself. This is the story of what that's actually like day to day, why it pushed me toward being a generalist instead of a specialist, and why I've stopped treating that as a failure. If you just want the professional payoff, it's in the last section.

I was diagnosed with ADHD two years ago, at 51. I’m writing this at 53, which should tell you something about how long it took me to actually sit down and write it.

I didn’t get diagnosed because I finally noticed something was wrong; I suspected ever since ADHD started being discussed openly that I had it. I got diagnosed because at some point I decided that noticing wasn’t the same as knowing, and if I was going to build my working life around this trait, I wanted a qualified psychiatrist to actually confirm it rather than me diagnosing myself off the back of an online screening questionnaire.

That distinction matters more than it sounds. Self-recognition is usually right, in my experience and from what I hear from other adults who go through this. The pattern-matching part of noticing “this describes me” is not the hard part. The hard part, and the useful part, is what a formal assessment gives you that self-diagnosis can’t: certainty you can actually build on, and access to medication if you decide you want it as one tool among several. I do, sometimes. Not daily, not as a personality transplant, but situationally, month-end bookkeeping being the reliable example I always reach for. There is no earthly reason my brain finds reconciling invoices harder than untangling a genuinely difficult problem, which is basically my raison d’être, and yet here we are. Medication helps on the days that particular mismatch needs help.

What the trait actually looks like, thirty-plus years in

I’m not going to pretend this is all upside dressed up as a personality quirk, because that does a disservice to anyone reading this who’s tired of ADHD being marketed as a secret superpower with none of the difficult bits mentioned.

The difficult bits are real. Tasks that are boring but important, the invoicing, the admin, the licence renewal that’s been sitting in an email for three weeks, get avoided in a way that has nothing to do with laziness and everything to do with a brain that treats “important but uninteresting” as barely worth the fuel. Multi-step tasks with no obvious payoff until the very end are hard to start and harder to finish. And there’s a particular flavour of shame that comes from knowing exactly what you should be doing, wanting to do it, and still not doing it, that took me a long time to stop internalising as a character flaw.

The coping mechanisms accumulate over decades whether you’ve got a name for what you’re coping with or not. External structure where my own doesn’t hold: calendars, reminders, breaking big vague tasks into small concrete ones I can actually start. Knowing which of my own moods are “just get started and it’ll click” versus “genuinely not today, don’t fight it.” None of that came from a diagnosis. The diagnosis just explained why I’d needed to build all of it in the first place.

And then there’s the other side, which is where this stops being a list of coping strategies and starts being relevant to why you’re reading this on an IT professional’s website rather than a mental health blog. I chase the next interesting thing, constantly. I see the big picture before I see the detail. I generate ideas at a rate that occasionally outpaces my ability to execute on all of them. And when something is either genuinely fascinating or the deadline is real and close, I can hyperfocus in a way that gets a disproportionate amount done in a short window, the flip side of the same trait that makes me useless at starting the boring thing three weeks before it’s due.

Why that produces a generalist, not a specialist

Twenty-five years in IT, and I’ve never wanted to go deep and narrow in any one direction. Plenty of very good, very successful IT people build a career on exactly that, ten years becoming the best in the world at one specific thing. I looked at that path more than once and knew, with total certainty, that it would slowly kill something in me. Not because depth is bad. Because staying interested in one narrow thing for a decade is exactly the kind of task my brain treats as “important but uninteresting” once the initial novelty wears off, and I’d have been fighting my own wiring the entire way.

My wife of thirty years is a specialist. She’s excellent at one thing, and she’s the best in her game at it. My brother-in-law is the same, top of his field. I could never be either of those people, but the world is built to expect specialists, or at least that’s how it felt for years, and against that expectation (real or imagined) I spent a long time quietly filing myself under F for failure. Twenty-five-plus years into a career, and where had it got me? Not the best in a field. Not a six-figure salary at the top of a large company. Just someone working for himself in a niche, doing interesting things, keeping his clients happy, trusting he’d always give them the best advice, no BS, and fantastic value for money. It took me a long time to see that as the actual result rather than the consolation prize. I spent 25 years measuring myself against a definition of success I now think was wrong for me, and it hurt.

I’ve made peace with it now. I’ll never specialise, and I’ll always be good at a lot of different things instead. My wife still rolls her eyes at me sometimes: “well, of course you’re excellent at that thing you just started.”

Generalising isn’t a consolation prize for not being able to specialise. It’s the actual shape of how this brain works well. New problem, new domain, new interesting puzzle, every single week, sometimes every single day. A bespoke Power Automate flow one morning, an ISO 27001 control gap the next afternoon, a stalled cloud app deployment that’s sat there waiting for someone to actually make it go live, the day after that. That’s not scattered. That’s the exact operating conditions this trait actually thrives under.

How this actually helps the people I work for

I’ll keep this part short, because the story above is the evidence, not a preamble to it.

Pattern recognition across domains that specialists often don’t cross is a direct product of never staying in one lane long enough to forget what the other lanes look like. Spotting that a client’s problem doesn’t need the expensive enterprise platform, it needs a small, right-sized thing built from parts most consultants wouldn’t think to combine, that’s the generalist’s move, not the specialist’s. Hyperfocus, the same trait that makes me useless at starting my own admin early, means that when I’m in the middle of solving something genuinely knotty for a client, I don’t want to stop until it’s actually solved. And a lower tolerance for boring, bloated process than most people have is, frankly, why “the smallest thing that solves it” isn’t just a pricing philosophy on this site. It’s the only way I’ve ever been able to work.

I’m not telling you this so you’ll feel sorry for me, or so you’ll be impressed. I’m telling you because if you’re going to trust someone with your systems, you might as well know what’s actually driving how they think.

Building a GDPR-Compliant Patient System on Microsoft 365 for a Genetic Counselling Practice

2026-07-18T00:00:00Z

A solo genetic counsellor came to me needing a proper patient management system. Booking, notes, documents, all of it currently scattered across inboxes and a spreadsheet. The market had two options: dedicated clinic software, priced and featured for a multi-clinician practice, or generic CRM tools that would need almost as much bespoke work as building from scratch, minus the fit. Neither made sense for one practitioner.

She was already paying for Microsoft 365, and as the sole controller of other people’s genetic health data, she was already bound by GDPR, no industry-specific certification required. So instead of adding a vendor, I built the system inside the tenant she already owned and already had to secure.

Architecture

SharePoint does the data layer: a Patients list, an Appointments list, a Notes list, and a Patient Documents library, linked together with lookup columns rather than duplicated fields. Nothing exotic, but it means every record lives somewhere she can audit, back up, and permission without learning a new admin console.

Microsoft Bookings handles the actual scheduling, because it’s the thing clients see and it already worked. A Power Automate flow bridges Bookings to SharePoint: every new booking becomes a patient record (or updates an existing one) and an appointment record, without anyone re-typing details into a second system.

Power Apps is the planned front end, a canvas app for the day-to-day work of looking up a patient, adding notes, and pulling up documents, so the practice doesn’t need to touch SharePoint’s native UI at all.

Auth runs through Entra ID, same as the rest of the tenant. That’s most of the GDPR case in one sentence: no new identity provider, no new place for access control to drift out of sync, no personal data leaving infrastructure that’s already covered by the client’s existing data processing arrangements. The whole thing costs the price of the Microsoft 365 licences she was paying for anyway.

Gotchas

A few things that cost more time than they should have, in case they save someone else the afternoon:

The Bookings connector’s calendar dropdown in Power Automate fails with AADSTS50013. Don’t fight it: type the booking mailbox address directly into the trigger field instead of selecting from the list.
Inline filter() expressions in Power Automate are flaky when pulling values out of CustomQuestionAnswers. The Filter array action does the same job and actually works.
The Bookings trigger returns StartTime as a plain string, not an object. No ?['DateTime'] needed, and adding it just breaks the expression.
Array length checks on the dedup branch need “is greater than”, not “is equal to”. Equal to zero silently skips cases it shouldn’t.
Patient deduplication matches on email address only. That’s a simplification, not an oversight: at this practice’s patient volume, it’s reliable enough, and anything more elaborate would be solving a problem she doesn’t have.

Where it stands

The data layer and the Bookings-to-SharePoint integration are built and tested: bookings flow in, patient and appointment records get created or matched correctly, nothing needs manual re-entry. The Power Apps front end is next.

Building a Real-Time AI Bridge for a Tabletop RPG

2026-04-25T00:00:00Z

I play Dungeons and Dragons. Specifically, I run it: I’m the Dungeon Master, which means I’m responsible for the world, the story, the NPCs, the rules, the pacing, and the improvised dialogue. It’s a lot of overhead, and prep time is always limited.

I’ve been using AI heavily for prep: developing characters, writing descriptions, planning encounters. But during live sessions, keeping the AI contextually aware of the game state while running the session is difficult. I was either neglecting the AI or breaking the flow of the game to type updates.

The solution was to connect them directly.

The Setup: Virtual Tabletops

Fantasy Grounds Unity (FGU) is a leading Virtual Tabletop (VTT) that replicates the tabletop experience online. It has a rich extension system and a large library of licensed content. We play online, keeping a Discord open for voice chat while the game’s mechanics and narrative play out in the FGU chat window.

FGU Has No Native AI Integration

To use AI during a session, you normally have to manually copy chat logs or summarize events in a separate browser window, then copy responses back. That workflow falls apart at a live table. I needed the AI to watch the session alongside me, building its own awareness of events, so I could query it with minimal friction.

The Architecture

The bridge consists of three components:

A Lua extension inside FGU: This registers custom GM slash commands. When typed, the extension writes a JSON request directly to FGU’s console log.
A Python server running locally: This monitors FGU’s chatlog.html for new entries, parsing them in real time to accumulate session history in memory. When a GM command is written to the console log, the Python server packages the history, the command, and the campaign notes, and sends them to the Anthropic API.
The Anthropic API (Claude): Receives the full context, generates the response, and returns it to the Python server, which automatically copies it to the system clipboard for the GM to paste.

FGU chatlog.html  →  Python monitors continuously
                      Session events accumulate in memory (no API call, no cost)

GM types /npctalk  →  console.log  →  Python detects it
                       Full context sent to Anthropic API
                       Response copied to clipboard
                       GM: Ctrl+V into FGU chat → Enter

How the Live Context Works

FGU writes everything—dialogue, attack rolls, damage, turn markers—to chatlog.html. The Python server polls this file every 0.4 seconds. New lines are parsed, stripped of HTML, and appended to an in-memory list. Mechanical events (like dice rolls) are prefixed with [ROLL] so Claude understands they are game mechanics rather than narrative text.

Every few seconds, pending events are flushed into the conversation history as a [TABLE] message. Claude is instructed via the system prompt to absorb these silently without generating a response.

When a slash command is sent, the entire conversation history is dispatched to the API. Claude has seen the full context of the session and can respond instantly in character.

The Campaign Notes

Two markdown files provide Claude’s background knowledge:

campaign_history.md: The accumulated campaign record (world details, character backstories, session recaps).
session_notes.md: Pre-written descriptions for locations, NPC profiles (personality, voice, mannerisms), and GM secrets.

These are loaded at server startup and injected into the system prompt of every API call.

The GM Commands

All commands are slash commands typed in the FGU chat box:

/describe: Generates sensory scene descriptions based on notes.
/npctalk (Name): Generates character dialogue ready to paste.
/npcaction (Name): Generates physical character actions.
/combatsummary: Translates recent dice rolls into a narrative description of the battle.
/claude: Freeform private query whispered to the GM.
/claudereset: Clears the conversation history buffer.

Cost & Performance

API calls are only made when a GM command is sent; monitoring the logs is free. A full session typically costs less than a dollar using Claude Haiku, depending on the size of the note files and query frequency.

The full project, including the Lua extension and Python server templates, is available on GitHub (heyjudeuk/fgu-claude-bridge).

Note for developers: FGU Unity 5.x uses Comm.registerSlashHandler for slash commands. Older documentations reference ChatManager.registerSlashCommand, which has been deprecated.

Fixing the Microsoft 365 Room Finder Nobody Could See

2026-01-25T00:00:00Z

You create a room resource in Exchange Online. Maybe it’s just a single meeting room for a small office, but you want bookings managed properly rather than relying on calendar etiquette and guesswork. Everything appears to be set up correctly, yet users report they cannot find the room in Outlook’s Room Finder. They can add it by manually typing the room name, but the automated search is an empty void.

When a user clicks “Add room” and selects “Browse all rooms”, Room Finder prompts them to select a building, only to return zero results.

This behavior shows up consistently across Outlook desktop, Outlook on the web, and Teams. In most cases, nothing is actually broken—Microsoft’s default configurations simply assume you are a multinational corporation.

The Missing Metadata Trap

Microsoft’s official troubleshooting guidance tells you to create a Room List using PowerShell and add the rooms to it (documented in Microsoft’s Troubleshooting Guide).

You can follow those instructions exactly, create the list, add the room, and wait 48 hours for replication, only to find the Room Finder is still completely empty.

The reason is that modern Room Finder is driven by Microsoft’s Places service. If a room is missing basic location metadata—specifically street, city, postcode, and country—it will fail to appear even when the building field is populated. The UI doesn’t throw an error or warn you; it just silently fails to display the resource.

This design makes sense if you assume every tenant has dozens of offices spread across regions, each managed by a dedicated facilities team. For a small office with one meeting room and a kettle in the corner, it is absurd. There is no fallback, no “show all rooms” button, and no hint explaining that missing metadata is the blocker.

The Fix

The fix requires PowerShell. You cannot configure these location attributes in the Microsoft 365 Admin Center or the Exchange Admin Center UI.

First, connect to Exchange Online PowerShell and run this to inspect what Exchange actually sees:

Get-Place | Where-Object { $_.Type -eq "Room" } | Format-Table Identity,Building,City,Street,PostalCode

If your rooms show empty location fields, Room Finder will ignore them. To fix it, assign both the building and the core location metadata:

Set-Place `
  -Identity "Meeting Room 1" `
  -Building "ABC Company HQ" `
  -Street "Alphabet Street" `
  -City "London" `
  -PostalCode "ABC DEF" `
  -CountryOrRegion "United Kingdom" `
  -Floor 1 `
  -Capacity 8

After running Set-Place and ensuring the room is in a valid Room List, wait a few hours for the directory changes to propagate.

Microsoft’s choice to require enterprise-grade metadata before displaying a single office meeting room is a classic example of corporate over-engineering. But once you populate the Place fields, the Room Finder finally works.

Entra ID Joined, But Not an Admin? Fixing the "SID With a Question Mark" Issue on Windows 11

2025-06-20T00:00:00Z

You unbox a new Windows 11 Pro laptop, run through the out-of-box experience, sign in with a work account, and the device joins Entra ID without complaint. Then you find the user has no local admin rights.

Worse, if you open the local Administrators group you’ll see a SID starting S-1-12-1... with a greyed-out question mark where a name should be. No name, no permissions, no way to elevate. Fully joined, fully unusable.

The problem

The first user to join a device to Entra ID used to be added to the local Administrators group automatically. Microsoft changed that default in newer tenants. The join itself still succeeds, but the admin assignment doesn’t happen, and what’s left behind is a SID Windows can’t resolve. The account clearly exists, since the user can sign in, but there’s nothing to elevate it with: no admin password, no way to install software, update drivers, or reset Windows from within the OS.

What causes it

Almost always, it’s the device settings in Entra ID (or an Intune policy) not assigning local admin rights during join. Check it here:

Entra admin centre → Devices → Device settings → Local administrator settings

Set “Registering user is added as local administrator on the device during Microsoft Entra join” to All, and “Global administrator role is added as local administrator on the device during Microsoft Entra join” to Yes (handy as a fallback if the first setting ever gets misconfigured again).

Fixing a device already in this state

If a device has already joined with no admin user, there are two ways out.

Reset and rejoin. If you’re still early in deployment, Shift + Restart at the login screen → Troubleshoot → Reset this PC. Keep the device online throughout OOBE, and fix the tenant setting above first so the rejoin doesn’t repeat the problem. If BitLocker is on, confirm the recovery key is already in Entra ID before you wipe.

Fix it remotely via Intune, if wiping isn’t an option. Push a script through Endpoint Manager → Devices → Scripts:

Add-LocalGroupMember -Group "Administrators" -Member "AzureAD\user@domain.com"

The takeaway

Nothing here is broken so much as reconfigured: Microsoft tightened the default, and a device that looks fully provisioned can still be missing the one thing that makes it usable. Worth checking the device settings before you roll out a new deployment profile, rather than after the first support call.

Why MFA Isn't Enough (And How to Actually Fix It)

2024-09-03T00:00:00Z

Multi-Factor Authentication (MFA) is the standard baseline for securing Microsoft 365 accounts. By requiring a second factor—like an authenticator app approval or a code—it stops bulk credential-stuffing attacks. However, relying on MFA as a standalone defense creates a false sense of security. Modern phishing techniques bypass standard MFA entirely by targeting session cookies rather than just passwords.

The Mechanics of Session Hijacking

Phishing frameworks like Evilginx do not just steal credentials; they steal the authenticated session.

Evilginx operates as a reverse proxy, acting as a man-in-the-middle between the user and the legitimate Microsoft 365 login portal. The workflow operates in six stages:

Proxy Setup: The attacker deploys a server running the reverse proxy, cloning the styling of the target login page.
Link Generation: The proxy generates a custom URL pointing to the proxy server, designed to mimic a legitimate domain.
Delivery: The link is sent to the user via a targeted email, disguised as a standard document review or password prompt.
Interception: When the user clicks the link, they see the actual, live Microsoft login page served through the proxy.
Capture: As the user enters their password and completes the MFA prompt, the proxy intercepts both the credentials and the resulting session cookie.
Hijack: The legitimate portal issues a session cookie to the user’s browser to keep them logged in. The proxy intercepts this cookie and copies it. The attacker can then load this cookie into their own browser, bypassing MFA entirely and gaining direct access to the mailbox.

Once inside, attackers typically set up silent inbox rules to delete sent mail or redirect invoices, playing a quiet “long game” to intercept financial transactions.

Moving Beyond User Training

Many organizations treat user training as their primary defense against these attacks. While training helps, humans are fallible. Under pressure or distraction, even trained users will click a well-crafted link.

Relying on users to spot sophisticated proxy domains is a weak security model. Instead, you need hard, system-enforced technical controls.

Hard Controls: Conditional Access and Intune

To secure Microsoft 365 against session theft, you must implement Conditional Access policies that restrict access to verified, compliant devices.

Instead of asking “who is logging in?”, your security policies must ask “what device are they logging in from?”.

By integrating Microsoft Intune and enforcing device compliance, you ensure that:

Only corporate-managed or registered compliant devices can access company data.
An attacker in possession of a stolen session cookie still cannot log in, because their machine is not registered in your directory as a compliant device.

For personal devices (like mobiles used for email), you can enforce selective compliance policies through Mobile Application Management (MAM) to protect corporate data without violating personal privacy.

MFA is a necessary baseline, but it is not a complete security strategy. True security means deploying controls that are actually real—hardening the identity boundary so that stolen session cookies are useless without a verified, managed device.

Windows 10 Remote Desktop Fix: "The system administrator has restricted the types of logon (network or interactive) that you may use"

2024-05-23T00:00:00Z

A client was trying to reach a Windows 10 Enterprise workstation over RDP from a laptop and hit this:

“The system administrator has restricted the types of logon (network or interactive) that you may use. For assistance, contact your system administrator or technical support.”

What I checked first

Remote access was enabled.
The account used for the connection was local and a member of the local Administrators group.
NLA and the firewall were both switched off, purely to rule them out.

All of that was fine, which meant the problem was somewhere less obvious.

The actual cause

I opened Local Security Policy (secpol.msc, or search “local security policy” from the Start menu) to confirm the Administrators group was listed under “Allow log on through Remote Desktop Services.” It was. While I was in there, though, I noticed “Deny log on through Remote Desktop Services” had an entry for Local account.

Open Local Security Policy:

Find “Deny log on through Remote Desktop Services”:

Remove “Local account”:

That was it. Problem solved.

This policy appears to be a default on Enterprise editions, on the assumption that the machine is domain-joined and RDP access should come through domain accounts rather than local ones. This particular workstation was standalone, so the default was actively working against the client rather than protecting anything.

Worth noting: “Deny access to this computer from the network” had the same Local account entry, and will bite you the same way if you’re troubleshooting network logons rather than RDP specifically.

Handling Null Properties in JSON Payloads in Power Automate

2024-03-08T00:00:00Z

Following on from my previous article on querying the Companies House API in Microsoft Power Automate, in this article I’ll explore an option for handling missing JSON properties in a given payload that are necessary for subsequent actions in your flow.

The Problem

As an overview, this is what my flow does:

From a source Excel spreadsheet, iterate through a list of company registration numbers that I’m interested in finding charge information for.
In this loop, there is an HTTP GET action that constructs a URI from the current row of the Excel spreadsheet.
Following this is a Parse JSON action, the contents of which are used to set up another (nested) loop which iterates through all ‘charges’ listed against that company
There is then a 3rd nested loop (a loop within a loop within a loop) that iterates through ‘persons entitled’, which is an array associated with each charge.
The data is written to a SQL database using an Insert Row action.

However, during the course of testing my flow, I noticed that some of the JSON payloads were causing the flow to fail. Why? Because some charges (very old ones) registered on Companies House have no persons entitled listed. This means the JSON property ‘persons_entitled’ was completely missing. Without this, the 3rd loop, which required this property to exist, would fail.

Power Automate doesn’t have a failsafe mechanism for dealing with null entities, so we have to be a little creative.

The Solution

The solution I used was to create a condition action:

Here you can see my flow. The condition action sits directly below the loop which iterates through the list of charges in the Companies House JSON payload. Its job is to check the existence of the ‘persons_entitled’ property. If it exists, then continue with the inner most loop (IteratePersonsEntitled), if not, then effectively do nothing (I have a compose action here that simply concatinates a string; it’s merely there so something happens in the false branch).

The condition contains the following expression:

contains(items('IterateCharges'), 'persons_entitled')

The contains function inspects items from the IterateCharges loop, looking for the existence of the persons_entitled array. If this property was missing entirely from the JSON payload (for a given charge) then that array will be absent and the function will return false.

So you can see the logic. If the persons_entitled array is present, the contains function returns true. The condition expression states that if the expression = true then proceed with the actions in the true branch, else follow the false branch.

Now my flow can continue without falling over in the event of a missing property!

Other Tweaks

I had to amend the JSON schema I posted in my previous article, removing several required properties, notably ‘links’ and ‘persons_entitled’ since this was also causing my flow to fail when these were not included in the JSON payload.
Some companies queried via the API do not have any charges listed, so the API returns a 404 not found error. To handle this in Power Automate, you must configure the ‘run after’ setting for the action directly following the HTTP action:

In my flow, I have a delay action that I added to avoid the 600 queries per 5 minutes imposed by the Companies House API. Here I ticked the ‘Has failed’ option under Run After under the HTTP action.

Using Power Automate with the Companies House API

2024-02-09T00:00:00Z

A client asked whether I could investigate pulling data from Companies House using their API. This is still work in progress since ultimately the data harvested will be dumped into a database for later reporting using PowerBI. However, I thought it might be useful to document the process of using Microsoft Power Automate (my chosen tool for this task) to perform HTML GET operations via the Companies House API and parsing the subsequent JSON payload.

Step 1: Create an application & API key

Visit: this link to create an application in your Companies House ‘Developer Hub’. If you don’t have an account, you will need to register first (it’s free). You can’t use your webfiling account (if you have one).

Fill in the new application form. It’s fine to choose ‘Live’ under ‘Choose an environment for your application’. Click the application name you’ve just created. In my example, it’s called GCF:

If you can’t find this page, here’s a handy link. On the next page, there should be a green Create new key button under the heading ‘Keys for this application’

Give the key a name, a description and select REST as the API type and leave the remaining fields blank:

Then click the green Create Key button. On the next page, copy the API key. There is a ‘Copy’ link, but this didn’t work for me at the time of writing, so I had to highlight and copy the key manually:

You must now convert this key into base64 which will be used to authorise the GET request in Power Automate later.

Head over to base64encode.org

And paste your API key plus a colon (:). This is important because the API uses Basic Authentication without a password. The trailing colon is important because it adheres to the Basic Authentication standard, ensuring that the server can correctly parse the base64 encoded string and identify the username (or API key in this case) without expecting a password. Without the colon, the server might interpret the entire base64 encoded string as the username, leading to authentication errors.

Click the ENCODE button and you should end up with something that looks like this: OTExNWVjNTQtYTA5NC00MDQ2LTlmYmMtMDcwNDg4YjhkOWZmOg== Don’t try and use this key as it will be deleted by the time you read this article!

Step 2: Create a new flow in Power Automate

Note that to use HTTP GET (required for this task), you will need a premium license. In my example, I’m going to use a simple manually triggered flow to see who holds charges for a given company on Companies House. In the future I will develop this flow to iterate through a spreadsheet of companies that my client is interested in, dumping out the retrieved data into an Azure SQL database for later reporting. But for now, we’ll keep it simple.

From your Power Automate homepage create a flow, using a manual trigger. Start from a blank ‘Instant cloud flow’:

Name your flow and select ‘Manually trigger a flow’, then click Create.

Step 3: Create an HTML GET action

First, click on the ‘Manually trigger a flow’ action and in the flyout on the left, click ‘add an input’. Select Number, and type RegNo in the Number field, leaving ‘Please enter a number’ as the default. We will use this company registration number to query Companies House via their API to get the data we want:

Next, add an action in your flow by clicking the + button under the manual trigger. In the flyout, search for HTTP and select the HTTP action:

We are going to use the ‘charges’ ‘list’ API request to return a list of charges for a company:

https://developer-specs.company-information.service.gov.uk/companies-house-public-data-api/reference/charges/list

Click the newly added HTTP action in the Flow designer and paste this URL into the URI field:

https://api.company-information.service.gov.uk/company//charges

We need to supply the company registration number in our request, so click the space inbetween the forward slashes after company and before charges and select insert dynamic content:

In the pop up menu, click See More next ‘Manually trigger a flow’, then select RegNo in the list.

Select GET in the Method dropdown and type Authorization in the first Headers box where it says ‘Enter Key’. In the box next to it, type Basic then a space and then paste your base64 API key where is says ‘Enter Value’. You should end up with something like this:

Step 4: Parse JSON

Add another step directly below your HTTP action, search for and add the Parse JSON action. In the configuration box on the left, click into ‘Content’ and click the lightning bolt icon to open the dynamic picker menu. Under HTTP select Body. The JSON schema we need to provide is a little tricky since Companies House don’t provide a JSON schema and the JSON chargeList resource they give cannot be used to generate one (you can generate a schema from it, but your flow will fail!). In the end I had to run my flow with just the manual trigger and HTTP action, examine the raw output from the HTTP action (the JSON payload sent by Companies House) and use that to generate the JSON schema. Once I had the JSON output, I added the Parse JSON action back and then clicked the ‘Use sample payload to generate schema’ in the Parse JSON action properties and it gave me this:

{
    "type": "object",
    "properties": {
        "etag": {
            "type": "string"
        },
        "total_count": {
            "type": "integer"
        },
        "unfiltered_count": {
            "type": "integer"
        },
        "satisfied_count": {
            "type": "integer"
        },
        "part_satisfied_count": {
            "type": "integer"
        },
        "items": {
            "type": "array",
            "items": {
                "type": "object",
                "properties": {
                    "etag": {
                        "type": "string"
                    },
                    "charge_code": {
                        "type": "string"
                    },
                    "classification": {
                        "type": "object",
                        "properties": {
                            "type": {
                                "type": "string"
                            },
                            "description": {
                                "type": "string"
                            }
                        }
                    },
                    "charge_number": {
                        "type": "integer"
                    },
                    "status": {
                        "type": "string"
                    },
                    "delivered_on": {
                        "type": "string"
                    },
                    "created_on": {
                        "type": "string"
                    },
                    "satisfied_on": {
                        "type": "string"
                    },
                    "particulars": {
                        "type": "object",
                        "properties": {
                            "type": {
                                "type": "string"
                            },
                            "description": {
                                "type": "string"
                            },
                            "contains_floating_charge": {
                                "type": "boolean"
                            },
                            "contains_fixed_charge": {
                                "type": "boolean"
                            },
                            "floating_charge_covers_all": {
                                "type": "boolean"
                            },
                            "contains_negative_pledge": {
                                "type": "boolean"
                            }
                        }
                    },
                    "persons_entitled": {
                        "type": "array",
                        "items": {
                            "type": "object",
                            "properties": {
                                "name": {
                                    "type": "string"
                                }
                            },
                            "required": [
                                "name"
                            ]
                        }
                    },
                    "transactions": {
                        "type": "array",
                        "items": {
                            "type": "object",
                            "properties": {
                                "filing_type": {
                                    "type": "string"
                                },
                                "delivered_on": {
                                    "type": "string"
                                },
                                "links": {
                                    "type": "object",
                                    "properties": {
                                        "filing": {
                                            "type": "string"
                                        }
                                    }
                                }
                            },
                            "required": [
                                "filing_type",
                                "delivered_on",
                                "links"
                            ]
                        }
                    },
                    "links": {
                        "type": "object",
                        "properties": {
                            "self": {
                                "type": "string"
                            }
                        }
                    },
                    "more_than_four_persons_entitled": {
                        "type": "boolean"
                    }
                },
                "required": [
                    "etag",
                    "charge_code",
                    "classification",
                    "charge_number",
                    "status",
                    "delivered_on",
                    "created_on",
                    "particulars",
                    "persons_entitled",
                    "transactions",
                    "links"
                ]
            }
        }
    }
}

Your configured Parse JSON action should look like this:

Step 5: Setting up the loops

The JSON we are parsing has several nested arrays. We want to iterate through the list of charges for the company specified and then iterate through each charge to get the ‘persons entitled’. We are therefore going to have to set up two loops, one nested within the other.

Under the Parse JSON action, click the plus button and add an Apply to each action. The usual configuration box pops up from the left. First, rename the action (click on Apply to each) to Outer.

Now click in ‘Select An Output From Previous Steps’ and click the fx icon to the right. In the function box type:

outputs('Parse_JSON')?['body']?['items']

Then click Add. Your final config should look like this:

Next, click the plus button inside the grey box under the ‘Outer’ action

Add another Apply to each action and name this one Inner. Click in ‘Select An Output From Previous Steps’ and click the fx icon to the right. In the function box type:

items('Outer')?['persons_entitled']

Step 6: Create an add row to an Excel table action

Create an Excel spreadsheet in OneDrive and create a table within this spreadsheet with the following headers: Reg_no, charge_ID and Persons_entitled_name. Now in your flow, click the plus button directly below the Inner loop, search for and add the Add a row into a table (Excel) action.

In the configuration box, select your spreadsheet (you may be prompted to authenticate to OneDrive) and select your table within your spreadsheet. Under ‘Advanced parameters’, use the checkboxes to show the three headers above (Reg_no, charge_ID and Persons_entitled_name).

In ‘Reg_no’, click the lightning icon, scroll down through the picker and select RegNo under ‘Manually trigger a flow’

In ‘Charge_ID’ click the fx button and enter the following:

items('Outer')?['charge_code']

In ‘Persons_entitled_name’ click the fx button and enter:

items('Inner')?['name']

The final config should look like this for the ‘Add a row into a table’ action:

And the final flow should look like this:

Step 7: Save and run your flow!

Click the Save button. Your flow will be validated and saved. Now click Test. Select ‘Manually’, enter a valid company registration number and then click the blue Run flow button. If there are any charges for that company, the charge code will be written to the Excel table along with the ‘entitled persons’.

Further considerations

Future development of this flow will involve iterating through a list of companies my client is interested in, rather than having to manually enter a company registration number each time. Some error handling will need to be added to account for 404 ‘not found’ returns by the API and some consideration will be needed for the default API limit of 600 requests within a five minute period.

Fixing the Buffer Time Problem in Microsoft Bookings

2024-01-31T00:00:00Z

As I write this post I have just started using Microsoft Bookings. As an IT professional, having the ability for a client to visit my Bookings page and put an appointment in my diary is a great way of avoiding the usual back and forth via email to pin down a mutually convenient time. Out of the box, Bookings offers a good deal of flexibility, including the option of adding ‘buffer time’ to allow for preparation, travel between appointments, avoiding back to back appointments etc. However, as noted by many here Calendar time vs Buffer time - Microsoft Community Hub, this feature is flawed: The first appointment that was created by the system resulted in me ringing my client 30 minutes early, because the buffer time set simply extends the event in the calendar; the reminder pops up and then I must remember to ring my client 30 minutes later. The ‘time with client’ is buried in the event notes. Not great …

A workaround using Microsoft Power Automate

By leveraging Power Automate, we can create a flow that automatically adds a ‘buffer time’ event around the booking, ensuring that reminders and scheduling reflect the actual appointment times, not the buffer periods. Here’s how:

Step 1: Add the Power Automate integration to Microsoft Bookings

Turn off your buffer time for all services in Microsoft Bookings and click the Integrations button in the sidebar:

As of writing, this is the only integration offered:

then click ‘Go to Setup’:

Step 2: Create the trigger

We want our flow to trigger when a new appointment is created:

You should then be presented with Power Automate’s design grid with a sole trigger event ‘When a appointment is Created’ (spot the grammatical errors!). There will be an alarming ‘Invalid parameters’ warning. Just click it:

Using the dropdown, select the appropriate booking page. When an appointment is made using this Bookings page, it will trigger your flow automation. I only have one setup in this example.

Step 3: Calculate buffer times

In this step we are going to create two calculated variables that will define the start and end time of our buffer appointment. In my example, I am using a pre and post meeting buffer time of 30 minutes.

First, click the plus button directly below your trigger in the flow grid:

In the left hand flyout, search for ‘initialize variable’ and click it:

Under the parameters tab, enter PreMeetingBuffer under Name, use the dropdown to select String under Type and next to Value, click the fx button:

And copy and paste the following code. We are using the addMinutes function to subtract 30 minutes from the start time of the appointment that triggered the flow:

addMinutes(triggerOutputs()?['body/StartTime'], -30)

Now click Add:

You now need to add another variable, following the steps above, this time clicking the plus sign under the newly appeared ‘Initialize variable’ action. Call this new variable PostMeetingBuffer and use the following function to calculate the end of our buffer appointment:

addMinutes(triggerOutputs()?['body/EndTime'], 30)

In my example, the buffer appointment will be 30 minutes longer than the triggering event booking.

You should now have three objects in your Flow: A trigger and two variables

Step 4: Create a buffer calendar event

Click the plus sign below the last action you created (the second variable, which should be called Initialize variable 1 by default). In the flyout on the left, search for create event and add it:

Under the parameters tab, select your calendar from the dropdown (normally just called Calendar) and give it a name under Subject (I’m calling mine Booking Buffer). Click the lightning bolt symbol next to the Start Time:

And select the PreMeetingBuffer variable we created earlier:

For the End time, select the PostMeetingBuffer variable. Under advanced parameters I’ve also done the following:

Turned reminders OFF
Show as Busy (by default any event created using this action would show as available)

In the end, your flow should look like this:

Save your flow and then test it by creating a booking via your Bookings page. You should end up with something like this:

The buffer appointment won’t trigger a reminder (if you configured the advanced parameters above) but it will prevent back to back bookings (make sure you configure the ‘busy’ parameter above) and you will only receive calendar notifications for the actual events generated by your Bookings page.

I haven’t looked at creating flows for deleting or amending these automatically generated buffer events if the original booking is cancelled or amended. Something for another day!

NB: I did try the Copilot AI to help create the flow, but it wasn’t helpful, so I ended up having to use my brain! 🧠