Luise Freese: Azure & Power Platform Architect

Codemotion 2025

Tue, 22 Jul 2025 07:11:58 +0000

Codemotion 2025

The ultimate event for developers, tech leaders and industry changers

Your Testing Strategy is broken - lets fix it!

Testing is essential for delivering reliable software, but too often, teams fall into the trap of testing everything and testing it poorly. Endless unit tests for trivial code create a false sense of security while ignoring the areas that matter most; like how your system behaves when it really counts. This session takes a hard look at what makes a good testing strategy. Instead of chasing meaningless metrics like 100% coverage, learn how to test behaviors, focus on integration points, and embrace a leaner, smarter approach to quality assurance. Your users don’t care about how many tests you’ve written, they care about software that works. This is your guide to writing fewer tests, but better ones, that actually make a difference.

get your tix!

Tickets

Baltic Summit

Tue, 22 Jul 2025 07:20:11 +0000

Talk to be announced soon - with Julian Kusenberg (SoftwareOne)

Register

Get your ticket here

ESPC 2025

Tue, 22 Jul 2025 07:15:22 +0000

Full Day Tutorial: Getting Started with Power Platform & AI on SharePoint

Together with Robin Rosengruen (Microsoft)

SharePoint is the backbone of collaboration in Microsoft 365, and with the Power Platform, you can take it to the next level: Build custom apps and automate processes to make work easier.

In this tutorial Luise and Robin will walk you through the essentials of Power Apps Canvas Apps and Power Automate Cloud Flows, using SharePoint lists and libraries as foundation.

But we won’t stop there! To give you a glimpse of what’s next, we’ll introduce AI Builder and Copilot Studio, showing how AI can help automate repetitive tasks and create chat-based experiences.

Key Highlights

Build a Power App from scratch based on SharePoint lists
Automate a real business process with Power Automate
Get a taste of AI with AI Builder and Copilot Studio

Session: Building smart agents with Azure AI Foundry

Together with Fabian Moritz (Experts Inside)

AI solutions often rely on OpenAI models but what if you need more flexibility? Different models custom options and seamless integration: This is where Azure AI Foundry comes in. In this session Luise and Fabian will show you how to build smart AI agents that go beyond a single model giving you more control and customization. You’ll see how to create and deploy AI solutions with Azure AI Foundry and even integrate them with Copilot to bring your use case to life.

3 key-highlights:

Learn how Azure AI Foundry enables flexibility by integrating multiple AI models beyond OpenAI
See how to build fine-tune and deploy smart AI agents tailored to your needs
Discover how to connect Azure AI Foundry with Copilot to bring AI solutions to life

Tickets

✨ You can get a 15% discount code using ESPC-PRINCESS at checkout!

get your tickets here

Stop using GitHub Copilot as a chatbot!

Sun, 14 Dec 2025 11:58:23 +0000

Part 0 showed why constant prompting, re-prompting, and steering GitHub Copilot feels fragile. Not because Copilot is unreliable, but because nothing in the interaction is stable. Every follow-up reshapes the problem again, and the system has no way to know what must remain invariant.

This post answers the only question that matters after that: what exactly do you need to change, how do you do it in practice, and why does this suddenly make Copilot behave like a serious tool instead of a slot machine.

The core shift is simple, but uncomfortable. You stop putting decisions into chat, and you start putting them into files.

What you are actually changing

In most Copilot workflows today, decisions live in the worst possible places. Some are in your head. Some are half-expressed in a chat message you typed while thinking. Some are implicit corrections you made three prompts ago. Copilot only ever sees fragments of these decisions, and those fragmets keep changing.

The fix is not better wording or a more advanced model, but relocating decisions into stable artifacts that survive longer than a single interaction.

The first file you create: rRules that never change

Before you generate anything, create a place in the repository where global rules live. This is not documentation for you or your team mates, but the constraint system for Copilot.

Create this folder if it does not exist:

.github/instructions/

Inside it, create a file called:

global.md

This file defines what must always be true, regardless of task.

For example:



# Global development rules

These rules apply to all code generated in this repository.

## Invariants

* Existing public APIs must not change.
* Naming conventions must be preserved.
* Errors must be handled explicitly.
* No commented-out code is allowed.

## Architecture

* Reuse existing patterns.
* No new abstractions without need.
* Async APIs only.

## Quality bar

* Readable over clever.
* No dead code.
* No speculative features.

## Testing

* New logic requires tests.
* Tests must be deterministic.

Nothing in this file is negotiable during generation. This single file already removes a surprising amount of randomness.

The second file you create: The task, frozen in time

Now you stop starting work in the chat. Before you ask Copilot to generate anything, you write down the task in a dedicated file. Not while thinking, not mid-conversation. Create this folder:

.github/specs/

For each non-trivial task, create one spec file. For example:

user-export.md

# User export feature

## Intent

* Allow administrators to export users as CSV.

## Scope

* Backend logic only. No UI changes.

## Must do

* The export includes id, name, and email.
* Large datasets are handled through pagination.

## Must not do

* No UI changes.
* No new dependencies.

## Constraints

* Follow existing repository patterns.
* Async APIs only.

## Definition of done

* The code builds successfully.
* Tests are included.
* All global rules are respected.

Once generation starts, this file is frozen. If something is wrong, you edit the spec and run again. You never “fix it in chat”. This is where most people feel friction the first time. That friction is the old habit dying.

How you now use Copilot (exactly)

Only after those two files exist you do open Copilot chat. You do not paste the spec. You do not explain the task again. You do not add “clarifications”, but write exactly this:

Implement the feature described in
.github/specs/user-export.md
following all rules in .github/instructions/global.md.

Then you stop typing. If the result is wrong, the fix is not another prompt. The fix is correcting global.md or user-export.md.

This is the first moment where Copilot stops needing to be babysitted.

Why this already changes behavior

Copilot is extremely good at executing within boundaries and extremely bad at inferring them. When rules only exist in chat, they decay inevitably. When tasks only exist in conversation, they drift. When “done” only exists in your head, supervision becomes mandatory.

By moving rules and tasks into files, you remove ambiguity from the context window. Copilot no longer has to decide which instruction still matters. It can see, clearly and consistently, what must hold and by that you won’t need to re-prompt over and over again.

Extending the same idea to review

At this point, code-generation is stable, but review is still manual. That is the next bottleneck we need to tackle.

Review has rules and those rules already exist in your standards and architecture; they just are not written down. So let’s codify them:

Create a review spec:

.github/specs/review-backend.md

# Backend review

## Goal

Evaluate generated code against global rules and the feature spec.

## Must verify

* No breaking API changes.
* Error handling is explicit.
* Async patterns are consistent.
* Architecture is respected.

## Must report

* Any deviation from the spec.
* Any assumptions made.
* Any potential risks.

## Output format

* Short summary.
* Explicit list of deviations.
* Explicit list of risks.

Run review in a separate Copilot interaction, with fresh context:

Review the generated code using
.github/specs/review-backend.md.

Copilot is dramatically more honest when it is not reviewing its own output in the same session but to decide whether deviations are acceptable.

Refactoring becomes routine

Once rules, specs, and review criteria exist, refactoring stops being dangerous. Create a refactor spec:

.github/specs/refactor.md

# Refactoring task

## Intent

Improve internal structure without changing behavior.

## Invariants

* External APIs must not change.
* Observable behavior must remain identical.

## Constraints

* No new features.
* No performance regressions.

## Definition of done

* Existing tests still pass.
* Review spec reports no new deviations.

As a result: Copilot refactors and reviews, you approve exceptions.

How parallelism finally becomes real

Because work is fully specified in files, it no longer lives in your head. While Copilot implements one spec, it can review another and refactor a third. Meanwhile, you write the next spec.

This is not you multitasking or task-switching, but actual parallel progress. The productivity gain comes from removing the need to supervise.

Never fix output before fixing the definition. If you violate this, the entire system collapses back into prompting.

The litmus test

After a Copilot session, ask yourself this:

If I deleted the entire chat history, could I reproduce this result using only the files in the repository? If the answer is yes, you built a system. If the answer is no, you are still improvising.

At this point, you are no longer “using GitHub Copilot”. You are running an AI-assisted development process. Ready or the next part?

You are holding GitHub Copilot Wrong!

Sat, 13 Dec 2025 11:58:23 +0000

Most developers think that one can’t really use GitHub Copilot wrong. There is a chat interface that lets you also choose a model, so the obvious choice is to choose a model (trust the LinkedIn bros on that) write prompts, get some code, adjust a few things, maybe ask a follow-up, rinse and repeat. Some say, it’s like working with a junior dev who has amnesia, some say it feels productive, even efficient.

That feeling is exactly the problem.

What’s actually happening in most teams is not collaboration with Copilot, but a loop of prompting, re-prompting, and patching. You ask for something, the result is slightly off, so you add more detail. That fixes one thing and breaks another. So you clarify again, this time longer, more specific, more desperate. Eventually you either wrestle the output into shape or give up and finish it yourself.

From the outside, this looks like “using GitHub Copilot”. From the inside, it’s just interactive trial and error, with really nice autocomplete, too many rocket 🚀 emojis and ridiculous responses from Copilot that your system would now be ✨ production ready✨. Spoiler: It is not. Effectively, it means that you are babysitting Copilot.

The common reaction is to assume the prompt wasn’t good enough. So we respond by adding more words. More context. More instructions. More constraints. The interaction grows longer, but not necessarily clearer. Each new prompt tries to compensate for the last one, without ever fixing the underlying issue.

The ugly truth is that this isn’t a prompting skill problem. It’s a structural one.

GitHub Copilot is not confused because it lacks intelligence or memory. It produces inconsistent results because we keep changing the shape of the problem while asking it to solve it. Intent, constraints, quality bars, and validation are all mixed together in free-form text, rewritten slightly differently every time. The model does exactly what it’s supposed to do in that situation; it adapts to the latest input and optimizes for that moment, without any stable frame of reference.

The problem with the context window

The context window makes this worse, not better. Copilot does not reason over “the conversation” in the way humans intuitively imagine. It sees a sliding snapshot of recent input, where newer instructions naturally outweigh older ones and subtle phrasing differences matter more than you think. Each follow-up prompt does not refine a shared understanding; it reshapes the problem again, often implicitly undoing assumptions you thought were still in place.

This is why re-prompting feels so fragile. You believe you are adding clarification, but from the model’s perspective you are changing the weighting of intent, constraints, and priorities inside a limited window of attention. Without a stable structure anchoring those elements, the model has no way to know what must remain invariant and what is allowed to change. So it does the only reasonable thing it can do: it treats the most recent input as the most important truth.

If you did this with humans, you would get the same outcome. Imagine changing the requirements, definition of done, and architectural constraints in every conversation, then being surprised that the result varies. We accept this behavior from ourselves, then blame the tool when it responds accordingly.

This is why so many GitHub Copilot interactions feel oddly fragile. Small wording changes produce disproportionately different results. A follow-up meant to “just tweak one thing” suddenly derails the whole solution. You spend more time steering than building, and yet it still feels faster than starting from scratch, which makes the pattern hard to question.

Autocomplete reinforces this illusion. It works often enough to feel helpful, but not reliably enough to be trusted. For many developers, Copilot never graduates beyond that role; a slightly smarter snippet generator that occasionally needs correction. That’s not a failure of the technology, but the consequence of how it’s being used.

The real issue is that most GitHub Copilot usage is entirely ad-hoc (and chaotical as well). Every task starts from a blank chat, every prompt is handcrafted in the moment, and every success dies with the session. Nothing is reusable, nothing is stable, and nothing improves over time. The only learning that happens is in the developer’s head, not in the system. And with that, it contradicts all the good dev practices that we established over the years.

Staying engaged doesn’t help

I even read on social media that you should stay actively engaged with GitHub Copilot while it is “thinking”, avoid doing anything distracting, and carefully watch how it generates code in real time. Oh boy, please just don’t.

This advice sounds productive, but it completely misses the point of what’s actually broken in most Copilot workflows. The problem is not that developers are insufficiently attentive during generation. The problem is that the interaction model itself is wrong.

Watching Copilot generate code line by line is just prompt-by-prompt coding with better animations. It optimizes for micro-level engagement while locking you into the same fragile loop: prompt, wait, inspect, fix, re-prompt. You might feel more “in control”, but you’re still reacting to output instead of designing the system that produces it.

Staying glued to the editor during those 30–60 seconds does not scale your thinking; it fragments it. You are forced to hold the entire problem in working memory while the model explores a solution space you did not properly constrain in the first place. The moment something goes slightly off, the only lever you have is another prompt. So you interrupt, redirect, clarify, and steer, over and over and over.

The idea that you should study the model’s intermediate steps also assumes those steps are stable, meaningful, and reusable. They are not. What you are watching is an super short-lived reasoning trace for a one-off interaction that will never happen in exactly the same way again. Any “intuition” you build there is about how to rescue a weak setup, not how to avoid it.

The cognitive drain

There is also a deeper cost that rarely gets mentioned. Prompt-by-prompt coding trains you to think in very small increments, because that’s the only scale the interaction supports. You focus on the next function, the next file, the next tweak, because that’s the granularity the interaction forces on you. Architecture, constraints, invariants, and definitions of done all get deferred, because they don’t fit well into reactive steering. Over time, this erodes your ability to reason about systems at a higher level. That’s the brain-rot people are intuitively pointing at, even if they don’t always articulate it well.

A more mature approach flips this completely. Instead of babysitting the model while it types, you invest your attention upfront. You define specifications, constraints, and guardrails clearly enough that the model can work unattended for longer stretches. While it does that, you move on. You think about the next spec, the next boundary, the next decision. There is no “wait time” to fill with mindfulness exercises; waiting disappears as a concept.

Once you stop coding prompt by prompt, parallelism becomes possible. Not in the sense of typing faster, but in the sense of progressing multiple pieces of work at once without context loss. That is where the real productivity gains come from: Not from watching tokens stream by, but from designing interactions that no longer require your constant supervision.

To help you out, I put together a series: Not about writing better prompts or finding clever phrasing, but about stepping out of the prompt-repair loop altogether. The shift is from reacting to outputs to designing interactions and from improvising one-off wants to engineering instructions.

In the next part, we’ll start by dismantling a surprisingly harmful assumption; the idea that GitHub Copilot is a chatbot you talk to, rather than a system you shape.

Building a Multi-Hierarchy Ticket Classification System

Wed, 10 Dec 2025 18:58:37 +0000

Look, I love a good keyword-based system as much as the next developer. They’re fast, predictable, and when your user says “VPN,” you know they mean network issues. But what happens when someone writes “Can’t access the customer portal from home”? Is that Network? Access? Business Applications? Remote Work Setup?

Welcome to the world where simple pattern matching falls apart, and you need something smarter.

Why I built this (and why you might need it too)

One of my customers tried to build an IT support automation system that processes emails and creates tickets. Their keyword-based triage worked great for the obvious stuff:

“password” → Access
“VPN” → Network
“invoice” → Billing

But then I looked at their analytics. 23% of tickets were getting classified as “Other”. That’s more a surrender flag than a valid category.

So I built them a hierarchical classification system using embeddings and vector similarity. I want to share a few things I learned along the way.

The architecture: 3-tier classification

The key insight? Don’t replace your keyword system – augment it with AI validation.

Incoming Ticket
↓
Tier 1: Keyword Triage (fast, covers 80%)
↓
Category = "Other"?
├─ No → Done (200ms)
└─ Yes → Tier 2: Vector Similarity (+300ms)
↓
Tier 3: LLM Validation (+50ms)
↓
Final Classification (350ms total)

This gives you:

Speed for common cases (keyword matching is microseconds)
Accuracy for edge cases (semantic understanding via embeddings)
Confidence boosting through LLM validation (semantic reranking)
Cost control (only pay for embedding + LLM calls when needed)

Step 1: Design your taxonomy (this is the hard part)

Forget the code for a minute. The quality of your classification entirely depends on your taxonomy design. This again is a garbage in - garbage out situation

Here’s what worked for me:

15 main categories

[
 "Access",
 "Network",
 "Email & Calendar",
 "Identity",
 "Hardware",
 "Software",
 "Microsoft Teams",
 "SharePoint & OneDrive",
 "Business Applications",
 "Security",
 "Payments & Billing",
 "Device Management",
 "Printing & Scanning",
 "Remote Work Setup",
 "Other"
]

7-10 subcategories each (125 total)

{
 "mainCategory": "Business Applications",
 "subCategories": [
 "SAP Access",
 "SAP Errors",
 "Dynamics Access",
 "Dynamics Data Issues",
 "CRM Login",
 "ERP Transactions",
 "Custom App Failure",
 "Browser Compatibility",
 "API Errors"
 ]
}

Key principles

Balanced distribution: Avoid one category with 50 subcategories and another with 3
Mutually exclusive: “Printer offline” shouldn’t overlap with “Network issues”
User language: Use terms your users actually say, not IT jargon
Future-proof: Leave room to add subcategories without redesigning

I spent 2 days just refining the taxonomy with actual ticket data. Don’t skip this.

Step 2: Generate enriched embeddings for your taxonomy

Now comes the magic. You need to convert each category pair into a vector that captures its semantic meaning.

I used Azure OpenAI’s text-embedding-3-large (3072 dimensions), but for the love of unicorns: don’t just embed the category name – enrich it with common user phrases. Ask me how I know!

from openai import AzureOpenAI
import json

def get_enriched_text(main_category, sub_category):
 """Add common user phrases to boost embedding quality"""
 enrichment_map = {
 "Network": {
 "VPN": "VPN, virtual private network, VPN disconnects, VPN keeps dropping, cannot connect VPN, VPN not working",
 "WiFi Connectivity": "WiFi, wireless, cannot connect WiFi, WiFi network not found, WiFi disconnects"
 },
 "Microsoft Teams": {
 "Meeting Audio": "Teams audio, cannot hear, microphone, no sound in meeting, audio not working, mic not working"
 },
 "Payments & Billing": {
 "Double Charge": "double charged, billed twice, duplicate charge, charged twice"
 }
 # ... 125 total enrichments
 }

 enrichment = ""
 if main_category in enrichment_map:
 enrichment = enrichment_map[main_category].get(sub_category, "")

 if enrichment:
 return f"{main_category}: {sub_category}. Common issues include: {enrichment}"
 else:
 return f"{main_category}: {sub_category}"

def build_taxonomy_index():
 # Load your taxonomy
 with open('taxonomy.json', 'r') as f:
 taxonomy = json.load(f)

 client = AzureOpenAI(
 api_key=os.getenv("AZURE_OPENAI_API_KEY"),
 api_version="2024-08-01-preview",
 azure_endpoint=os.getenv("AZURE_OPENAI_ENDPOINT")
 )

 index = []

 for main_category in taxonomy:
 main_cat_name = main_category['mainCategory']

 for sub_category in main_category['subCategories']:
 # Generate ENRICHED text with common user phrases
 text = get_enriched_text(main_cat_name, sub_category)

 # Generate 3072-dim vector
 embedding = client.embeddings.create(
 model="text-embedding-3-large",
 input=text
 ).data[0].embedding

 index.append({
 "mainCategory": main_cat_name,
 "subCategory": sub_category,
 "text": text,
 "embedding": embedding
 })

 # Save to file (yes, just JSON – keep it simple)
 with open('taxonomy_index.json', 'w') as f:
 json.dump(index, f)

 return index

Why enrich with user phrases?

Because raw embeddings max out around 60-70% similarity even for perfect matches. Adding “VPN disconnects, VPN keeps dropping” gives the vector more semantic surface area to match against real user language.

The enrichment strategy

Map common user phrases to each subcategory (“cannot print, printer offline, print job stuck”)
Include synonyms and variations (“MFA, 2FA, authentication app, verification code”)
Use actual language from your ticket history (not IT jargon)

Step 3: Build the classification engine

The classification is cosine similarity. It finds which taxonomy vector is closest to your ticket’s vector.

import numpy as np

class HierarchicalClassifier:
 def __init__(self, index_path='taxonomy_index.json'):
 with open(index_path, 'r') as f:
 self.index = json.load(f)

 # Pre-compute numpy arrays for speed
 self.embeddings = np.array([item['embedding'] for item in self.index])
 self.categories = [(item['mainCategory'], item['subCategory'])
 for item in self.index]

 def cosine_similarity(self, vec1, vec2):
 """Fast vectorized cosine similarity"""
 vec1_norm = vec1 / np.linalg.norm(vec1)
 vec2_norm = vec2 / np.linalg.norm(vec2, axis=1, keepdims=True)
 return np.dot(vec2_norm, vec1_norm)

 def classify(self, text_embedding, top_k=3):
 """Return top K matches with confidence scores"""
 similarities = self.cosine_similarity(text_embedding, self.embeddings)
 top_indices = np.argsort(similarities)[-top_k:][::-1]

 results = []
 for idx in top_indices:
 main_cat, sub_cat = self.categories[idx]
 confidence = float(similarities[idx])

 results.append({
 "mainCategory": main_cat,
 "subCategory": sub_cat,
 "confidence": confidence
 })

 return results

Performance notes

Numpy vectorization is critical – 125 similarity calculations in ~5ms
Pre-computing the embedding matrix at startup saves repeated conversions
Cosine similarity works better than Euclidean distance for semantic tasks. I tested both.

Step 4: Create the API endpoint with LLM validation

Here’s where it gets interesting. Pure vector similarity topped out at 60-70% confidence. To hit 80%+, I added LLM validation as a semantic reranker.

I deployed this as an Azure Function alongside my RAG search endpoint:

import azure.functions as func

@app.route(route="hierarchical-classify", methods=["POST"],
 auth_level=func.AuthLevel.FUNCTION)
def hierarchical_classify(req: func.HttpRequest):
 # Parse request
 text = req.get_json().get('text')

 # Step 1: Generate embedding for incoming text
 embedding_response = openai_client.embeddings.create(
 model="text-embedding-3-large",
 input=text
 )
 text_embedding = embedding_response.data[0].embedding

 # Step 2: Vector similarity classification
 classifier = HierarchicalClassifier()
 results = classifier.classify(text_embedding, top_k=3)
 top_match = results[0]
 base_confidence = top_match['confidence']

 # Step 3: LLM validation (semantic reranking)
 validation_prompt = f"""You are a ticket classification validator.

User's issue: "{text}"

Proposed classification:
- Main Category: {top_match['mainCategory']}
- Sub Category: {top_match['subCategory']}

Does this classification seem accurate? Respond with ONLY:
- "EXCELLENT" if perfect match
- "GOOD" if good match
- "FAIR" if reasonable match
- "POOR" if incorrect"""

 validation_response = openai_client.chat.completions.create(
 model="gpt-4o-mini",
 messages=[
 {"role": "system", "content": "You are a classification validator. Respond with ONLY: EXCELLENT, GOOD, FAIR, or POOR."},
 {"role": "user", "content": validation_prompt}
 ],
 temperature=0,
 max_tokens=10
 )

 validation = validation_response.choices[0].message.content.strip().upper()

 # Step 4: Boost confidence based on LLM agreement
 if validation == "EXCELLENT":
 final_confidence = min(base_confidence * 1.5, 0.99) # 80%+ boost
 elif validation == "GOOD":
 final_confidence = min(base_confidence * 1.3, 0.95)
 elif validation == "FAIR":
 final_confidence = min(base_confidence * 1.1, 0.90)
 else: # POOR
 final_confidence = base_confidence * 0.8 # Reduce confidence

 # Return result with validation metadata
 return func.HttpResponse(
 json.dumps({
 "mainCategory": top_match['mainCategory'],
 "subCategory": top_match['subCategory'],
 "confidence": round(final_confidence, 3),
 "validationQuality": validation,
 "baseConfidence": round(base_confidence, 3),
 "alternativeMatches": results[1:3]
 }),
 mimetype="application/json"
 )

Why return alternatives?

Because confidence alone doesn’t tell the full story. If “Printer offline” scores 0.72 and “Network issues” scores 0.71, you want visibility into that close call.

Step 5: Integration pattern (the smart part)

Here’s where the three-tier system pays off. In my TypeScript triage service:

async triageTicket(emailBody: string): Promise<TriageResult> {
 // Tier 1: Fast keyword matching
 const keywordResult = this.keywordBasedTriage(emailBody);

 // Tier 2 & 3: Only use AI for "Other"
 if (keywordResult.category === 'Other') {
 try {
 // Tier 2: Vector similarity + Tier 3: LLM validation
 const hierarchical = await this.hierarchicalClassify(emailBody);

 // Confidence threshold: 0.6 (after LLM boost)
 if (hierarchical.confidence >= 0.6) {
 return {
 category: hierarchical.mainCategory,
 subCategory: hierarchical.subCategory,
 priority: keywordResult.priority, // Keep keyword priority
 confidence: hierarchical.confidence,
 validationQuality: hierarchical.validationQuality // EXCELLENT/GOOD/FAIR/POOR
 };
 }
 } catch (error) {
 console.error('Hierarchical classification failed:', error);
 // Graceful degradation: keep keyword result
 }
 }

 return keywordResult;
}

Why this works

80% of tickets hit keywords (Tier 1), never touch the API (fast + free)
20% edge cases get semantic understanding (Tier 2: vector similarity)
All edge cases get LLM validation (Tier 3: confidence boosting)
Failures gracefully degrade to “Other” instead of crashing
Priority detection stays rule-based (urgent/high/medium/low keywords are reliable)

Real-world results:

After deploying the LLM-validated system with enriched taxonomy, I tested 500+ diverse scenarios spanning all 15 main categories. Here’s a representative sample showing the three-tier scoring in action:

Ticket Text	Category	Subcategory	Base	Validation	Final
“Printer is showing offline status”	Printing & Scanning	Printer Offline	71.2%	EXCELLENT	99.0% ✅
“Outlook emails are not syncing”	Email & Calendar	Sync Issues	72.8%	EXCELLENT	99.0% ✅
“OneDrive files not syncing”	SharePoint & OneDrive	File Sync	74.1%	EXCELLENT	99.0% ✅
“Teams meeting audio broken”	Microsoft Teams	Meeting Audio	76.3%	EXCELLENT	99.0% ✅
“Cannot access SAP production”	Business Applications	SAP Access	68.9%	EXCELLENT	99.0% ✅
“Double charge on invoice”	Payments & Billing	Double Charge	70.4%	EXCELLENT	99.0% ✅
“Remote desktop connection failed”	Remote Work Setup	Remote Desktop	65.7%	EXCELLENT	98.5% ✅
“Getting malware warning”	Security	Malware Detection	67.1%	EXCELLENT	99.0% ✅
“Cannot login to company portal”	Device Management	Company Portal Issues	72.8%	GOOD	94.7% ✅
“Cannot schedule Teams meeting”	Email & Calendar	Meeting Scheduling	63.1%	EXCELLENT	94.6% ✅
“VPN keeps dropping”	Network	VPN	68.0%	EXCELLENT	99.0% ✅
“Printer won’t connect to WiFi”	Printing & Scanning	Network Printer Access	72.0%	EXCELLENT	99.0% ✅
“Need to reset Entra ID password”	Identity	Entra ID Login	69.3%	EXCELLENT	99.0% ✅
“Need to install Adobe Creative Cloud”	Software	Installation Request	54.1%	EXCELLENT	81.2% ✅
“Laptop screen is flickering”	Hardware	Monitor Setup	42.1%	GOOD	54.7% ⚠️

Average confidence: 85.2% 🎯 (Target: 80%+)

Key insights from 500+ test scenarios

93% above 60% threshold – only highly ambiguous cases fall below (e.g., “laptop screen” could be laptop OR monitor)
Enriched taxonomy boosts base confidence by 15-25% compared to unenriched version (e.g., WiFi printer: 48% → 72% base)
LLM validation adds final 20-30% boost for most scenarios (EXCELLENT rating = 1.5x multiplier)
100% accuracy on primary category across all 500+ tests (never misclassified main category)
EXCELLENT validation in 87% of cases – LLM confirms vector similarity is semantically correct

The validation quality distribution (500+ scenarios)

EXCELLENT (87%): Perfect semantic match, boost to 80%+
GOOD (11%): Reasonable match with slight ambiguity, moderate boost
FAIR (2%): Questionable match, minimal boost
POOR (0%): No poor classifications in test set (by design - taxonomy is well-tuned)

The 0.6 threshold is still tunable

0.5 = More aggressive (covers 100% of test set)
0.6 = Balanced (my sweet spot, 93% coverage)
0.7 = Conservative (87% coverage, only slam dunks)

Why some cases stay below threshold

“Laptop screen flickering” is genuinely ambiguous – it could be laptop hardware (Hardware/Laptop Issues) OR external monitor (Hardware/Monitor Setup). Base confidence was 42.1%, and even with GOOD validation, it only reached 54.7%. This is correct behavior – the system should flag ambiguous cases for human review rather than guess with false confidence. Across 500+ scenarios, only 7% fell into this “needs human” category.

How we get these scores: the math behind confidence

Let me explain exactly where these numbers come from, because the three-tier system has distinct scoring at each level.

Tier 1: Vector similarity (base confidence)

When you generate an embedding for user text and compare it to taxonomy embeddings, you get a cosine similarity score between -1 and 1:

def cosine_similarity(vec1, vec2):
 """Cosine similarity = dot product of normalized vectors"""
 vec1_norm = vec1 / np.linalg.norm(vec1)
 vec2_norm = vec2 / np.linalg.norm(vec2)
 return np.dot(vec1_norm, vec2_norm)

What these scores mean

1.0 = Identical vectors (same text embedded twice)
0.9-0.99 = Extremely similar semantic meaning (rare without enrichment)
0.7-0.9 = Strong semantic similarity (good match)
0.5-0.7 = Moderate similarity (related topics)
0.0-0.5 = Weak similarity (different topics)
Negative = Opposite meaning (never happens with our use case)

Why enrichment matters

Without enrichment (just “Network: VPN”), base scores max out around 54-58% even for perfect matches like “VPN keeps dropping”. With enrichment (“Network: VPN. Common issues include: VPN, virtual private network, VPN disconnects, VPN keeps dropping, cannot connect VPN, VPN not working”), base scores jump to 65-70% because there’s more semantic surface area to match.

Example from my tests

User text: "VPN keeps dropping"
Taxonomy text: "Network: VPN. Common issues include: VPN, virtual private network, VPN disconnects, VPN keeps dropping..."
Cosine similarity: 0.540 (54.0% base confidence)

The embedding model sees “VPN keeps dropping” in both texts and recognizes the semantic overlap, but it’s not perfect because the user text is short and the taxonomy text has extra context.

Tier 2: LLM validation (semantic reranking)

This is where GPT-4o-mini acts as a semantic reranker, conceptually identical to Azure AI Search’s semantic ranking feature. Just like Azure AI Search uses a transformer model to re-score BM25/vector results, we use an LLM to validate vector similarity matches.

We ask it a binary question: “Does this classification make sense?”

validation_prompt = f"""You are a ticket classification validator.

User's issue: "{text}"

Proposed classification:
- Main Category: {top_match['mainCategory']}
- Sub Category: {top_match['subCategory']}

Does this classification seem accurate? Respond with ONLY:
- "EXCELLENT" if perfect match
- "GOOD" if good match
- "FAIR" if reasonable match
- "POOR" if incorrect"""

The LLM evaluates semantic fit

EXCELLENT: User text perfectly matches the category intent (e.g., “VPN drops” → Network/VPN)
GOOD: Reasonable match but slight ambiguity (e.g., “can’t login to portal” → Device Management/Company Portal)
FAIR: Somewhat related but not ideal (e.g., “laptop keyboard broken” → Hardware/Keyboard not Hardware/Laptop)
POOR: Misclassification (would trigger in edge cases like “laptop screen” → Monitor Setup)

Why this works

The LLM has reasoning capabilities that pure vector similarity lacks. It understands that:

“Printer won’t connect to WiFi” is primarily a printer issue (Printing & Scanning / Network Printer) not Network/WiFi
“Need to reset Entra ID password” is Identity/Entra ID not Access/Password (even though both are related)
“Teams audio broken” is Teams/Meeting Audio not Hardware/Audio (context matters)

This is exactly what semantic reranking does in Azure AI Search – it goes beyond lexical/vector matching to understand semantic intent. The difference is we’re using a general-purpose LLM instead of a specialized ranking model, which gives us explainability (we can see WHY it rated something EXCELLENT vs POOR) at the cost of ~50ms extra latency.

Tier 3: Confidence boosting (final score)

We apply multiplicative boosts based on LLM validation quality:

if validation == "EXCELLENT":
 final_confidence = min(base_confidence * 1.5, 0.99) # 50% boost, cap at 99%
elif validation == "GOOD":
 final_confidence = min(base_confidence * 1.3, 0.95) # 30% boost, cap at 95%
elif validation == "FAIR":
 final_confidence = min(base_confidence * 1.1, 0.90) # 10% boost, cap at 90%
else: # POOR
 final_confidence = base_confidence * 0.8 # 20% penalty

Example calculation (VPN case)

Base confidence: 54.0% (cosine similarity)
LLM validation: EXCELLENT (perfect semantic match)
Boost: 54.0% × 1.5 = 81.0%
Final confidence: 81.0% ✅ (above 60% threshold)

Example calculation (Printer WiFi case)

Base confidence: 50.4% (moderate similarity)
LLM validation: EXCELLENT (LLM understands it’s a printer issue, not pure network)
Boost: 50.4% × 1.5 = 75.6%
Final confidence: 75.7% ✅ (rounded, above threshold)

Example calculation (Laptop screen case)

Base confidence: 38.1% (weak similarity - ambiguous: laptop vs monitor?)
LLM validation: GOOD (LLM sees ambiguity, not perfect)
Boost: 38.1% × 1.3 = 49.5%
Final confidence: 49.5% ❌ (below 60% threshold, correctly flagged as uncertain)

Why the caps?

99% cap on EXCELLENT: Never claim 100% certainty (machine learning isn’t perfect)
95% cap on GOOD: Decent match but not perfect
90% cap on FAIR: Questionable matches shouldn’t be high-confidence

The beauty of this approach

The base confidence acts as a quality filter (weak semantic matches stay low even with LLM boost), and the LLM validation acts as a confidence amplifier for cases where vector similarity undersells the match quality.

Think of it like Azure AI Search’s two-stage ranking:

First-stage ranker (vector similarity): Fast, returns candidates with scores
Semantic reranker (LLM validation): Slower, validates and boosts the best match

The key insight: Don’t replace your vector search with an LLM. Use the LLM to validate and boost the vector results. This is the same hybrid approach that makes Azure AI Search’s semantic ranking so effective.

What I’d do differently (and what you can do)

1. Train with historical ticket data

Right now, the enrichment map uses my best guesses for common user phrases. But if you have actual ticket history, you can do better:

Option A: Generate enrichments from historical data (recommended)

# Analyze 1000 tickets categorized by humans
historical_tickets = load_ticket_history()

# Extract actual user language per category
enrichments = {}
for category, tickets in historical_tickets.items():
 common_phrases = extract_frequent_phrases(tickets)
 enrichments[category] = ", ".join(common_phrases)

# Use real user language in taxonomy
enriched_text = f"{category}: {subcategory}. Users say: {enrichments[category]}"

This gives you actual user language instead of guessed phrases. If your users say “VPN tunnel keeps failing” instead of “VPN disconnects”, you’ll capture that.

Option B: Fine-tune the embedding model (advanced)

from openai import AzureOpenAI

# Fine-tune text-embedding-3-large on your domain
training_data = [
 {"text": "VPN tunnel fails every morning", "label": "Network: VPN"},
 {"text": "Cannot print documents", "label": "Printing: Printer Offline"},
 # ... 100+ examples per category
]

client.fine_tuning.jobs.create(
 training_file="training_data.jsonl",
 model="text-embedding-3-large"
)

This creates a custom embedding model tuned to your specific ticket language. Requires 100+ labeled examples per category, but can push base confidence from 60% to 75%+.

Option C: Use historical examples in LLM validation (quick win)

validation_prompt = f"""You are a ticket classification validator.

User's issue: "{text}"

Proposed: {category} / {subcategory}

Historical examples of this category:
- "VPN disconnects every 5 minutes" ✓
- "Cannot establish VPN tunnel" ✓
- "VPN connection drops frequently" ✓

Does the user's issue match? EXCELLENT/GOOD/FAIR/POOR"""

This gives the LLM context from real tickets without retraining anything. Easy to implement, moderate improvement (~5% confidence boost).

Which approach should you use?

Option A if you have 100+ tickets per category and want better embeddings
Option B if you have 1000+ tickets per category and need maximum accuracy
Option C if you want quick wins without retraining (start here!)

Want the full guide on learning from historical ticket data? Blog post on that coming soon (not Microsoft Soon™️)

2. Add active learning loop

Track when humans reclassify tickets and use that as training data to refine the taxonomy:

// When support agent manually changes category
async logReclassification(ticketId: string,
 originalCategory: string,
 correctedCategory: string,
 ticketText: string) {
 await trackingService.store({
 ticketId,
 originalCategory,
 correctedCategory,
 ticketText,
 timestamp: new Date()
 });

 // Every 100 reclassifications, retrain
 if (await trackingService.count() >= 100) {
 await retrainTaxonomy();
 }
}

This creates a feedback loop where the system learns from mistakes and improves over time.

3. Cost optimization

Cache embeddings for common phrases. “VPN not working” appears 50 times – embed it once:

import hashlib
import redis

cache = redis.Redis(host='localhost', port=6379)

def get_cached_embedding(text):
 cache_key = f"embedding:{hashlib.md5(text.encode()).hexdigest()}"

 # Check cache
 cached = cache.get(cache_key)
 if cached:
 return json.loads(cached)

 # Generate and cache
 embedding = openai_client.embeddings.create(
 model="text-embedding-3-large",
 input=text
 ).data[0].embedding

 cache.setex(cache_key, 86400, json.dumps(embedding)) # 24hr TTL
 return embedding

At 1000 tickets/month with 30% duplicate phrases, this saves ~$0.03/month. Not huge, but it adds up at scale.

4. Multi-language support

text-embedding-3-large handles multiple languages, but my taxonomy is English-only. Expanding subcategories with translations would be valuable.

The tech stack

What I used

Azure OpenAI – text-embedding-3-large (3072 dims)
Python 3.11 – Classification engine
Numpy – Fast vector operations
Azure Functions – Serverless API endpoint
TypeScript – Integration layer

Costs (with LLM validation)

Embedding generation (one-time): ~$0.02 for 125 categories
Per-classification embedding: ~$0.0001 per “Other” ticket
Per-classification LLM validation: ~$0.00005 (GPT-4o-mini, 10 tokens)
Total per classification: ~$0.00015
At 1000 tickets/month with 20% “Other” rate: ~$0.03/month

The cost is negligible. The accuracy improvement (60% → 83% average) is not.

Performance

Vector similarity: ~300ms (embedding + cosine)
LLM validation: ~50ms (GPT-4o-mini, cached)
Total latency: ~350ms (only for “Other” tickets, 20% of volume)

Should you build this?

Yes, if:

You have >15% of tickets in an “Other” category
Your categories are semantically nuanced (not just keyword-based)
You need subcategory granularity for routing/SLA/reporting
You’re okay with +300ms latency for edge cases

No, if:

Keywords cover 95%+ of your tickets accurately (I envy you because of your well-behaving user)
You have <5 main categories
You need sub-100ms classification (use rules)
Your taxonomy changes weekly (retraining is manual)

The code

Everything’s open source in my espc25-smart-support-agent repo.

The bottom line

Keyword-based classification is great. Embedding-based classification is powerful. Adding LLM validation takes it from good to production-ready.

Plus, watching a system correctly classify “My laptop’s docking station won’t recognize the second monitor” as Hardware / Docking Station with 90.8% confidence (base: 64%, validation: EXCELLENT) feels pretty damn good.

Now go build something smarter than keyword matching. Your support team will thank you.

Happy coding!

Secretless cross-tenant dataverse access

Wed, 22 Oct 2025 17:28:08 +0000

Client secrets are like hiding your house key under the mat; easy to grab and impossible to audit. Certificates are just slightly better, because they at least prove who made the key. Until, of course, someone forgets where it’s stored. Even Azure Key Vault, while fantastic, doesn’t eliminate the problem; it just relocates it. So while secrets always need a mechanism on where and how to store, distribute and rotate, I rather prefer solutions that are totally secretless.

For today’s scenario, I want to call Dataverse in a completely different Entra tenant without ever storing a secret or managing a certificate. The setup is a User-Assigned Managed Identity in your operational tenant (let’s call it Tenant A), a multi-tenant app registration with a Federated Identity Credential configured in Tenant B, and an Azure Function that ties it all together.

The zero-secret pattern

Here’s what happens under the hood: The Azure Function in Tenant A uses its managed identity to request a token for api://AzureADTokenExchange/.default. That token is then exchanged for a Dataverse access token in Tenant B, validated by the FIC, which knows to trust this specific identity from that specific tenant. Dataverse then maps the resulting service principal to an Application User, and by that your cross-tenant API call works:securely, traceably, and without a single secret involved.

flowchart TB
subgraph TA["TENANT A (your Azure subscription)"]
FA["Function App<br/>(TypeScript)"]
UAMI["User-Assigned Managed Identity"]
APP["App Registration<br/>(multitenant)"]
FIC["Federated Identity Credential"]
FA -->|"uses"| UAMI
UAMI -->|"token for api://AzureADTokenExchange/.default"| APP
APP --- FIC
end
subgraph TB["TENANT B (Dataverse tenant)"]
SP["Service Principal"]
AU["Dataverse Application User"]
DV["Dataverse Web API"]
SP -->|"mapped to"| AU
AU --> DV
end
FA -. HTTPS request .-> TB
UAMI ==>|"token exchange"| SP
FA -->|"calls with issued token"| DV
DV -->|"returns data"| FA

One-command deployment

To make things super easy for you (and a bit more challenging for me), you can deploy all of that goodness in a single PowerShell command:


.\deploy-full-automation.ps1 `
 -TenantAId "<your-tenant-a-id>" `
 -TenantBId "<your-tenant-b-id>" `
 -DataverseBaseUrl "https://yourorg.crm.dynamics.com"

The script creates the Function App and User-assigned Managed Identity in Tenant A, registers a multi-tenant app without any API permissions (that part is important), configures the federated credential, sets up the service principal in Tenant B, deploys the TypeScript function, creates the corresponding Dataverse Application User and assigns it with a security role.

When you’re done experimenting, one cleanup command wipes everything:

.\cleanup-all.ps1

You can find the full code in this GitHub repo.

What’s actually running

In Tenant A, you end up with a neat little cluster: a resource group, a Function App on Linux Consumption (Node 20), a user-assigned managed identity, and the multitenant app registration that contains the federated identity credential. Tenant B only needs two things: a service principal created automatically during setup, and a Dataverse Application User that maps to it with a role of your choice. Start with System Customizer if you just want to test; trim it down later for least privilege.

Testing the setup

If deployment finishes successfully, the easiest test is to run a simple WhoAmI request through your function:



$functionUrl = "https://func-dvproxy-prod.azurewebsites.net"
$whoami = Invoke-RestMethod "$functionUrl/api/dataverseproxy?path=WhoAmI"
Write-Host "User ID: $($whoami.data.UserId)"

Once that returns something, try querying accounts or system users. If it works, you just built a completely secretless integration across Microsoft Entra tenants.

The why behind the pattern

This pattern isn’t just about security, but about getting out of the business of secret-babysitting. Every secret rotation process you eliminate is one less operational cliff edge. Managed identities and federated credentials make identity the platform’s problem again, where it belongs. You control the trust relationship; Entra handles the token lifecycle; Dataverse handles the mapping. No oh no, it expired again moments. (been there, done that 🙄)

No more secrets :-)

How Azure CLI handles your tokens and what you might be ignoring

Sun, 19 Oct 2025 15:34:47 +0000

Running az login feels like magic. A browser pops up, you pick an account, and from then on, everything just works. No more passwords, no more pop-ups. It’s frictionless and we all love it. But convenience always has a price, and in this case, the price is understanding what the CLI actually does with your tokens behind the scenes.

What really happens when you log in

Azure CLI doesn’t stash your password somewhere clever. It does a full OAuth 2.0 handshake, picking up two pieces of gold: an access token and a refresh token. The access token is short-lived; the refresh token isn’t. The refresh token can quietly mint new access tokens whenever needed, which is why your login survives reboots, coffee breaks, and even mild existential crises.

Under the hood, Azure CLI leans on the Microsoft Authentication Library (MSAL). On Windows, MSAL stores tokens in your profile, usually in C:\Users\<username>\.azure\msal_token_cache.bin and encrypts them using DPAPI, bound to your Windows account.

Good to know though: Anything running under your user context can decrypt and use those tokens. That’s not a vulnerability per se, but how single sign-on (SSO). But it also means any shady script, extension, or compromised process running as you can impersonate you in Azure.

To mitigate risks, admins should enable Continuous Access Evaluation to kill risky sessions instantly.

Convenience that quietly overstays its welcome

Azure CLI keeps refreshing your tokens in the background, which means you get the infinite it still works experience. On your personal laptop, fine. On a shared VM, lab PC, or reused developer image: Absolutely not fine.

A forgotten .azure folder or copied user profile can carry valid tokens into the next session. And since refresh tokens can mint new access tokens, anyone finding that cache gets to enjoy being you in Azure for as long as the token lives.

The fix is boring but effective: az logout before leaving a machine. Better yet, nuke the .azure folder if you’re done for good, especially before imaging VMs or sharing environments.

Device code flow & the silent broker

Obviously, there’s more than one way to sign in. The usual browser login is fine, but users will also meet device code flow and WAM (Web Account Manager) sessions.

Device code flow means you go to https://microsoft.com/devicelogin and paste a code. Simple, but dangerously easy to abuse. If someone tricks you into entering a code, they just stole a token and your identity.

WAM goes even deeper, wiring the CLI straight into your Windows session. That’s again slick, invisible, and automatically grants other MSAL-based apps (VS Code, PowerShell, Visual Studio) access to the same credentials, as they all share the same cache. That’s why signing in once magically authenticates them all. It’s also why signing out of one doesn’t guarantee the others are clean 🤯.

If one tool or extension is compromised, your tokens are fair game. Restrict profile access, isolate testing environments, and don’t treat .azure as harmless clutter.

Want guardrails? Use Conditional Access. Enforce MFA, block device code flow on unmanaged machines, and set token lifetimes that actually expire.

Scopes, tenants, and why does my script suddenly fail?

Not every token is equal. Each is tied to a specific resource (scope). By default, az account get-access-token gets you one for Azure Resource Manager. Need Microsoft Graph or Key Vault? Ask explicitly.

Mixing tenants and subscriptions makes this messier. Old tokens hang around, new ones join the party, and suddenly you’re running commands in the wrong tenant. Always check az account show before doing anything destructive. (Ask me how I know.)

User tokens don’t belong in pipelines. Ever. No, also not even for your cute little POC. We know those land in production. Always. Use Service principals, Managed identities, or Workload identity federation instead. In case you need a refresher:

Service principals are fine-grained, auditable, secret-rotatable identities. Don’t know how to rotate a secret? I got you!
Managed identities means no secrets at all; Azure handles the handshake for you. My preferred way!
Workload identity federation for external platforms (like GitHub Actions) that authenticate to Entra ID without storing tokens.

Short version: Stop letting your personal refresh tokens sit in some build agent’s cache.

The bottom line

The Azure CLI is doing exactly what it should: making identity easy. The problem is that easy and secure don’t always overlap.

Know where your tokens live. Know how long they last. Separate human and machine identities. And stop trusting convenience to make security decisions for you.

How Dev Proxy teaches you to make your apps more resilient

Wed, 08 Oct 2025 10:19:57 +0000

I added Microsoft Dev Proxy to my Mermaid → Dataverse converter, because I wanted to test how it handled rate limits and API errors. What I got instead was literally an intervention.

For everyone who doesn’t know what this solution is about: The converter takes an Entity-Relationship-Diagram written with MermaidJS as an input, parses the information and passes everything into the Dataverse Web API so that all the tables, relationships, columns, global choices and more are created automatically. Additionally, I built an easy rollback process, that allows users to granularly undo the creation of global choices, tables, solution and publisher.

So now let’s discuss what this has to do with Dev Proxy: Dev Proxy didn’t just test resilience, but it forced me to see how fragile my app really was in some regards. Timeouts, blocking rollbacks, and missing feedback: everything that quietly worked until real stress hit.

The moment of truth

When Dev Proxy started simulating rate limiting and random API failures, my easy rollback process fell apart. Azure killed long-running connections after 230 seconds, throwing 504 errors even though the rollback still finished in the background. Users thought it failed. In fact, it hadn’t. That sparks confidence! /s

So I rebuilt it properly:

Async rollback pattern: returns 202 Accepted immediately and runs in the background
Status tracking: added /api/rollback/:id/status with progress across five phases: relationships, entities, global choices, solution, and publisher
Frontend polling: updated the UI to check progress every 2 seconds

Now I do not get any fake failures, no more hanging requests, but a smoother experience all around.

Once Dev Proxy had me sweating, other weak spots showed up fast. Rate limiting revealed that some rollbacks could take up to ten minutes, so I bumped the API timeout - thank Dataverse API for not allowing any concurrent actions 😘. Every test Dev Proxy threw at me exposed another spot where I’d trusted luck instead of design. A result of that is, that I implemented the changes that now make the solution way more resilient.

My two cents

Dev Proxy didn’t just test my app; it taught me how to handle reality better.

Every simulated failure revealed an assumption I didn’t know I was making in the first place. So they say it’s a testing tool, but it’s more an architectural therapist. It doesn’t just break things but helps you understand why they were fragile in the first place.

Happy coding!

Building Azure functions that never store secrets — ever

Thu, 25 Sep 2025 07:33:51 +0000

What if your function could hit Microsoft Graph with no client secrets, no certs, and no Key Vault entries? That is exactly what a Managed identity is for: Azure issues short-lived tokens to your app on demand, and the platform rotates and protects the underlying credentials for you.

The problem: credential hell

// the old way — credential nightmare
const clientSecret = process.env.CLIENT_SECRET; // 🚨 secret in env vars
const certificatePath = './certs/app-cert.pfx'; // 🚨 cert lifecycle
const connectionString = "DefaultEndpointsProtocol=…"; // 🚨 another secret

// what goes wrong?
// - secrets expire; prod breaks
// - certificates need attention
// - secrets get committed to git (oops)
// - Key Vault becomes a hard dependency
// - drift across environments

💡 Secrets create operational drag and failure modes you do not need in Azure. Managed identity removes them.

The solution: Managed identity in one picture

At runtime your function asks the platform for a token; Azure verifies the function’s identity and returns a short-lived OAuth 2.0 access token for Microsoft Graph, which your code uses as a bearer token. No app-held secret is involved.

Minimal code: fetch a token, call graph

import type { AzureFunction, Context, HttpRequest } from "@azure/functions";

const httpTrigger: AzureFunction = async (context: Context, req: HttpRequest) => {
 // IMDS pattern; works broadly, especially on VMs and newer stacks
 const tokenUrl = "http://169.254.169.254/metadata/identity/oauth2/token" +
 "?api-version=2018-02-01&resource=https://graph.microsoft.com/";
 const tokenResp = await fetch(tokenUrl, { headers: { "Metadata": "true" } });
 const { access_token } = await tokenResp.json();

 const resp = await fetch("https://graph.microsoft.com/v1.0/groups", {
 headers: { Authorization: `Bearer ${access_token}`, "Content-Type": "application/json" }
 });

 context.res = { status: resp.status, body: await resp.json() };
};

Why this is safe: the Instance Metadata Service (IMDS) lives at a non-routable address 169.254.169.254, is reachable only from inside the host, and communication to IMDS never leaves the host. The response includes expires_in (typically 3599 seconds), roughly an hour.

Production tip: on App Service/Functions prefer the local identity endpoint (IDENTITY_ENDPOINT + X-IDENTITY-HEADER), which the runtime exposes for you. The Azure Identity SDK (DefaultAzureCredential or ManagedIdentityCredential) wraps this nicely.

// pattern for App Service/Functions local identity endpoint
const { IDENTITY_ENDPOINT, IDENTITY_HEADER } = process.env;

async function getGraphToken(): Promise<string> {
 if (IDENTITY_ENDPOINT && IDENTITY_HEADER) {
 const u = `${IDENTITY_ENDPOINT}?api-version=2019-08-01&resource=https://graph.microsoft.com/`;
 const r = await fetch(u, { headers: { "X-IDENTITY-HEADER": IDENTITY_HEADER } });
 const j = await r.json();
 return j.access_token;
 }
 // IMDS fallback
 const imds = "http://169.254.169.254/metadata/identity/oauth2/token" +
 "?api-version=2018-02-01&resource=https://graph.microsoft.com/";
 const r = await fetch(imds, { headers: { "Metadata": "true" } });
 const j = await r.json();
 return j.access_token;
}

The bootstrap: Who gives the function permission to call graph?

The Managed identity eliminates stored credentials, but it does not auto-grant API permissions. You must assign Microsoft Graph application permissions (app roles) to the function’s service principal at deploy time. Use the Graph app role assignment API and the least-privileged permissions to call it.

Required rights for the caller

Use AppRoleAssignment.ReadWrite.All plus Application.Read.All, or run under a directory role such as Cloud Application Administrator or Application Administrator. These are the least-privileged choices documented for assigning app roles.

Reliably target the Graph service principal

Do not search by display name. Address Microsoft Graph by its well-known appId and query its app roles:

servicePrincipals(appId='00000003-0000-0000-c000-000000000000')

Three IDs you need for each assignment

principalId: your function app’s managed identity service principal id
resourceId: the Graph service principal id
appRoleId: the specific Graph application permission you want (for example, Directory.Read.All), found in Graph’s appRoles collection

Example: assign `Directory.Read.All` and `Group.Read.All` to the function’s identity


$graphSp = az rest `
 --method GET `
 --uri "https://graph.microsoft.com/v1.0/servicePrincipals(appId='00000003-0000-0000-c000-000000000000')`?$select=id,appRoles" `
 --query "id" -o tsv

# function's managed identity service principal id
$miSpId = $principalId # e.g., from your Bicep output

# find the appRoleIds you need programmatically 
$roles = az rest --method GET `
 --uri "https://graph.microsoft.com/v1.0/servicePrincipals/$graphSp?`$select=appRoles" `
 --query "appRoles[?value=='Directory.Read.All' || value=='Group.Read.All'].{value:value,id:id}" -o json

# assign each role
$roles | ConvertFrom-Json | ForEach-Object {
 $payload = @{ principalId = $miSpId; resourceId = $graphSp; appRoleId = $_.id } | ConvertTo-Json
 $tmp = New-TemporaryFile
 $payload | Out-File -FilePath $tmp -Encoding utf8

 az rest --method POST `
 --uri "https://graph.microsoft.com/v1.0/servicePrincipals/$miSpId/appRoleAssignments" `
 --headers "Content-Type=application/json" `
 --body "@$tmp" | Out-Null
 Remove-Item $tmp -Force
}

Security model; what is and is not leaving your app

No long-lived credentials in your app. The underlying SP keys and certs are platform-managed; your code never handles them
Token requests stay local to the host. Calls to IMDS use 169.254.169.254 and never leave the host
Access tokens are bearer tokens. You do receive the access token in your app; protect it like any other bearer token. The win here is that it is short-lived and you do not store a secret. The platform rotates the identity for you

Why this matters

traditional	zero-credential (managed identity)
secrets in code/config/Key Vault	no app-held secrets; platform-issued tokens
manual rotation of secrets/certs	platform rotates credentials; you request new tokens when needed
risk of leaks via git/logs	no long-lived secrets to leak; token request is host-local
secret management infra	none for Graph; you manage permissions, not secrets
outages from expired secrets	short-lived tokens; transparent renewal via the platform

Grab-and-go snippets

IMDS token request (HTTP semantics, including expires_in): GET http://169.254.169.254/metadata/identity/oauth2/token?api-version=2018-02-01&resource=https://graph.microsoft.com/ with header Metadata: true.
App Service/Functions identity endpoint (raw HTTP example, required headers): GET /MSI/token?resource=https://graph.microsoft.com/&api-version=2019-08-01 with header X-IDENTITY-HEADER: <IDENTITY_HEADER> to the host in IDENTITY_ENDPOINT.
Assign Graph app role to a service principal and required permissions for the caller: POST https://graph.microsoft.com/v1.0/servicePrincipals/{id}/appRoleAssignments with principalId, resourceId, and appRoleId; caller needs AppRoleAssignment.ReadWrite.All + Application.Read.All (or a suitable directory role).

And now, please stop using secrets if you don’t have to 😇

Introducing Mermaid to Dataverse Converter

Wed, 10 Sep 2025 17:33:51 +0000

Why diagrams matter (and why they usually fail us)

Entity-Relationship Diagrams (ERDs) are the universal shorthand for talking about data models. They show what entities exist, which attributes they carry, and how they connect to each other. In workshops, they are invaluable: they help everyone get on the same page, and they force the team to make decisions about terminology early on. Is it a Customer or an Account? Do we store Address inside the Order or separately? These are the conversations you want to have at the whiteboard.

The tragedy is that most ERDs end their lives inside a Visio file, a Confluence page, or, if you’re truly unlucky, a PowerPoint deck. They look polished for the kickoff meeting. Six weeks later they’re a lie. The system has moved on, but the diagram is frozen in time. Nobody trusts it anymore. What was supposed to be the map has become a fossil.

Mermaid: diagrams that behave like code

Mermaid.js changes the game because it treats diagrams as text. Instead of dragging rectangles around a canvas, you write a few lines that describe your model. Those lines render into a clean diagram, every time. No one is fiddling with connectors or fighting layout engines; the syntax is simple, readable, and versionable.

What you see here isn’t a static sketch. It’s code. You can put it into Git, track changes, open pull requests and more. The diagram becomes part of the software, evolving alongside the rest of the project. That alone is already a big step forward from Visio archaeology.

From drawing to deployment

But I didn’t want to stop at documentation. I built the Mermaid to Dataverse Converter, an Azure App Service that takes your Mermaid ERD and provisions the schema directly into Microsoft Dataverse.

The diagram that once lived in a deck now becomes the thing that creates your environment. The converter generates publishers and solutions, defines entities with their attributes, provisions one-to-many and many-to-many relationships, respects global choice sets, and even maps to existing Common Data Model entities where possible. What started as a design artifact in a customer meeting ends up as a working Dataverse solution a few minutes later.

What about plan designer?

If you’ve been following the Power Platform updates, you’ve probably seen Plan Designer. It’s Microsoft’s AI-driven canvas for solution design. You type in a prompt, sometimes upload an image, and it drafts a whole plan for you: tables, relationships, apps, flows, even a portal. It’s impressive, and for quick ideation it’s a fantastic tool.

But prompts are not code. They look like they could be versioned, but they aren’t deterministic. The same words might give you a different schema tomorrow. You can check a prompt into Git, but you can’t guarantee the output will be identical next time you run it. That makes deployments unpredictable.

You can call it a proof of concept or an MVP, and that’s fine if it stays a sketch. The reality, though, is that proofs of concept have a bad habit of sneaking into production. Once users see something that works, they keep using it. Suddenly you’ve got live data sitting on a nondeterministic schema that you can’t repeat or redeploy with confidence.

Mermaid to Dataverse Converter takes the opposite path. The file is text. The output is deterministic. The same diagram yields the same schema every time, no surprises. It can be versioned properly, reviewed properly, and deployed properly. That’s the difference between a sketchpad and infrastructure. Plan Designer is great for sparking ideas; Mermaid to Dataverse Converter is what you reach for when you want something you can trust on a Friday night rollout.

documentation as infrastructure

Because Mermaid is plain text, it slides neatly into the practices we already use for code. You commit it, version it, and push it through a pipeline. Every schema change becomes visible in source control, every adjustment is reviewable, and every environment can be provisioned automatically from the same source.

This is what Infrastructure as Code looks like in the Dataverse world. The ERD is no longer a sketch you present to stakeholders. It’s the blueprint that shapes the environment, always up to date because it has to be. The usual drift between documentation and reality disappears, because they are literally the same thing.

Rage against the docs

For too long we’ve tolerated diagrams that die in SharePoint folders and slide decks that mislead more than they guide. We’ve accepted documentation as a necessary evil that will always be out of date. That’s nonsense. Documentation should be as alive as the system it describes. It should be part of the build, not a side note.

Mermaid plus Dataverse finally lets us do that. Define the model, check it in, and let it provision itself. Stop treating diagrams like art projects. Start treating them like infrastructure.

Try it out

The Mermaid to Dataverse Converter is open source. It’s deployed within a few minutes. Grab an ERD, upload it, and run it through the converter. Watch your documentation turn into a Dataverse solution. The next time someone asks for “the latest version of the diagram,” you can point to GitHub, and to the running system, and know they are the same thing.

Would love to get your feedback! 💖

It’s OK to be seen trying

Thu, 31 Jul 2025 10:45:00 +0000

It’s OK to be seen trying

Somewhere along the way, we started believing that you’re only allowed to speak after you’ve figured everything out. That you can only post once the product is perfect. That you can only ask a question if it’s smart enough, and that you can only contribute once you have “value”: measurable, monetizable, LinkedIn-optimizable value.

And until then? Stay quiet 🤫. Watch. Lurk politely in the back row of the internet.

My suggestion: Let’s kill that idea.

Perfectionism kills participation

It’s not that people have nothing to say. It’s that they’re afraid of saying it wrong.

In many rooms, especially technical ones, there’s this quiet rule: if you don’t already know, don’t speak. And if you do speak, you better be right. Flawlessly, citation-included, TED-Talk-ready right.

The result? Smart, curious people stay silent. Teams lose out on diverse thinking. Communities become echo chambers for the already-confident.

Building in public is a power move (even when it’s messy)

When you share half-baked ideas, drafts, ugly prototypes, something magical happens. You signal that it’s safe to learn here. That trying counts. That progress matters more than polish. You also make space for feedback, collaboration, and the kind of honesty you can’t fake in a keynote. This doesn’t mean performative “look at me failing” posts. It means showing the process. Being real. Building during, not just after.

Yes, the reply guys will show up

The “Actually…” brigade is always ready. The guy correcting your grammar. The one telling you that your take “lacks nuance”. The person who misses the point just to feel smarter. They don’t matter.

If you’re building in public, you will be corrected. But you’ll also connect with the people who get it, the ones who are walking the same messy path, not standing on the sidelines with a red pen.

Your voice matters, even if it shakes

You don’t need to be an expert to contribute. You don’t need to have it all figured out to post something useful. Sometimes, the most helpful thing you can share is the thing you just learned five minutes ago. It’s fresh. It’s real. It’s not “thought leadership”. but it’s thought in motion.

Beginners make the best guides for other beginners. They still remember what it felt like not to know.

Teaching and learning are not separate states

You don’t “arrive” at knowing and then start giving back. It’s a loop. You figure something out. You share it. Someone else teaches you the next piece. Rinse, repeat. The healthiest communities are built by people who are open mid-process. Not the ones holding court, but the ones pulling others up as they climb.

Trying is enough. trying visibly is brave.

“Sometimes I work 40 hours in one day.
Sometimes I need a week to find 4.”

Let go of the myth that it has to look good.
It just has to be honest. Progress beats polish. And showing up, even with a shaky voice and half a plan, is always better than staying silent. So write the post. Publish the prototype. Ask the question. Be seen trying.

Because someone out there is waiting for permission to do the same.

Stuck in pilot - Part 1: The illusion of progress

Wed, 30 Jul 2025 09:20:51 +0000

“We just need to test the AI. We’ll figure out the data later.”

That sentence has quietly killed more AI pilots than any model failure ever could. Most AI pilots don’t fail because the tech didn’t work. They fail because no one did the groundwork. No clean data. No integration path. No clear problem. No business owner. Just a well-intentioned scramble to “try AI” and show something in a demo, preferably fast. And then everyone wonders why it didn’t go anywhere.

The myth of the fast pilot

Pilots are often sold as a quick win. Low commitment, high visibility. A chance to show progress without the red tape of production work. But if you skip the prep: if you start before you’ve validated the problem, the data, and the path to value, then you’re not testing AI. You’re testing how far a half-baked prototype can limp before someone shelves it with a polite “let’s revisit this later”. Big sigh!

You think you’re being agile. You’re actually being avoidant.

What’s almost always missing

Let’s get specific. Here are four foundational gaps that quietly ruin most AI pilots before they even start, and unfortunately, I see all of them when my customers show me their pilots.

1. Clean, reliable data

Everyone assumes the data is “somewhere”. No one checks if it’s usable, consistent, labeled, or accessible. So when the model performs poorly, people blame the algorithm instead of the dataset. Garbage in, garbage model. We should know by now, that this sentence correctly says: garbage in - garbage out.

2. An integration plan

The pilot lives in a beautiful little bubble. It doesn’t connect to the CRM. It doesn’t update any real records. It doesn’t push anything to production systems. So even if it works, it can’t scale, because no one thought about how it would fit into the real-world process.

3. A clear problem statement

You get goals like “reduce time spent” or “optimize the workflow” or “improve customer experience”. Vague enough to be exciting. But totally unhelpful when you try to define success. What, exactly, are we fixing? How do we measure this?

4. Business ownership

When a pilot is purely IT- or innovation-driven, it often lacks a business owner who actually cares about the outcome. No one to champion it. No one to fight for its rollout. No one whose KPIs depend on it. So when priorities shift, the pilot just… dies in corporate.

Every pilot needs a contract (even if it’s just a slide)

Before you build anything, you should be able to answer five basic questions:

What problem are we solving? Use plain language. No jargon. No “digital transformation” fluff
How bad is it right now? What’s the baseline? What’s the pain? What are the symptoms?
What data are we using? Where does it live? Who owns it? How clean is it? Can we access it?
How will we test it? What’s in scope? What’s off limits? How will we simulate usage?
What does success look like? Define the win condition now, not retroactively after the pilot’s already derailed

This doesn’t have to be a 10-page deck. But it has to exist, before the pilot starts.

Skipping the foundation isn’t agile—it’s wishful thinking

You can’t move fast if you don’t know what you’re building, or for whom. And no amount of generative flair or AI hype will rescue a pilot that’s missing the basics. If your pilot is slow, buggy, or underwhelming, it may not be the tech. It may be the homework you skipped to feel fast.

Closing thought

You can’t build a second floor when the foundation is still guesswork.

If your pilot’s in trouble, don’t blame the model or the team. Look backward. Because chances are, the cracks were already there before you wrote a single line of code (or clicked yourself through a portal).

More parts of this series:

Stuck in pilot - Part 0: The comfort of the sandbox
Stuck in pilot - Part 1: No foundations, no future [📍 You are here!]
Stuck in pilot - Part 2: Fear of success - to be published soon™️
Stuck in pilot - Part 3: your chatbot isn’t useful - to be published soon™️
Stuck in pilot - Part 4: from stuck to scaled - to be published soon™️

The MVP trap: AI lets you do more, but often worse

Wed, 30 Jul 2025 06:00:00 +0000

There’s a narrative floating around right now: With AI, one person can do the work of a whole team.

Code? Done.
Design? Prompted.
Copy? Generated.
Voice-over, editing, visuals? All stitched together in record time.

And at first glance, that sounds like progress. AI makes it easier than ever to ship something: quickly, independently, and with just enough polish to post. But it’s also creating a very specific kind of trap.

The MVP pyramid no one wants to talk about

There’s an image I keep coming back to whenever people start throwing around the word “MVP”.

The left side is what many AI-powered projects are starting to look like: Stacked layers. Functionality without usability. Code without context. Stuff that technically works, but feels empty.

The right side? That’s how it should work. A small, testable, coherent slice. Something people can actually use. Something with value, not just features. And right now, AI is making the left-hand path faster, cheaper, and way too tempting.

Shipping isn’t the same as succeeding

Just because something runs doesn’t mean it works. Just because it’s publishable doesn’t mean it’s worth sharing. And just because AI lets you do everything yourself doesn’t mean you should. We’re now surrounded by content and tools that exist purely because they can, not because they solve a problem well, or even make sense.

Voice-overs that miss the tone.
Copy that reads like a marketing intern on autopilot (not Copilot) Interfaces that look decent in a screenshot but fall apart under real use

The result? Lots of output. Very little value.

The “we don’t need juniors” myth

Here’s where it gets dangerous. Some folks are already saying

“If AI can write the code, we don’t need junior devs.”
“If ChatGPT can write posts, who needs marketing people?”
“If design is a prompt away, why bother with actual designers?”

But juniors don’t just write code. They ask the awkward questions. They bring fresh eyes to assumptions. They grow into the people who later build the foundations you depend on. Removing them from the system doesn’t save time; it starves your future talent pipeline.

Same with marketers, designers, QA, tech writers: anyone who adds clarity, nuance, and experience to what you’re building. AI doesn’t replace them. It just replaces your excuses for skipping them.

AI lowers the cost of mediocrity

When things were expensive to build, we were careful by default. We tested. Reviewed. Debated. Improved. Now? We generate, skim, and ship. Because it’s cheap. Because it’s fast. Because it looks good enough.

But doing more isn’t the same as doing better.

What are we actually building?

AI is here. It’s useful. It’s powerful. But it doesn’t know what matters to your users. It doesn’t care about the edge cases. It won’t ask if your output is accessible, maintainable, or even remotely worth doing. That’s still on you. On your team. On your taste. So the question isn’t “how much can I build now?”, but

Am I delivering a meaningful slice of value, or just another bottom layer nobody needs?

Because in the end, tools don’t make good products. People do.

The productivity graph is broken and we’re pretending it’s fine

Tue, 29 Jul 2025 09:21:04 +0000

You know that neat little curve in project planning tools that suggests you’ll produce value at a steady pace from Monday to Friday? It’s a lie. Not a malicious lie. Just a completely detached-from-reality one.

The myth of the 8-hour brain

Most jobs still pretend that productivity is something that can be sliced neatly into eight equal hours a day. But if you’ve ever done any kind of deep, focused, creative, or strategic work, you already know: it doesn’t work like that.

“Sometimes I work 40 hours in one day. Sometimes I need a week to find 4.”

That quote wasn’t meant to be profound. I just said it out loud once, and people nodded like I’d confessed something they weren’t allowed to say themselves.

the 1–4–40 reality

Here’s what it actually looks like for a lot of us:

On some days, you get 1 hour of real output, and spend the rest trapped in inboxes, meetings, or brain fog
Some days, you hit a rhythm and produce 4 hours of high-value work.
Once in a blue moon, you get 40 hours of clarity in a single caffeine-fueled sprint and wonder if you’ve unlocked a new dimension

The problem isn’t the variation. The problem is pretending the variation doesn’t exist, and building performance expectations around a model that’s never been true.

It’s not about discipline

It’s easy to assume this inconsistency means you’re undisciplined. That you need better routines. A stricter schedule. A fancier Pomodoro timer. But what if it’s not about discipline? What if knowledge work is simply unpredictable, because focus, creativity, and problem-solving are not linear resources? You don’t summon insight on command. You don’t plan your most productive hour, it sneaks up on you at 6:43 a.m. in the shower or at 9:19 p.m. when you should be unwinding.

I found this cartoon a little too relatable :-)

The Cal Newport effect

One of the best comments I got on this topic was about Deep Work by Cal Newport: “Real productivity doesn’t mean being busy all day. It means doing focused, meaningful work without distractions.” Exactly 🫳🎤⬇️. And how many hours of that do we realistically get in a typical day? Two, maybe three—if we’re lucky, rested, and no one scheduled a team sync at 9:00 a.m.

So how should we think about productivity?

Start with this: value ≠ hours. Your job isn’t to fill time. It’s to deliver outcomes, solve problems, make good decisions, and occasionally do something brilliant. And most of that happens in peaks, not in steady state. So instead of fighting the 1–4–40 reality, try designing around it:

Guard your deep work hours like gold - I for example have a maximum of 2 hours of meetings per day - rest is real work
Not every hour will be productive, and that’s okay. There is this thing of productive procrastination where you subconsciously go through all the steps that you aren’t ready for, yet. And when the time comes, you processed it so thoroughly, that you exactly know what to do. And then you spread your wings and fly.
Measure by impact, clarity, and progress, your clock is not a good way to measure productivity.

Let’s stop pretending

The graph is broken. Our brains don’t work on conveyor belts. And yet, we keep designing work environments, performance metrics, and schedules as if they do.You’re not lazy. You’re not broken. You’re just working in a system that wasn’t built for how people actually think. Maybe it’s time to fix the graph instead of forcing ourselves to fit it.

Stuck in pilot - Part 0: The comfort of the sandbox

Sat, 26 Jul 2025 09:20:51 +0000

“Our AI chatbot is live- in a test environment, since … uhm… 18 months.”

Sounds familiar?

If your organization has a hallway legend about a “pilot” project that never saw daylight, you’re not alone. Across industries, AI pilots have become the business equivalent of Schrödinger’s cat: both alive and dead, depending on who’s presenting the PowerPoint. They give the illusion of innovation without requiring anyone to actually commit to change.

Let’s talk about why pilots feel safe, why that’s a trap, and why not piloting isn’t the answer either.

Pilots are easy to love

There’s something comforting about a pilot. It’s non-threatening. Limited in scope. Budget-contained. And most importantly: No one gets fired if it doesn’t work. Pilots are where good ideas go to hide from accountability.

In a sandbox, you don’t have to think about integrating with your CRM, fixing bad data, or training customer support teams. You can just build a chatbot, or drop an AI summarizer into a Power Automate flow, and feel like you’re part of the future. And hey, if it looks cool enough, maybe someone will even share it in the All Hands meeting. Yay!

Pilots without a path to production are organizational theater.

Performative innovation

I call it pilot theater, the corporate cousin of innovation theater. It’s performative and looks like progress, but it’s just a loop of demo–hype–pause–repeat.

You spend six months “validating feasibility”, only to realize no one planned for ownership, integration, or ongoing support. So the pilot gets parked. Or worse, someone suggests starting a new pilot. One that’s even more exciting! (And just as doomed.)

In the meantime, the business still has the same inefficiencies, and same bottlenecks. But now, with the added bonus of AI fatigue.

The infamous use case list won’t save you

A common symptom of pilot theater is the infamous “AI use case list”. You gather 20, 30, maybe 50 ideas from across the company. Some are genuinely good. Others? Not so much.

But the problem isn’t the ideas, but the lack of clarity about what to do with them.

I’ve written about this in detail here, but in short: Use case lists give the illusion of progress. They help you say, “look at how much we could do!” without answering the more important question: “what are we actually ready for?”

What’s missing isn’t imagination, but prioritization, ownership, and feasibility.

Skipping pilots is worse

Let’s be clear: not piloting is not the answer either. Nobody should roll out AI to all 18,000 employees at once. That’s not bold; that’s reckless. Pilots are essential to reduce risk, test assumptions, and validate business value in a controlled environment.

But a pilot should be the start of a journey, not a loop.

A solid pilot begins with a hypothesis: a testable, grounded assumption about how AI could improve a specific business process. Maybe you believe that automating invoice routing will cut manual handling time by 50%. Or that an AI-powered summarizer will reduce response time in your support center by 15%. That hypothesis must be linked to something tangible, something you can actually measure.

Which brings us to metrics. If your pilot has no business metrics, no baseline data, and no plan for what happens if it works… congratulations, you’re not piloting. You’re procrastinating.

Pilots need an ending

One of the reasons pilots get stuck is that no one agreed on how they’d end. You need exit criteria: clear, objective statements that define what “successful”, “inconclusive”, or “not worth continuing” looks like. These should be defined before the pilot starts, not when someone asks for a status update six months in.

For example:
“We’ll consider the pilot successful if the AI reduces invoice processing time by 30%, with an error rate under 2%, and if the three-person accounting team finds it usable without additional training.”

Not only does this force clarity early on, it gives everyone a shared target. And more importantly, it avoids the trap of “it’s not bad… let’s just keep it running in test.”

Of course, exit criteria only work if they’re connected to real business metrics. And I don’t mean “number of chatbot clicks” or “hours spent coding”. I mean measurable outcomes:

How much time was saved?
Was manual effort reduced?
Did we see fewer errors?
Was customer satisfaction improved?
Did operational throughput increase?

Start by capturing the baseline: how long does this process take today? What are users frustrated about? What’s the current failure rate?

Then, define what change would make the pilot worth scaling. Measure the delta. Track results. And make a decision. All of this should be part of your pilot planning. Not a side note, not a retrospective, but a section right at the top of your one-pager

What are we testing?
What does success look like?
What will we do if we get it?

Because a good pilot starts with a hypothesis, includes a measurable outcome, and ends with a decision: scale, pivot, or stop.

Signs you’re stuck

If any of these apply, you’re probably stuck:

Your pilot is older than a year
There’s no rollout plan, just another “phase”
The project is owned by IT, but not the business
The same demo has been shown to three leadership teams
No one can tell you what success looks like

Pilots should make people uncomfortable

Good pilots challenge something. A process. A decision. A mindset. They surface the real blockers: data quality, siloed teams, broken incentives, so that the organization can deal with them before a full rollout. If your AI pilot made everyone feel safe, it probably didn’t do much.

Let’s end with this

“If your AI pilot was never designed to leave the sandbox, it wasn’t a pilot, it was a safe place to pretend you’re changing.”

What’s next in this series

This post is part of the “Stuck in Pilot” blog series. Coming up next:

Part 1: no foundations, no future
What your AI pilot was missing before it even started - to be published soon™️
Part 2: fear of success
Why good pilots still don’t go live - to be published soon™️
Part 3: your chatbot isn’t useful
When pilots fail because no one asked if the solution matters
Part 4: from stuck to scaled - to be published soon™️ A roadmap for turning a successful pilot into real business value - to be published soon™️

Round Robin assignments in Power Automate

Fri, 25 Jul 2025 09:21:04 +0000

When distributing tasks or tickets across a team, fairness matters, and so does flexibility. With Power Automate, we can implement a round robin pattern that always picks the next person in line, and wraps around once we hit the last.

I got asked by a customer on how to achieve this - so it might be helpful to you as well.

What we’re solving

Let’s say your team handles incoming forms—support requests, process suggestions, or tickets. You want those distributed evenly across your team, but also automatically.

The round robin logic makes sure that in a team 3 people:

Request #	Assigned to
1	Person 1
2	Person 2
3	Person 3
4	Person 1 again

… and so on. No skipping, no duplication, no manual effort.

Setup

SharePoint list: AssignmentIndex

Create a simple list called AssignmentIndex. It only needs one row and one column (besides the Title):

Title	LastIndex
Assignment	0

LastIndex must be a number column
This acts as memory across runs, telling us who got the last task

Microsoft Forms form

Set up a basic form with questions like Title, Description or similar. We will use this to trigger an upcoming support request.

Flow overview

Let’s break this down into steps:

Microsoft Forms trigger

Use the trigger When a new response is submitted

Get Form Details

Use the actions: Get response details, this gives us the data we want to assign: title, description, urgency, etc.

Initialize MemberList

variable of type Array
leave value empty

Get SharePoint Index

Use Get items to pull the one row from the AssignmentIndex list. Use a filter condition Title eq 'Assignment'.

Initialize LastIndex

Now initialize a variable of type Float: body('Get_items_-_AssignmentIndex')? ['value'][0]?['LastIndex'] - this lets us store the value of the LastIndex column.

Get Microsoft Teams members

Use the action List members from Microsoft Teams connector to list the members of your Team. Select a team and channel from the dropdown. The output will be an array of team members (emails, names, etc.).

Get the email addresses

Add an Apply to each loop with the input: body('List_members')?['value']. Inside of the loop, add an Append to array variable - Choose the MemberList from the dropdown and put this into the value as an expression: items('Apply_To_Each')?['email']

This will loop through the array of objects we get from the Teams action, extract only the email addresses of the team members and add them to our array variable.

Calculate the new index

We now want to move one step/person forward in the team list. Initialize another variable NewIndex of type Float and use an expression:

mod(add(variables('LastIndex'), 1), length(variables('MemberList')))

This is where the magic happens. The mod() (Modulo) function will return the remainder of a division (dividend : divisor). In our case, it will give us the remainder of the division of LastIndex + 1 and the amount of items we got from the Memberlist variable (we calculate this with the length function).

What does `mod()` do here?

Let’s make that clear with a table:

LastIndex	Team size	NewIndex calculation	Result
0	3	(0 + 1) mod 3 = 1	1
1	3	(1 + 1) mod 3 = 2	2
2	3	(2 + 1) mod 3 = 0	0

The mod() function ensures we loop back to the beginning after reaching the end of the list.

Now let’s finally find the right person to assign the new task to. We already know the NewIndex, all is left for us now is to get the NewIndexth (sic!) item from our MembersList: Add a Compose action and call it Assignee. Use this expression: variables('MemberList')[int(variables('NewIndex'))], which will then return the email address, and due to our round-robin logic it will always be the next person in the list. You might have noticed, that we make an integer out of our float variable - this is needed because the index needs to be an integer (as an index can’t be 9 3/4 or similar).

Assign the task

You can use this pattern for different use cases, for example

Assigned To fields (Planner, SharePoint, Approvals)
Emails
Logging

Do as you please, your Assignee action is now always the correct person.

Update the SharePoint index

Finally, don’t forget to update the LastIndex field in SharePoint List so we know who got the last assignment and the list stores the correct value for the next flow run.

Use Update item with:

ID = dynamic content ID from our Get items action
LastIndex = variables('NewIndex')

Done! 👌

Looking for more blog posts on Power Automate? I got you: https://www.m365princess.com/categories/power-automate/

Copilot Studio: Part 5 - From tool to capability – making Copilot Studio strategic

Fri, 25 Jul 2025 06:15:26 +0000

If you made it this far in tis series, you’ve seen the messy middle: the risks, the lifecycle debt, the cost of inaction. Now let’s zoom out.

Copilot Studio isn’t just another way to automate tasks, but a design surface for how your organization thinks, acts, and responds. But only if you treat it like a capability, not a tool.

The real value isn’t in building faster but in thinking better

Most organizations ask the wrong first question: “What use cases can we build with Copilot Studio?”

They should be asking: “What kinds of agents should we be able to build, reliably, at scale?”

Because building one agent isn’t hard. Building twenty that share knowledge, escalate consistently, reuse logic, and don’t rot after Q1? That’s capability. You don’t need a library of bots. You need an ecosystem.

“One per team” is not a strategy

If your roadmap is “every department gets a chatbot”, congratulations, you’ve reinvented the silo. Now every agent has its own personality, logic, and tone. None of them are connected. All of them are partial.

Capabilities are horizontal.
They support multiple processes, flex across domains, and evolve with the org.

Instead of one bot per team, ask:

Which core tasks show up across teams?
Which decisions are low-stakes but high-volume?
Where do people get blocked, not because the work is hard, but because it’s inconsistent?

Build for those. Build once, use many times. And please stop making FAQ-Bots.

Composition over control

Most agent deployments start centralized. One team. One environment. One “AI initiative”. That works for a pilot. But it doesn’t scale. Because real-world needs shift fast. Autonomy matters. Context matters. So instead of controlling every agent from the center, design for composition

Shared knowledge sources
Reusable skills
Composable response blocks
Plug-and-play escalation flows

Let teams build what they need, but give them building blocks that don’t reinvent the basics.

Capability maps > use case catalogs

A use case catalog tells you what you’ve built. A capability map tells you what you could build, where it fits, how it integrates, and what it depends on. It includes:

Agent types (retrieval, task, autonomous)
Triggers (user-initiated, system signals, cross-agent)
Behaviors (respond, decide, act, escalate)
Ownership (who governs, who maintains, who measures success)
Boundaries (what this agent should not do)

It’s not documentation (although docs are still necessary). It’s design intent. It helps you scale without duplicating effort or creating invisible risk.

Workforce design, not tech deployment

Every agent you deploy takes over a task your people used to own. That’s not just automation, but workforce shift. Treat it that way and ask

What kind of decisions are we delegating?
What kind of work do we want to automate or augment?
Where should humans stay in the loop?
Where should the loop disappear entirely?

If you don’t ask these questions, Copilot Studio becomes another dashboard, something that demos well, but changes nothing. (If you feel that your org is stuck at that level… lets have a chat, I will help you get out of pilot-jail)

Wrap-up: This wasn’t about bots

This whole series? It wasn’t really about Copilot Studio, but about clarity, ownership, intent. Because that’s what agents reflect. Not just what you told them to do, but how clearly, how carefully, and how repeatably you told them.

Tools come and go. Capabilities compound.

Build the latter.

You can still catch up on the previous blog posts in this series

Part 0: Everything is an agent, until it isn’t
Part 1: When automation bites back – autonomy ≠ chaos
Part 2: Copilot Studio: Part 2 – Copilot Studio agents: the ALM reality check
Part 3: The cost of (in)action – what you’re really paying for with Copilot Studio
Part 4: Agents that outlive their creators – governance, risk, and the long tail of AI
Part 5: From tool to capability – making Copilot Studio strategic [📍 You are here]

Copilot Studio: Part 4 - Agents that outlive their creators – governance, risk, and the long tail of AI

Tue, 22 Jul 2025 10:17:17 +0000

Agents that outlive their creators – governance, risk, and the long tail of AI

In most organizations, apps get decommissioned. Workflows get retired. People move on, and someone eventually archives the mess they left behind. But agents? Agents keep acting, even when their creator is gone. That’s not a hypothetical risk. It’s already happening. Because most Copilot Studio deployments are building agents with no plan for ownership, no lifecycle guardrails, and no way to know who’s responsible once the project changes hands.

Automation doesn’t age well

A flow that fails? It throws an error. Someone notices. An agent that fails? “It might just hallucinate” a plausible answer. Or skip a trigger. Or quietly misclassify a request. And no one notices, until the wrong thing gets approved. Or never does. Now imagine that agent was built by someone who left six months ago. No documentation. No ownership transfer. No audit trail. No one even knows it still exists.

And yet, it’s still acting.

Orphaned logic is the new shadow IT

Orphaned agents don’t break all at once. They decay. The SharePoint source changes. The connector credentials expire. The business rule is revised, but not in the agent. And because it doesn’t crash, no one flags it. It just keeps delivering wrong-ish results. Enough to pass casual use. Enough to lose trust over time. When agents are treated like temporary hacks, they never get the lifecycle discipline of “real” apps. But they still live in your production environment, attached to your brand, acting in your systems. Shadow IT used to be spreadsheets and rogue access databases. Now it’s retired employees’ bots still issuing approvals.

Intent isn’t portable

Agents don’t just contain instructions. They contain assumptions. What should be escalated?
What counts as “sensitive”? What tone should be used in a customer response? These aren’t just prompts, but judgment calls: made once, encoded, and never reviewed. Until someone disagrees with the outcome and the fallout begins. You can’t inherit an agent without inheriting its design logic. And most of that logic is undocumented.

Code you can read. Flows you can inspect.

But an agent’s behavior? That often lives in prompts, embedded logic, and fuzzy mental models. Good luck reverse-engineering intent.

Governance isn’t cleanup. It’s foresight.

Most AI governance today is reactive. There’s an incident. Or a compliance audit. Or a spike in weird behavior. Then everyone scrambles to retro-document the agent, wrap it in monitoring, and assign an owner. It’s backward.

Governance should begin at the moment of creation:

Who owns this agent?
What is its purpose?
How long should it run?
What should happen when it fails?
How is success measured
And who reviews that?

If you can’t answer those questions, you’re not building an agent. You’re publishing a biiig liability.

The long tail of ownership

Every agent you deploy creates ongoing obligation. It needs:

Knowledge base updates
Prompt maintenance
Access review
Escalation logic refresh
Retirement planning

And yet most agents go live with none of that defined. Because the maker is “just experimenting” or the team is “moving fast”. Then the person leaves. Or the project pivots. Or the department gets restructured. And suddenly you’re running production logic that no one can explain. AI doesn’t stop working just because you stopped watching it. That’s what makes it dangerous.

Future-proofing the invisible workforce

If your organization has a bot running in Teams, that bot is now part of your workforce. It performs tasks. Interfaces with customers. Retrieves and summarizes knowledge. Makes decisions. So treat it like a team member:

Give it a clear role
Document its function
Assign an owner
Review its performance
Offboard it when it’s done

Because whether you track them or not, your agents are working. And if no one’s in charge, they’re still making decisions, with your name on them.

Coming up next

Part 0: Everything is an agent, until it isn’t
Part 1: When automation bites back – autonomy ≠ chaos
Part 2: Copilot Studio: Part 2 – Copilot Studio agents: the ALM reality check
Part 3: The cost of (in)action – what you’re really paying for with Copilot Studio
Part 4: Agents that outlive their creators – governance, risk, and the long tail of AI [📍 You are here]
Part 5: From tool to capability – making Copilot Studio strategic

Org chart is cheap, show me the relationships

Tue, 22 Jul 2025 08:31:49 +0000

tl;dr

AI can read every policy, spec, and wiki page in your company; it even knows the formal org chart. But it doesn’t feel the informal paths: the backchannels, the trust networks, the unspoken approvals. Institutional knowledge lives in the spaces between people. When you drop an AI agent into an organization and expect it to “just know”, it plays the wrong game. Map the relationships first; then let AI augment the humans who already run them.

The illusion of instant expertise

There’s something deeply appealing about the idea that AI could replace the messiness of human memory. If we could just ingest all the project notes, the documented processes, the internal wikis, maybe even throw in the Slack/Teams logs for good measure, surely we could replicate what the experts in the building know. (I will happily leave out the problem that usually, knowledge is rarely (well) documented, that processes are unclear/broken, and that people fight political battles in hierarchal structures; some to thrive, some to just survive this quarter)

The problem is: We’re conflating access to documentation with access to understanding. Reading what happened is not the same as knowing how it happened, or why. And it definitely doesn’t mean you can replicate it. The fantasy is that institutional knowledge is just poorly indexed content. But most of it was never written down in the first place. It lives in offhand comments, hallway deals, late-night decisions, subtle workarounds, and emotional memory, the kind that says, “Yeah, that diagram says A, but trust me, talk to Maria first.”

AI can scan the documentation, but it won’t sense the tension in a planning call. It can retrieve the slide deck, but it doesn’t know that slide was a decoy for a much harder conversation that never made it into writing. It can suggest a process, but it won’t understand the invisible compromises that hold it together.

The real org chart

A few years ago, a cartoonish diagram started circulating in HR departments. It showed a smiling org chart turned sideways by arrows of resentment, secret crushes, backchannel deals, and long-forgotten favors. People laughed; some a little too hard. It stuck because it captured something everyone knew but no one ever documented: that real power, real trust, and real influence don’t follow reporting lines - and they are never written down.

Every company has someone who technically reports to someone else, but in practice, calls the shots. Every dev team has a person who isn’t the architect but whose opinion the architect won’t ship without. Every meeting has the person whose silence speaks louder than the project sponsor’s cheerleading.

Sometimes it’s the executive assistant who knows exactly when to schedule a meeting so it gets the right attention. Sometimes it’s the long-tenured employee who can de-escalate a cross-team conflict with a single sentence. These aren’t exceptions; they’re infrastructure. The kind no system-of-record captures. When someone says, “Let me check with them first”, you’re seeing the real org chart at work. And AI, no matter how much data you feed it, doesn’t feel those dynamics.

Why ai stumbles

AI struggles in knowledge work because it assumes the structure is the truth. It assumes that if you feed it the correct inputs, it will produce the correct answers. But knowledge work is full of context, ambiguity, and shifting expectations.

Let me give you an example: Language models score probabilities; humans score trust. When someone gives you a nuanced answer to a politically charged question, you’re not just hearing the words. You’re reading between the lines, tracking facial expressions, body language, tone. You’re also remembering how they handled a tough decision two years ago. AI misses all of this.

Even if you give it access to all the right content (remember, that’s a whole different challenge!), you’re working with static context. An org’s knowledge graph changes faster than its documents. Today’s team lead becomes tomorrow’s problem child. The person who used to run things steps back. Someone else quietly steps up. Your AI won’t keep up with the gossip, and it definitely won’t sense that a document is technically accurate but politically obsolete.

There’s also the Conway problem. Conway’s Law tells us that systems mirror the communication structures of the teams that build them. If you don’t know who actually talks to whom, your automation will lock in the wrong assumptions. AI solutions built on misread maps only deepen the disconnect.

And finally, AI is blind to the informal networks. The people who connect teams, translate between departments, or just know who to talk to, they rarely show up in org charts. These are your bridge people. They have no formal mandate but hold immense influence. If you don’t account for them, your AI will repeatedly miss the mark.

What we actually need

We need to stop trying to replace knowledge workers with AI and instead design tools that help them be more effective. That starts with respecting how knowledge actually flows in an organization. Don’t build systems that expect to learn everything from one big data ingestion. Most of what matters isn’t written down, and what is written often lacks the nuance to be interpreted safely without context. Instead, build opt-in systems that let people gradually contribute and curate the knowledge they hold. Systems that understand the value of context, timing, and consent.

Instead of mapping roles, map relationships. Knowing that Alex is the “Product Owner” doesn’t tell you much. Knowing that Alex always defers to Jamie on architectural questions, despite having the final say on paper, tells you a lot. Track who people actually turn to for help, advice, or unblocking. The connectors. The mentors. The quiet experts. These are the nodes an AI assistant needs to understand if it’s going to provide value without stepping on toes.

And above all

Stop framing AI as a cost-cutting tool. Frame it as a knowledge amplifier.

AI is something that helps humans find the right person faster, spot inconsistencies earlier, or prep better for meetings. Let people stay in charge. Just give them better tools.

Making it real

So how do we build AI that respects the real org chart? Start with relationship mapping. Not in a creepy surveillance way, but in the spirit of transparency and collaboration. You don’t need to trace every coffee chat. But there’s a big difference between “the dev team” and “the three people in the dev team everyone trusts with hard questions”.

Find those people. Talk to them. Ask not what they do on paper, but how they get things done in practice. They’ll tell you where the bottlenecks really are, who smooths things over when teams fight, and where decisions get quietly reversed before they hit the roadmap.

Then, build your AI around those realities. If someone always edits the architecture document after it’s approved, make sure the AI knows not to recommend it without checking with them. If two people interpret the same policy differently, your assistant shouldn’t pick one; it should flag the conflict and suggest a conversation.

And don’t measure success by usage alone. Measure trust. When people rely on an AI suggestion, do they feel it helped? Do they come back? Or do they start ignoring it because it keeps missing the point? Usage can be a vanity metric. Trust is what determines whether AI becomes a partner or a nuisance.

Closing thought

Knowledge work is deeply human. It’s made of trust, shortcuts, conflict, and compromise. If your AI doesn’t know who people trust, who they avoid, who they quietly run things by before making a call, it doesn’t know enough. The real org chart isn’t in the HR system; it’s in the relationships. Start there.

PS

If you are still on the “hey Copilot whats our travel policy” level, lets talk to get you out of that chatbot-jail. AI can do so much more.

Copilot Studio: Part 3 - The cost of (in)action – what you’re really paying for with Copilot Studio

Mon, 21 Jul 2025 10:01:06 +0000

Some organizations break things by moving too fast. Most break things by doing nothing at all. Inaction is comfortable. It looks responsible. Safe. “We’re just waiting until the platform matures.” But the bill is still running, just not where you’re looking.

Copilot Studio isn’t expensive because of licenses.

It’s expensive because of what happens when you treat it like a toy, or when you ignore it altogether.

The quiet cost of doing it wrong

You don’t need a catastrophic failure to lose money with Copilot Studio. You just need friction.

You don’t need a dramatic failure to lose money with Copilot Studio. Most of the time, it’s friction that wears you down. Maybe the agent was built in the default environment and published without a pipeline, so every update overwrites something; accidentally wiping out working logic. Maybe no one tested the prompts properly, so users keep escalating the same issue the bot was supposed to resolve. Or maybe the agent keeps quoting a SharePoint list that hasn’t been updated in six months, and now someone has to patch it manually every week to avoid embarrassment. Over time, teams start building their own versions of the same chatbot because no one wants to deal with the old one, and suddenly you’re supporting five slightly different agents that all sort of work, but none of them are governed. Eventually, users stop relying on them at all. No one complains; they just go back to asking colleagues for help. The usage metrics stay flat, but the trust has disappeared. And sometimes, the agent misses something critical, an escalation that never happens, a ticket that never gets filed. Nothing breaks immediately. It just doesn’t work when it matters. And now you’re firefighting a silent failure that started months ago.

None of this makes a headline. It just eats your time. Quietly. Relentlessly.

The invisible price of doing nothing

Then there’s the cost of inaction

Every time you delay deploying agents because “we’re not ready”, here’s what happens:

Teams fall back to inbox ops. Decisions happen in chat. Institutional memory erodes.
Knowledge stays locked in wikis no one reads. The same questions get answered by five different people.
Talent builds workarounds in Excel, again.
Innovation effort migrates to unmanaged tools. That cool use case? They built it with ChatGPT on their phone.

Action is expensive, but inaction costs a fortune. ~Shane Parrish

AI isn’t free, but the real costs aren’t where you think

Organizations love to obsess over license pricing. “Is it worth paying for Copilot Studio?” is just a variant of “Should we allow premium connectors?”

Valid questions, but wrong focus. The cost isn’t just in the platform. It’s in the architecture and culture that wrap around it:

Bad prompts are cheap. Bad decisions from bad prompts are not.
Loose environments don’t break until they do, publicly.
Slow agents trained on incomplete data don’t help, they damage trust.
“We’ll just let the team try it” becomes “we’re now supporting six shadow agents with no owner.”

Copilot Studio scales whatever you feed it. If that’s poor process design, you’ve scaled confusion. If it’s quality? You’ve scaled leverage. Either way, you’re paying for it.

Technical debt, now with conversational UI

Every Copilot Studio agent you build becomes a long-term relationship. That means:

Maintenance
Governance drift
Training new owners
Retiring old logic without breaking existing workflows

Ignore this, and you’re not saving time but postponing effort into future outages and context loss.

Cost isn’t a number, but behavior

The real expense isn’t what you spend. It’s what your team learns is acceptable. Agents with vague logic and brittle actions teach people that automation is unreliable. Agents that get quietly deprecated teach people that automation is disposable. You build capability through repetition, reuse, and reliability. If every agent is a one-off, every failure resets trust.

This is what scale looks like

The question isn’t “should we use Copilot Studio?”
The question is: “what does it cost us to do nothing well?”

Because when you don’t act, you pay in:

Missed signals
Fragmented knowledge
Inconsistent responses
Developer frustration

Not all tech debt comes from overbuilding, a lot comes from under-deciding.

🌵 I’m curious: did you ever take the time or effort to calculate that? Or do you work in a company where that doesn’t matter, because we’ve always done it like this? Lemme know.

Coming up next

Part 0: Everything is an agent, until it isn’t
Part 1: When automation bites back – autonomy ≠ chaos
Part 2: Copilot Studio: Part 2 – Copilot Studio agents: the ALM reality check
Part 3: The cost of (in)action – what you’re really paying for with Copilot Studio [📍 You are here]
Part 4: Agents that outlive their creators – governance, risk, and the long tail of AI
Part 5: From tool to capability – making Copilot Studio strategic

Smart buttons for incident tracking in SharePoint

Wed, 16 Jul 2025 07:25:44 +0000

Incident tracking in SharePoint lists often involves too many clicks. Users need to open each item, change a value, wait for the value to be saved, and hope they didn’t miss anything. With JSON column formatting and Power Automate, this process can be streamlined using inline action buttons.

Use case

A SharePoint list tracks incidents with fields for title, priority (low, medium, high), and status (new, in progress, resolved). To improve efficiency, two buttons are added directly in the list view:

Escalate: triggers a Power Automate flow to notify a manager
Resolve: triggers a flow to mark the item as resolved

Both buttons are conditionally enabled: Escalate is only active when Priority = high, Resolve is only active when Status ≠ new

SharePoint List setup

Create a list with the following columns:

Title (single line of text) (it’s already there)
Priority (choice)
Status (choice)
Actions (single line of text; used for formatting only)

Power Automate flow setup

Create two flows in Power Automate:

Escalate flow: Use “For a selected item”, then notify the people you like this to receive or start any other protocol that you might already have in place
Resolve flow: Same trigger, update the Status column to be resolved and maybe send some message to the person who raised the incident

Copy the Flow IDs from their URLs.

Apply JSON formatting

Go to the Actions column → Column settings → Format this column. Paste the JSON below (replace the Flow IDs):



{
 "$schema": "https://developer.microsoft.com/json-schemas/sp/v2/column-formatting.schema.json",
 "elmType": "div",
 "style": {
 "display": "flex",
 "gap": "10px",
 "justify-content": "center"
 },
 "children": [
 {
 "elmType": "button",
 "txtContent": "Escalate",
 "style": {
 "background-color": "=if([$Priority] == 'high', '#287b7d', '#e0e0e0')",
 "color": "=if([$Priority] == 'high', 'white', '#888888')",
 "border": "2px solid transparent",
 "padding": "6px 12px",
 "border-radius": "4px",
 "cursor": "=if([$Priority] == 'high', 'pointer', 'not-allowed')",
 "font-weight": "600",
 "margin": "2px",
 "box-sizing": "border-box"
 },
 "customRowAction": {
 "action": "executeFlow",
 "actionParams": "=if([$Priority] == 'high', '{\"id\": \"<FLOWID_ESCALATE>\"}', '')"
 }
 },
 {
 "elmType": "button",
 "txtContent": "Resolve",
 "style": {
 "background-color": "=if([$Status] == 'new', '#f0f0f0', 'transparent')",
 "color": "=if([$Status] == 'new', '#aaaaaa', '#287b7d')",
 "border": "2px solid #287b7d",
 "padding": "6px 12px",
 "border-radius": "4px",
 "cursor": "=if([$Status] == 'new', 'not-allowed', 'pointer')",
 "font-weight": "500",
 "margin": "2px",
 "box-sizing": "border-box"
 },
 "customRowAction": {
 "action": "executeFlow",
 "actionParams": "=if([$Status] != 'new', '{\"id\": \"<FLOWID_RESOLVE>\"}', '')"
 }
 }
 ]
}

How it works

The root element is a div that acts as a container for the buttons, and we apply flexbox styling to align buttons horizontally with spacing between them. All buttons are nested inside the children array. We add conditional styling and call a Power Automate flow when the button gets selected.

Outcome

Users can take action directly in the list view without opening the item. You can find this soon as a sample in the PnP Listformatting repo - PR got approved ✨

Assumption is the mother of all fuck-ups

Wed, 16 Jul 2025 05:25:44 +0000

The comforting danger of “we assumed…”

You’ve heard the saying: assumption is the mother of all fuck-ups. It’s crude, yes, but also painfully accurate. Trust me, been there.

“We assumed each customer would have one account”
“We assumed the Excel template wouldn’t change”
“We assumed we would only need one language”

These statements don’t come from bad developers. They come from teams under pressure, moving fast, or trying to make progress without full information. It feels efficient to move forward based on a shared understanding, or at least a silent one. But that’s the trap:

Assumptions feel like alignment. They’re not. They’re just unspoken bets.

How assumptions show up in software

Assumptions are easy to spot in hindsight. They’re harder to catch in the moment because they’re embedded in our tools, our conversations, and our diagrams. You’ll find them:

in requirements that gloss over edge cases
in data models designed for the “happy path”
in architecture diagrams that skip error handling
in user stories with no alternate flows
in test plans that only test what we expect to happen

They hide behind “default settings”, “temporary workarounds”, and “this should be fine.”

Real-world fallout

Some examples I’ve seen in real projects:

A warehouse app that assumed every product would have a barcode. Then a shipment arrived from a new supplier—with no barcodes. The team had to manually override 300 entries.
A SharePoint site that assumed everyone would use the default language. Then came a merger with a French team, and suddenly no one could find the documents they needed.
A Power Platform solution that assumed the requester of a task would always be the one to approve it. It worked beautifully—until vacation season hit and tasks piled up with no fallback path.

None of these were technical failures. They were assumption failures.

We assume to move faster. It helps us act when things are uncertain, unclear, or politically tricky. Some assumptions are born out of survival—others out of status, fear, or comfort. And the ones we never say out loud? Those are the most dangerous. They’re not just technical; they’re cultural, emotional, or territorial. That’s why in complex orgs, the riskiest assumptions are often the ones no one is allowed to question.

The most dangerous kinds of assumptions

Let’s call them out. Here are some of the worst offenders:

Assumption Type	Example	What really happened
User behavior	“Users will always finish the form in one go.”	They got a Teams call halfway through and closed the tab
Data shape	“Every entry will have a unique ID.”	Except for the ones copied from a legacy system, those were all blank
Organizational clarity	“Everyone understands what ‘urgent’ means.”	Turns out, it means “maybe next week” to one team and “drop everything now” to another
Tool stability	“That Excel template won’t change structure.”	Someone added three columns and changed the headers. Quietly. On a Friday
Language/culture	“Date formats? Everyone uses dd/mm/yyyy, right?”	Until the US team joined and booked a meeting for the wrong day. Twice
Connectivity	“The app will always have network access.”	Except in the warehouse. Or on the train. Or when VPN dies
Ownership	“That’s the API team’s problem, not ours.”	The API team said the same about you. Nothing got fixed

These feel safe, until one breaks, and it’s your team scrambling at 2 a.m.

How to catch them before they catch you

Assumptions aren’t inherently bad. You need them to move forward. But they should be explicit, testable, and ideally temporary. Here are a few ways to surface them early:

Say them out loud. Literally start a meeting with: “Let’s list our assumptions.”
Challenge default values. “Why is that the default? What if it’s wrong?”
Use assumption mapping. A whiteboard or Miro board with three columns:
- What we think is true
- What we’ve confirmed
- What we need to find out
Add assumptions to your backlog. Track them like risks or tech debt.
Involve people outside your bubble. Someone from sales, support, or compliance will spot gaps you missed.

And a favorite: ask the team, “What would really surprise us later?” The answers usually surface the biggest hidden assumptions.

Spotting assumptions is the first step. But what do we do with them? That’s where validation comes in.

How to validate assumptions without killing momentum

It’s one thing to spot an assumption; it’s another to do something useful with it. The goal isn’t to eliminate all risk, but to expose the shaky ground before it becomes a crater. Here’s how we turn assumptions into validated decisions inside an agile setup:

1. Prototype early, and for the right reasons

Use quick spikes or throwaway prototypes specifically to test assumptions. Not to build a solution, but to answer a question:

Will this work with our existing system?
Does the user actually understand this flow?
Can we really get that data from that source?

2. Make assumptions visible in your backlog

Log them like you would bugs or tech debt. Use tags like @assumption, or write stories like:
As a team, we need to confirm that customers can link multiple accounts to their profile.

This keeps the risk visible and gives you a chance to prioritize actual validation work.

3. Include assumption checks in definition of ready

Before a story goes into a sprint, ask:

What are we assuming here?
Can we test or demo this assumption?
What would we do if it’s wrong?

This prevents hidden dependencies from sneaking into sprint commitments.

4. Demo failures, not just successes

In sprint reviews, don’t just show what worked. Show what you tested and ruled out. It builds trust and makes it safe to admit uncertainty early.

Closing thought

Software fails quietly when we act on things we hope are true. It fails loudly when we act on things we assume are true. The fix isn’t endless documentation or 500-question checklists. It’s building a habit of naming our guesses and replacing them with knowledge when it counts.

Make it safe to ask “what are we assuming here?” in every room. It’s not a sign of indecision; it’s a sign you want this thing to actually work.

Copilot Studio: Part 2 – Copilot Studio agents: the ALM reality check

Tue, 15 Jul 2025 06:53:41 +0000

You’ve built a Copilot Studio agent. It works in the demo. It talks to systems. You click “Publish” and it goes live. Except… nothing about this is live in the way that matters. No pipelines. No environments. No version control. No audit trail. No rollback.

If that’s your lifecycle, you haven’t shipped an agent. You’ve just made a sandbox louder.

What “Publish” actually means

Clicking Publish in Copilot Studio updates the current version of your agent to all connected channels:Teams, Microsoft 365 Copilot Chat, web, mobile, Azure Bot Service. It’s a channel push, not a deployment pipeline. That distinction matters. If you’re working in your default environment and using Publish as your release mechanism, you’re bypassing everything that makes software resilient. Your logic goes live immediately. There’s no formal test phase. No way to rollback. And probably no documentation of what changed since the last release.

Why environments matter

Copilot Studio is part of the Power Platform stack. That means it inherits all the good, bad, and critical enterprise realities that come with it: environment isolation, solution packaging, data loss prevention (DLP), tenant-wide governance controls.

The default environment isn’t meant for production. Microsoft explicitly recommends moving agents to dedicated environments. In the default, every user is an environment maker by default; there’s no permission isolation and no connector guardrails unless you enforce them yourself.

Real deployments need a real environment strategy. That typically means separating development, testing, and production into distinct environments, each with its own access control, data boundaries, and connector rules. Microsoft calls this a “governance zone” model: Safe Innovation, Collaboration, and Enterprise zones. And yes, your agents should be living in those, not all lumped into one chaotic playground.

Solutions and pipelines are not optional

Agents in Copilot Studio are solution-aware Dataverse components. That means if you’re not using solutions, you’re not doing lifecycle management; you’re editing in production 😱.

Once your agent is in a solution, you can export and import it across environments. You can also integrate it into Power Platform pipelines. So yes, ALM is very much real and supported.

This unlocks proper versioning, change tracking, rollback support, and environment-specific configuration. The stuff that makes the difference between “This works” and “This won’t break everything tomorrow.”

Agent types are not all created equal

There’s a world of difference between a retrieval agent that fetches answers from SharePoint and an autonomous agent that acts on real-time signals without being asked.

Copilot Studio supports three official agent types: retrieval, task, and autonomous. Retrieval agents are the least risky; they work off structured knowledge and user prompts. Task agents are a step up: They use flows or APIs to take action. Autonomous agents operate on triggers, make decisions, and act independently.

Each category ramps up the governance requirements. Retrieval agents need decent content hygiene. Task agents need guarded connector access and flow versioning. Autonomous agents need escalation logic, fallback paths, and real-time monitoring.

If you treat them all the same, especially in terms of deployment and testing, you’re walking into operational debt with your eyes closed.

Publishing to a channel doesn’t mean you deployed anything

Just because your agent is live in Teams or shows up in Microsoft 365 Copilot Chat doesn’t mean you’ve deployed it properly.

Channels are UI. Environments are infrastructure.

If your agent wasn’t authored, tested, and promoted through a structured pipeline, it’s not production-grade. It’s just a lucky preview.

💡Read more about Friends don’t let friends right-click publish.

Governance isn’t a checklist, it’s a living contract

Copilot Studio ships with strong governance capabilities. You can restrict who can share agents, limit connectors with DLP, apply sensitivity labels to protect data, and monitor usage with audit logs.

Admins can control which environments agents can be built in, which connectors are allowed per environment, and how agents are exposed to users, especially inside Microsoft 365 Copilot.

Most teams don’t configure these. So agents run on good intentions and shared credentials, not policy. And the moment that agent fails or acts on outdated data, or misroutes a workflow, everyone starts asking who signed off.

Beyond low-code: Integrating with AI Foundry and Copilot

Copilot Studio isn’t just for citizen developers anymore. You can bring in Azure AI Foundry models, register custom skills, and create orchestration flows across multiple agents. But these advanced capabilities assume you’ve already nailed the basics: environments, solutions, pipelines, versioning, audit.

If you haven’t? Don’t scale your chaos. Scale your discipline.

Bottom line

Copilot Studio gives you the ability to create digital agents that listen, respond, and act. But with that power comes a non-negotiable requirement: ALM. Clicking “Publish” is not a deployment strategy. It’s a risk multiplier.
Your agent is code. Treat it like code. Because sooner or later, your users (or worse, your auditors) will expect it to behave like a real system.

Coming up next

Part 0: Everything is an agent, until it isn’t
Part 1: When automation bites back – autonomy ≠ chaos
Part 2: Copilot Studio: Part 2 – Copilot Studio agents: the ALM reality check [📍 You are here]
Part 3: The cost of (in)action – what you’re really paying for with Copilot Studio
Part 4: Agents that outlive their creators – governance, risk, and the long tail of AI
Part 5: From tool to capability – making Copilot Studio strategic

'I’ll refactor this later': The lie that ships with every sprint

Sun, 13 Jul 2025 15:25:44 +0000

There’s a moment in nearly every development task where you hit a small decision:

Do I clean this up now?
Or do I just get it working and promise myself I’ll come back to it? 🤞🏻

The second option always feels easier. More efficient. Responsible, even: “I’m not skipping it forever, just for now.”

But I’ll let you in on a secret that you won’t like: “I’ll refactor this later” is just “temporary” in business casual.

What we really mean when we say it

We don’t say it because we’re lazy. We say it because we’re under pressure. Deadlines are tight. Test cases are half-written. Someone’s waiting for this component. The PR already has 27 comments.

So we choose to make the thing work, and tell ourselves we’ll tidy it up when there’s time. But time never comes back around. And the next time this function gets touched, the person working on it has no idea why the logic is split and there is a TODO comment referencing an old Jira ticket.

Refactoring later isn’t a decision; it’s a delay with interest.

The emotional debt of unfinished cleanup

Unlike bugs or broken tests, this kind of debt doesn’t throw alarms. It just slows us down, silently. Every bit of unclear logic, every reused variable name, every shortcut we meant to fix: it all adds to the mental friction of working in that codebase. You stop trusting functions. You start working around things. You duplicate instead of reusing. And slowly, delivery speed drops.

We don’t notice the cost until it’s too late; until someone says the words we all dread:

“Should we just rewrite this?”

The decision to delay cleanup turns into a silent tax that compounds over time. It becomes harder to add features. Harder to test. Harder to onboard new teammates. We build tools to work around complexity we created ourselves. And worst of all? The code starts to feel hostile. You avoid touching certain files. You write messages that start with “sorry for this question…” You start dreading the next release.

When later doesn’t come

Yes, it rarely does. Even when we create tickets for cleanup, they sit in backlog purgatory. Technical debt doesn’t scream. Features do (or your PM). And unless you have strong engineering culture, proactive refactoring doesn’t happen by default.

Teams change
Context gets lost
Priorities shift

The person who wrote the code may never come back to it. And if they do, it’ll be six projects later, with no memory of what they meant to refactor. In practice, “later” becomes a black hole. Anything sent there is gone for good unless a heroic effort drags it back into the light.

The Jira ticket myth

Sometimes, to feel better, we create a “Refactor XYZ later” issue in Jira. At best, this is documentation of intent. At worst, it’s a digital guilt trap that no one will open again. If your definition of done requires you to create a follow-up ticket for every refactoring you skip, ask yourself: How often do those tickets actually get picked up?

Do they live in a “Tech Debt” column that’s never part of sprint planning? Are they invisible to the product owner? Are they always at the bottom of every grooming session? If the answer is “almost never”, then the ticket isn’t a fix. It’s a way to feel like you’ve done the responsible thing, without actually doing it.

Refactor tickets are only useful if:

They’re prioritized like real work
They’re short-lived
They have enough context to be actionable later

If not, they’re just the long-form version of “I’ll refactor this later”. Worse, they give teams a false sense of closure. The real work hasn’t been done. But it’s been moved. Abstracted away. And eventually forgotten.

Real cleanup isn’t heroic; it’s incremental

“I’ll refactor this later” is seductive because it feels pragmatic. But truly sustainable teams do the opposite: they refactor as they go, in small, low-risk steps.

That doesn’t mean polishing everything. It means for example:

Renaming variables, functions, or classes so they express intent more clearly
Extracting logic into smaller functions to make code easier to read and reuse
Inlining unnecessary abstractions when they add no value
Eliminating duplication
Removing dead code and collapsing over-engineered conditionals
Writing a small test before making a change so that the safety net exists—even if retrofitted

You don’t need a big refactor week. You need a culture where small, continuous improvements are normal. A culture that rewards care, not just output. And this culture doesn’t come from tools or templates, but from how teams talk about quality. It comes from leaders making space for cleanup. From reviews that notice and encourage thoughtful structure.

Shipping clean-ish code

Clean code isn’t a goal; it’s a habit. And habits don’t form around vague future promises. They form in the moment you almost say “later”… and then fix it anyway. It’s not about perfection. It’s about reducing friction. It’s about building code you can come back to, not with fear, but with confidence.

You don’t need to refactor everything. You just need to stop lying to yourself.

Leave it better than you found it. And don’t let “later” mean not never.

There are no temporary fixes (just permanent shortcuts)

Mon, 07 Jul 2025 15:25:44 +0000

A while back, I wrote about A hill to die on: there are no tiny changes, just changes we underestimate. If you missed it, give it a read. But there’s a related myth we need to dismantle: “It’s just a temporary fix.”

Ah yes, the sacred chant of backlog triage. We all know how it goes:

“This is just to get us unblocked.”

“Let’s be pragmatic; we’ll clean it up later.”

“We’ll write a proper solution next sprint.”

Spoiler: we won’t.

When did temporary start meaning indefinite?

Once a fix goes live, it’s not temporary; it’s a default. It becomes part of how the system works, how people rely on it, how your future self has to navigate it. That workaround? It’s now someone’s expectation. That duct-taped dependency? It’s in production, baby. Every “just for now” decision is a long-term liability waiting for an excuse to dig in its heels.

We ship intent, not just code

Think about it. That quick-and-dirty fix ships with no expiration date, no conditions, no built-in cleanup plan. And nobody, not the code, not your CI pipeline, not the product owner, is going to magically remember to “circle back”. So it stays. And much like I argued in tiny changes, even the smallest-seeming fix can have wide ripple effects: Unexpected bugs. Fragile dependencies. Future blockers. All because we told ourselves this wasn’t the real solution. But it is. It’s live. It counts.

The real problem: we treat code like a whiteboard

We think we can scribble something quick and erase it later. But software doesn’t work like that. Once it’s deployed, it’s not just code:it’s behavior. It has inertia. It gets integrated into other things. The longer it sits there, the harder it is to untangle. So we end up building systems that are a patchwork of “for now” glued together with hope and good intentions.

What we should say

Instead of calling it a temporary fix, be honest about what you’re doing:

“This is a compromise with risk”
“We’re introducing technical debt deliberately”
“We’re choosing speed over sustainability”

Then, if you go ahead with it:

Write it down like a bug Don’t hide it behind a TODO; give it an owner and a deadline.
Make the cost visible. Add it to the roadmap as real work, not invisible hope.
Flag it in review. Code reviewers should treat “we’ll fix this later” as a blocker unless there’s a plan.

Let’s stop pretending our shortcuts don’t have long-term consequences. If we keep saying “we’ll fix it later” without specifying when and how, we’re not just lying to others, we’re lying to ourselves. You can’t measure what you won’t acknowledge. You can’t clean up what you never wrote down. And you sure as hell can’t call something “temporary” if there’s no plan to remove it.

So the next time you feel the urge to sneak in a fix and promise yourself it’s only for now, just remember:

There are no temporary fixes. Only permanent shortcuts you haven’t regretted yet.

Introducing QR Watchface: Your wrist’s new best friend

Sat, 05 Jul 2025 08:14:38 +0000

Ever wanted to share your LinkedIn profile straight from your Apple Watch, without fumbling for your phone? I’ve built something that makes it simple: QR Watchface, a sleek web app that turns any URL into a perfectly sized, scannable QR code for your watch face.

Why QR Watchface?

Imagine this: You’re at a conference, or maybe a coffee meet-up, and you want to share your LinkedIn profile, but pulling out your phone and opening the app just isn’t fast enough. With QR Watchface, you get an instant, one-click solution. It generates a clean QR code, adds extra margin for visibility around your watch’s clock, and lets you download a polished image optimized for your Apple Watch face.

And the best part? You can personalize it: Match the event’s color scheme or use your favorite colors. You get a QR code that looks good and works well.

Here’s the magic in a nutshell

Choose your QR code and background colors, see the updates live, and get a quick warning if the contrast isn’t up to accessibility standards.
Rounded corners, gradients, and a minimal pill-shaped download button. It’s sleek, polished, and feels right at home on iOS.
The app exports a 4:5 aspect ratio PNG with your QR code at 70% scale, positioned perfectly at the bottom so your clock doesn’t interfere.
Full support for dark mode and built-in contrast checks to meet WCAG standards, ensuring your QR code is always easy to scan, day or night.

How it works

The app checks the WCAG 2.1 contrast ratio in the background, so if your color choices fall below the minimum 4.5:1 contrast ratio, you’ll get a warning. Once you’re satisfied, hit Download and get a crisp, watch-ready PNG.

Accessibility matters (and it makes scanning easier!)

Accessibility isn’t just about making sure everyone can read your QR code, it’s about ensuring a better scanning experience for everyone. By enforcing high-contrast colors, not only do we make sure it’s easy to read for people with visual impairments, but we also make scanning faster and more reliable for anyone. Low-contrast codes can lead to failed scans, but with clear, high-contrast combinations, your code will be read in one go—no more awkward “Can you try again?” moments.

Give QR Watchface a try!

Let me know what you think! I’d love to hear your feedback: https://qrwatchface.netlify.app/

What Tinder🔥 taught me about bad Dataverse design

Sat, 05 Jul 2025 08:14:38 +0000

It started with a fish. Or more accurately, a fish pic guy. You know the one: holding up a trout like it’s a personality. And when I saw Sara Lagerquist compare him to local choices in Dataverse, I couldn’t unsee it. (She really did.)

Suddenly, the entire dating app experience started looking like a metaphor for Power Platform architecture. The red flags, the weird flexes, the mysterious disappearances, it’s all there. So here it is: my lovingly curated list of toxic Tinder traits and their Power Platform equivalents. And most importantly: what we really really want instead 💅.

🚩 “Just here for fun”

Tinder version: No intention of building anything serious.

Dataverse version: Apps are built in personal environments and shared informally, often with no use of solutions at all.

Why it’s bad: Personal environments are tied to an individual user. If that user’s license changes or they leave the organization, apps and flows can become inaccessible or break. There is no backup mechanism, no structured deployment, and no visibility for admins.

What we really really want: Use Managed solutions in real environments, supported by application lifecycle management. Adopt a Dev → Test → Prod structure using solution export/import, pipelines, and service accounts for ownership continuity.

🚩 “5'9 because apparently that matters”

Tinder version: Insecure flexing
Dataverse version: Spends hours fine-tuning view layouts: adjusting column widths, alignment, and font size, while ignoring form usability or data model design.

Why it’s bad: Aesthetic tweaks at view level don’t improve the user experience if forms are cluttered, poorly grouped, or not optimized for mobile. This leads to low adoption, frustrated users, and avoidable support tickets. Prioritizing cosmetics over structure signals a lack of UX maturity.

What we really really want: Design for usability. Use tabbed forms, card sections, responsive layouts, and define view columns based on meaningful business fields — not visual symmetry. Test across devices and screen sizes.

🚩 “Sapiosexual”

Tinder version: Claims to love intelligence, but mostly just wants to sound smart
Dataverse version: Mentions GPT, AI Builder, vector embeddings, or Copilot Studio without having clean data, a clear prompt strategy, or a licensing model that supports usage.

Why it’s bad: Deploying generative AI on top of unstructured or incomplete data (e.g., notes columns, plaintext metadata, inconsistent tags) results in unreliable output. Using OpenAI connectors without cost control leads to unpredictable billing. Overengineering AI features can also distract from core user needs.

What we really really want: Use AI intentionally. Invest in data preparation (structured columns, correct datatypes, standardized tags), and choose Copilot Studio or Azure AI integrations only when they serve a real business goal. Document model dependencies and cost implications.

🚩 “Van life guy”

Tinder version: Free spirit with zero stability

Dataverse version: Uses trial environments or developer environments for apps with live business users or production data.

Why it’s bad: Trial environments are temporary! Flows using premium connectors may break when the environment expires. Admins cannot enforce policies or guarantee data recovery. Trial environments also do not support secure ALM or production SLAs.

What we really really want: Use sandbox and production environments with environment-level governance. Apply DLP policies, define security roles, and ensure retention policies are in place. Trials are for demos and experiments, not business-critical workflows.

🚩 “Crypto bro”

Tinder version: Obsessed with hype, overconfident, and always promising exponential returns.

Dataverse version: Frequently rebuilds the solution architecture based on trends, switching from Canvas to model-driven, then to Power Pages, without completing any of them or defining a long-term data model.

Why it’s bad: Changing technologies mid-project creates confusion, duplicate work, and inconsistent user experience. It also disrupts security planning, licensing, and support handover. Teams lose trust in the platform and developers when nothing is stable for more than a sprint.

What we really really want: Define a stable architecture. Choose between Canvas, Model-driven, or Power Pages based on use case, user roles, and licensing; and commit to the model. Use technical design documents and decision logs to guide change intentionally, not impulsively.

🚩 “Let’s go on an adventure”

Tinder version: Spontaneous. Dangerously so.

Dataverse version: Builds large Power Automate flows with 30+ actions, nested conditionals, and multiple connectors — with no naming conventions, no error handling, and no retry logic.

Why it’s bad: When a flow fails, it’s difficult to troubleshoot without clear naming or scope grouping. Missing error handling leads to data loss or incomplete processes. Lack of logging makes audit trails impossible. Complex flows are harder to maintain and scale.

What we really really want: Use scopes to group logic, apply Configure Run After for error handling, and compose actions to isolate reusable logic. Document flows with comments and consistent naming. Build for readability and monitoring. Practice makes progress.

🚩 “Guy who ghosted”

Tinder version: Promises the world; then vanishes

Dataverse version: Delivers a working app in an unmanaged solution and disappears; leaving behind undocumented business rules, JavaScript, and custom plugins with no source control.

Why it’s bad: Unmanaged solutions in production environments are mutable. Changes won’t be tracked, and deploying updates can overwrite important customizations. With no documentation or ALM pipeline, maintenance becomes guesswork.

What we really really want: Use managed solutions in production and commit solution versions to source control. Document everything. Use pipelines or at least manual export/import with release notes.

🚩 “My ex was crazy”

Tinder version: Never their fault. Always someone else’s. Dataverse version: Blames Microsoft for everything: Slow forms, broken flows, weird errors; when it’s really their own unsupported JavaScript, sloppy plugin code, or broken logic.

Why it’s bad: You’ve seen it: a form throws an error, and the first reaction is “Dataverse is buggy”. But dig a little deeper, and there’s a JavaScript function that silently fails. Or a flow that references a deleted column. None of it logged. None of it tested. Instead of fixing the issue, they escalate to IT, file support tickets, and rant in Teams, Reddit, and LinkedIn. Meanwhile, the real problem is still buried in unmanaged code.

What we really really want: Take ownership. Write code that fails loudly and clearly. Use try/catch, trace logs, and show meaningful error messages to makers. If you add complexity, document it. Don’t blame Microsoft for problems you created; especially if you’re the only one who can fix them.

Final thoughts: Tell me what you want

We’ve all made red-flag decisions in Power Platform. Maybe you built that flow at midnight. Maybe you skipped governance “just this once”. Maybe you were the fish pic guy. But we can do better.

So next time you design an app, a flow, or a solution:

Be someone your future team would swipe right on.

Be someone who leaves behind clarity, not cleanup.

Stop pretending your text is bold: why fake formatting breaks accessibility

Fri, 04 Jul 2025 18:29:45 +0000

We need to talk about something that keeps showing up in LinkedIn posts, company updates, and personal branding pep talks: fancy fake bold text. You’ve seen it. You’ve maybe even used it.

𝗟𝗶𝗸𝗲 𝘁𝗵𝗶𝘀, or 𝘁𝗵𝗶𝘀, or even ⓉⒽⒾⓈ.

💡 For everyone using a screenreader: There is a line that uses unicode characters to display something that resembles bold letters. Screenreaders can’t interpret these characters.

💡 For everyone not using a screenreader: Try CTRL + Shift + U in your browser, ot should enable the Read aloud feature for some aha effect

It looks cool, sure. It grabs attention. But it’s also a nightmare for screen readers, completely unsearchable, and let’s be honest: it’s a trick. A formatting hack. And the people using it usually know exactly what they’re doing.

What’s the trick?

LinkedIn doesn’t support bold text, italic, or even basic markdown formatting. So people turn to Unicode font generators: little tools that replace your normal letters with characters from obscure parts of the Unicode table that look bold, italic, or fancy. And yes, it makes the post stand out visually in the feed. That’s the whole point. But it comes at a cost.

It’s not formatting — it’s a lie.

When you type 𝐁𝐨𝐥𝐝, you haven’t added formatting. You’ve swapped normal, readable letters for mathematical symbols. To a screen reader, that’s not “bold”. That’s:

“Mathematical Bold Capital B” Or worse: nothing at all. People who rely on assistive tech won’t hear your clever headline. They won’t get your message. Because your entire paragraph just vanished into something they can’t read or understand. And it gets worse…

And no, it’s not searchable either

This trick also breaks basic functionality like search and indexing. If you write 𝐩𝐫𝐨𝐝𝐮𝐜𝐭𝐢𝐯𝐢𝐭𝐲 with fake bold letters, nobody searching for “productivity” will find it. It won’t show up in: LinkedIn search, sometime snot even in browser text search (CTRL+F), SEO indexing and translation tools. It looks like content. But it’s actually just noise. So yes, it’s a trick. And using it to game the feed while leaving part of your audience behind? That’s not clever. That’s unethical. Screen readers don’t see your branding tricks — they parse your intent. If it only works for sighted users, it doesn’t really work. Using formatting hacks to game the feed is tempting, especially when real formatting tools aren’t available. But building attention on the back of accessibility gaps is a dirty move.

Your content should be visible, readable, searchable, understandable. For everyone. If it’s only beautiful to people who can see and ignore the technical glitches, you’ve missed the point.

The real flex? Writing that works for everyone

Using fake formatting to stand out is like putting neon stickers on a car that doesn’t run. It looks good parked. It fails the second someone tries to interact with it. Real professionals know how to write clearly, structure simply, and communicate accessibly. So before you paste in that shiny Unicode headline …Ask yourself:

Am I being clever, or just unreadable?

Spoiler: the best posts are both stylish and searchable.

Copilot Studio: Part 1 – when automation bites back – autonomy ≠ chaos

Wed, 02 Jul 2025 18:29:45 +0000

Autonomy scares people. Not because they’re against AI. They’re against losing control, and rightly so. Most organizations aren’t afraid of what their Copilot Studio agent might do. They’re afraid of what it might do without asking. And yet, that’s the whole point of agents. If you need a human in the loop for every decision, you didn’t build an agent. You built a clunky wizard. Autonomy, done well, is not chaos. Autonomy, done well, is clarity. But clarity takes work. And most deployments skip that part.

[Sidenote: I hope you know this character:]

Autonomy is not a vibe

There’s a misconception that autonomy is a checkbox or a personality trait. As if some agents are independent and others are obedient. But autonomy isn’t about tone. It’s about timing, trust, and triggers. An autonomous agent doesn’t ask before it acts. It listens for signals. It builds a plan. It executes. Ideally, it also knows when to escalate. Not because you told it to in a script, but because it understood the stakes. That’s not advanced AI. That’s just responsible system design. Never heard about that? Might be a good idea to talk :-)

Agents don’t hallucinate: people hallucinate them

Here’s the uncomfortable truth: most agent hallucinations aren’t the model’s fault. They’re design failures. Someone told the agent it could retrieve knowledge and take action, but never clarified when to do which, or how to resolve conflicts between instructions and context.

The mess isn’t in the model. The mess is in the instructions we shipped and forgot to version.

[💡 So in case you haven’t talked to me in a while: everything is code and should be in source control for versioning and traceability.]

This is where autonomy becomes dangerous: not because the agent is too powerful, but because the environment around it is too fuzzy. No escalation logic. No fallback plans. No logging that anyone actually checks. It’s not that the agent acts alone. It’s that no one takes responsibility when it does.

Autonomy needs a job description

Want autonomy that doesn’t backfire? Treat your agents like new hires. They need

Clear goals
Explicit limits
A decision framework
Supervision that kicks in only when needed

In fact, the best mental model might be onboarding a junior colleague. You teach them how to handle 80% of cases. They ask for help on edge cases. Eventually, they escalate less because they’ve learned more. The difference? Your agents won’t magically learn unless you build for that too.

“Let’s start with retrieval” is how you stay stuck

Organizations love to “start simple.” Let’s build a retrieval agent. Let’s just do FAQs. Let’s just surface policy links. That’s fine—if the goal is to stall. Because retrieval agents don’t scale business value. They reduce helpdesk noise, maybe. But they don’t change how work gets done. The moment you want the agent to take action (submit a request, assign a case, file a report) you’ve stepped into task or autonomous territory. And if your architecture, data model, and governance aren’t ready? You’re back to waiting for a human to fix it.

Build trust into the agent, not around it

We don’t need to wrap every agent in disclaimers and safety rails. We need to build trust into the agent’s behavior. That means:

Explainability: show users how the agent reached a conclusion
Escalation: hand over control gracefully when the agent isn’t confident
Containment: don’t let one bad action cascade across systems
Auditability: store not just what the agent did, but why

Autonomy isn’t the enemy. It’s the maturity test. And right now, too many orgs are failing it.

Coming up next

Part 0: Everything is an agent, until it isn’t
Part 1: When automation bites back – autonomy ≠ chaos [📍 You are here]
Part 2: Copilot Studio: Part 2 – Copilot Studio agents: the ALM reality check
Part 3: The cost of (in)action – what you’re really paying for with Copilot Studio
Part 4: Agents that outlive their creators – governance, risk, and the long tail of AI
Part 5: From tool to capability – making Copilot Studio strategic

Copilot Studio: Part 0 – everything is an agent, until it isn't

Sun, 29 Jun 2025 04:35:21 +0000

We’ve entered the age of automation. But most organizations are still treating it like the age of macros. A little generative garnish, a few nicely structured prompts, and suddenly every flow is called an agent. It sounds impressive until you try to scale it. Then the cracks start to show. Copilot Studio is not just another way to automate tasks. It’s an entry point into something much more ambitious, and much more dangerous: systems that act, not because a user clicks a button, but because they’ve been instructed to think, plan, and respond to context. Before we can talk about building anything meaningful, we have to stop calling everything an agent.

The assistant illusion

There’s been a narrative shift in AI; from tooling to teaming. Instead of apps and workflows, we now talk about assistants and agents. But that language obscures a fundamental difference.

Microsoft 365 Copilot is an assistant. It augments the user
Copilot Studio is where you build agents: systems that can reason and act

If M365 Copilot is here to help you work, Copilot Studio is here to replace part of that work.

This isn’t about putting a friendlier face on automation but about changing the nature of responsibility. Because once you ship an agent, you’re no longer guiding the outcome. You’re defining intent, and trusting the system to interpret it.

Microsoft 365 Copilot lives inside documents, chats, and emails. You prompt it. It helps. It never acts without you.

Copilot Studio agents, however, are defined by behaviors. They can

Act on external systems (e.g., submit a return, open a support case)
Make decisions based on knowledge and instructions
Initiate workflows triggered by events, not just user prompts

When done right, this enables a new class of applications. When done badly, it introduces subtle, scalable chaos. And if you read on LinkedInm, you could get the impression, that everyone is succeeding in agentic AI. This reminds me a bit about a quote by Dan Ariely, who said “Big Data is like teenage sex: everyone talks about it, nobody really knows how to do it, everyone thinks everyone else is doing it, so everyone claims they are doing it.” - Replace “big data” with “AI” 💅

If everything is an agent, nothing is

The overuse of the word “agent” is a problem. A chatbot that answers FAQs is not an agent. A scripted topic with static buttons is not an agent. A flow that posts a Teams message on Mondays is not an agent. These things are useful, but they don’t think, plan, or act autonomously. (In a more rigid sense, also agents can’t reason, that’s just us being helpless describing what AI does without using anthropomorphozing language)

Just because it uses AI doesn’t mean it’s intelligent. And just because it runs without code doesn’t mean it should run without oversight.

The Copilot Studio architecture allows for real agents. But it doesn’t enforce discipline. That’s your job. And most orgs aren’t ready; not because they lack the tools, but because they haven’t built the foundations.

Automation is not strategy

We’ve seen this play out before. The first wave of Power Platform was hailed as the democratization of development. What we got, mostly, was an explosion of disconnected apps and flows, each automating a tiny corner of a bigger mess. Now, with AI in the mix, the risk is even greater. Because these aren’t just workflows. They are delegated decisions.

The moment your system starts acting on your behalf, you’re responsible for what it thinks you wanted.

That’s a governance problem. It’s a testing problem. But most of all, it’s a design problem. You’re not just designing logic anymore. You’re shaping behavior. And behavior, once deployed, is sticky. It creates expectations. It teaches your users how to interpret system actions. If those actions are inconsistent, opaque, or worse: wrong, then you’ve just shipped dysfunction at scale.

What does your org actually need?

Here’s the unfortunately inconvenient truth: most organizations don’t need agents yet. They need clarity. They need to fix the ten-year-old knowledge base article that their chatbot keeps quoting. They need to stop reinventing the same FAQ bot for every department. They need governance before autonomy. But here’s what else is true: every organization will eventually need agents. The value is undeniable. The potential to offload repetitive work, to respond to signals in real time, to build proactive services: that’s the future. But you won’t get there by accident. You’ll get there by design.

Build or be built

The reason so many Copilot Studio projects don’t deliver the value that was promised in very pretty slides isn’t because of a technical gap. It’s because most organizations are still trying to run agent work inside assistant-era structures. Teams want agents that behave autonomously, but only within processes that are undocumented, inconsistently owned, and resistant to change. That’s not agent design. That’s wishful thinking 🤞🤞.

You don’t scale agents by writing better prompts. You scale them by fixing your operating model

Ask yourself:

Who’s responsible when an agent gives a wrong answer?
Who owns the lifecycle of that agent across environments?
How will it be monitored, retrained, versioned, retired?

If your org can’t answer these questions, you’re not building software. You’re building risk.

This is where we start

This blog series isn’t a walkthrough. It’s not a Microsoft-endorsed cheerleading campaign. It’s a practical, sometimes uncomfortable look at what Copilot Studio really demands: from your systems, your people, and your leadership. If you’re here to do more than build bots: If you want to architect capability, not just features. you’re in the right place.

This post is part of a blog series on Copilot Studio

Coming soon:

Part 0: Everything is an agent, until it isn’t [📍 You are here]
Part 1: When automation bites back – autonomy ≠ chaos
Part 2: Copilot Studio: Part 2 – Copilot Studio agents: the ALM reality check
Part 3: The cost of (in)action – what you’re really paying for with Copilot Studio
Part 4: Agents that outlive their creators – governance, risk, and the long tail of AI
Part 5: From tool to capability – making Copilot Studio strategic

Software development is a decathlon (and low-code only gives you running shoes for two events)

Tue, 24 Jun 2025 08:35:21 +0000

Software development is a decathlon (and low-code only gives you running shoes for two events)

Building apps with Power Apps feels easy. Drag some controls onto a canvas, connect to a SharePoint List, throw in a few formulas — ta-da! A working prototype.

Except… that’s not the race. That’s the warm-up.

Shipping real apps (you know, the ones that solve real problems, scale beyond one user, and don’t fall apart next month) is more like a decathlon. You’re not just doing one thing well; you’re juggling ten disciplines at once. And low-code helps with maybe two or three.

The real decathlon of software delivery

Here’s what it actually takes:

Requirement engineering Translating vague requests like “can you make it more user-friendly?” into testable, buildable, traceable features
Problem solving & edge case hunting Understanding the business logic behind the button, not just placing the button
Logical thinking & pattern recognition Building once, reusing often; not repeating the same formula across 27 controls
Syntax fluency Whether it’s Power Fx, JavaScript, or a flow expression; your logic still has to make sense, and perform
Data modeling Designing structures that can scale, not storing everything in one flat SharePoint list with 200 columns
UI/UX & accessibility Not just “looks fine on my screen”, but intuitive, inclusive, and mobile-friendly
Testing & quality assurance Writing clear test cases, automating where possible, and validating edge scenarios, not just hoping
Documentation & supportability If no one else can understand, update, or fix your app six months from now, it’s not a product; it’s a liability
Integration & maintainability Connecting systems in a way that survives password changes, API limits, and platform updates
Lifecycle management & accountability Versioning, auditing, knowing who owns what, and not deploying straight to production from someone’s trial environment

What Power Apps made easier

To be fair, low-code did remove some friction:

You can sketch out a UI fast
You can connect to data without writing custom code
You can build logic with Power Fx instead of full-stack frameworks

These are real advantages, especially for business users and prototyping. But let’s not kid ourselves. (at least not when nobody from MS is listening)

What’s still hard (and still matters)

You still have to do requirement engineering, even if the stakeholder is standing next to you.
You still need testing and documentation, especially when multiple people build on the same solution.
You still need to care about supportability, ownership, and accountability, because “the person who built it left the company” is not a great helpdesk answer.

And all those apps? They need to be maintainable and reusable, not a pile of one-offs duct-taped together in someone’s personal environment.

Low-code doesn’t remove complexity. It just delays it.

And unless you’ve trained for the full decathlon, it’ll hit you in production.

Fusion teams win races

Power Apps shines when it’s part of a fusion team setup: business experts, pro devs, testers, IT, ops, all pulling in the same direction. It’s not about replacing developers. It’s about speeding up delivery without compromising on the fundamentals: clarity, quality, accountability. Because building fast isn’t the point. Building well, fast: that’s the win.

Final lap: Know what race you’re in

Low-code is powerful. But it’s not a shortcut to quality. If you only train for the “fun” parts — the visual design, the first-click wow moment — you’ll be in trouble by lap three. The real work is the rest of the decathlon: Requirements. Testing. Ownership. Reusability. The things that make software work long after the demo ends. So yes; lace up those low-code running shoes. But don’t skip leg day. You’re still in the full race.

Test Less. Test Better: The Modern Testing Stack

Tue, 17 Jun 2025 07:01:35 +0000

Fewer tests. Faster feedback.

Testing is broken; not because we don’t do it, but because we waste time doing it wrong. We obsess over unit tests that don’t matter. We write coverage reports that lie. We mock everything until our app is disconnected from reality. Then we go live and wonder why things break. Again.

The test pyramid wasn’t meant to be worshipped

The old test pyramid said: write lots of unit tests, fewer integration tests, and just a sprinkle of UI tests. That made sense when systems were simple. When most logic lived in the same codebase. When APIs were internal and your frontend talked to your backend directly.

But those days are gone. (At least for me.)

Today, your app talks to other apps. It uses third-party services, runs across distributed infrastructure, and depends on config, roles, and runtime behavior that no unit test will ever see. And yet, most teams are still clinging to pyramids. They write thousands of unit tests for functions no one cares about and skip the tests that would have caught the real issues.

Test behavior, not branches.

So let’s flip it: test what users do, not how your code is organized. Or even better: realize, that there is no strict test hierarchy

Behavior beats coverage

Your users don’t care whether you’ve tested 95% of your lines of code. They care whether their invoice gets generated. Whether they can sign in with their corporate account. Whether that file upload still works when the internet drops for five seconds.

This is why behavior-driven testing matters. Tools like Playwright and Cypress let you simulate real user actions, not just internal logic. Instead of testing, Does this function return true? you’re testing, Can a manager with restricted access approve a report when the backend service is slow? These are tests that reflect production. They exercise critical paths. They surface regressions that matter. And they do so in a language everyone (from Dev to QA to Product) can understand.

Both Playwright and Cypress are CI-native. They integrate seamlessly with GitHub Actions and Azure DevOps. You can run tests across browsers, inject user roles, and simulate flakiness, all automatically, on every PR. Behavior-first testing isn’t slower. It’s smarter. Because when it fails, you know something real is broken.

Mocks hide the truth. Contracts reveal it.

Most test environments are fake. We mock the API, stub the database, simulate users, and then celebrate that everything passes. Until production doesn’t. Why? Because mocks don’t tell you when something changed upstream. They don’t alert you when a provider you depend on adds a required field or renames a response property. The mock stays the same. But reality moved on.

Contract testing fixes that.

Tools like Pact and PactFlow don’t just mock, they verify. They let consumers define the behavior they expect from a provider: If I send this request, I expect that response. And then they check that the provider still honors that agreement. This isn’t the same as validating against an OpenAPI spec. Swagger-based tools are useful for structural checks, but contract tests go deeper. They verify real behavior across real services. You stop wondering whether the integration still works. You know it does.

Accessibility is not a nice-to-have

Most teams still treat accessibility like something they’ll get around to. Maybe someone runs a Lighthouse scan. Maybe someone files a bug. Maybe someone sues you.

Accessibility isn’t just a checklist, it’s part of quality.

If a screen reader can’t read your modal, that’s a broken UI
If keyboard users can’t navigate your app, that’s a critical bug
If your contrast ratio fails standards, it’s a compliance risk

You can use axe to test accessibility. Add this to your Playwright or Cypress flows. Automate them in your GitHub Action. There is no valid reason to defer this anymore.

If your software is supposed to be used by everyone, it needs to be tested for everyone.

Test how it breaks, not just that it works

Here’s what most tests don’t do: simulate failure. We check the happy path. We test with perfect data. We assume the network is stable, the auth token is valid, and the dependency responds in 200ms. But real systems break in boring, predictable ways:

A token expires
A permission is missing
An API returns malformed JSON
A service times out

These aren’t edge cases. They’re the default failure modes. Tools like Microsoft Dev Proxy let you simulate bad responses and inject latency or broken payloads into your app in dev. Start injecting chaos. Simulate rate limits. Test bad tokens. Drop headers. Let your app break - on purpose. If you never test failure, you’re not testing production.

Your test suite should be fast or it won’t be used

A modern test stack runs in CI, runs fast, and provides signal. You should know within minutes whether your change is safe, risky, or broken. The goal isn’t just automation. It’s trust. A fast, focused test suite builds trust in your codebase and confidence in every release. So test testing tools for their performance as well.

Testing is a leadership problem

Let’s talk to the business for a moment. If you want to move fast without breaking things, your test strategy matters. If you want teams to innovate without fear, your feedback loops need to be short and reliable. If you want fewer outages, fewer hot fixes, and fewer Friday rollbacks, then testing has to shift from checkbox to strategy. Real testing isn’t about writing more code but about reducing uncertainty. It’s the difference between shipping with hope 🤞 and shipping with confidence.

Test smarter. Not harder.

Coverage is a vanity metric. Confidence is the real one. You don’t need a thousand tests. You need the right ones. Test behaviors, not just functions. Verify contracts, not mocks. Run fast, catch failure, test what actually matters. Because if your test suite doesn’t reflect reality, it’s not protecting you, it’s lying to you. And if you want to move faster, scale smarter, and sleep better, then it’s time to modernize your stack.

This blog post is part of a series on testing software. You can find more parts here:

Highway to the danger zone: No testing of business apps

Sat, 14 Jun 2025 07:01:35 +0000

We love to pretend that business apps are boring. Predictable. Safe. Low risk. After all, we’re not launching rockets or handling billions of users… we’re just managing leave requests, budgets, logistics, workflows, customer data, and access rights. You know, just the things entire companies run on. But here’s the uncomfortable truth:

Business apps are some of the riskiest systems we build

And they’re often the least well-tested. If they get tested at all (and no Kyle, I don’t mean you to click through the app that you’ve build and notice that it works like a charm).

So if you are in a project, where you do in fact test business apps, they’re the most likely to be surrounded by quality theater. Mock data. Manual clicks. Acceptance criteria that describe buttons, not outcomes. Test suites that proudly show 95% coverage - and miss the fact that login fails for half the users in production.

The illusion of safety in business apps

Enterprise apps are integration-heavy. They pull data from ERPs, sync with CRMs, push records into legacy systems, and serve users with a dozen different roles. They’re built with multiple layers of logic: some in code, some in workflows, some in config, some in Excel sheets no one wants to admit still matter.

And we test them with… stubs. And mocks. We spin up test environments with sanitized data and assume it’ll behave the same as production. We run a few UI flows and declare victory. It looks good. Until real users do real things. That’s when a renamed field in SAP breaks a Power Automate flow. Or a SharePoint permission issue locks out an entire department. Or a regulatory field gets left blank because no one ever tested the edge case where null means non-compliant.

Stubs, mocks, and hope

Most business app testing is built on mocked dependencies. We fake the response of an API. We stub out the database. We hardcode sample user roles. That’s fine for unit tests. It’s even useful when isolating tricky logic. But in business systems, the logic is rarely the problem. The integration is. You’re testing how your leave request process reacts to 5 days off, but not how it handles a broken HR system, or how it syncs to payroll, or what happens when a manager’s access level was misconfigured six months ago.

Mocks don’t test reality. They test assumptions.

And assumptions, as we all know, are the mother of all f*ck-ups.

Quality theater vs. real risk

Most test coverage in business apps tells you that code was executed, not that value was delivered. You might have 100 tests on a plugin, but none on the actual sales process. You’ve tested that the invoice PDF renders, but never validated the tax calculation logic that runs when the customer is in a different country. Meanwhile, nobody’s tested accessibility in your custom forms. Or what happens when your dependency times out. Or whether your data policies are enforced when users export records in bulk. But hey — the test coverage is 91%. Green dashboard. All good, right?

Low-code makes it easier to build — and easier to forget what comes next

Low-code platforms like Power Platform let teams move fast. They remove boilerplate. They open the door for non-developers to build real solutions. And they often work beautifully, until they don’t. The problem isn’t the platform. It’s what happens after the prototype. In many low-code environments, testing is either entirely manual or completely absent. Automation is rare. Pipelines are an afterthought. Real-world data is never tested. Why? Because the person who built the app is usually not a professional developer. They’re a domain expert. A problem-solver. A builder. They created something great, because no one else was going to. But now the business depends on it. And suddenly, this scrappy solution is infrastructure.

Here’s the part nobody likes to say out loud:

Making the baby is the fun part.

Raising it: maintaining it, securing it, testing it, governing it, is less glamorous. It’s not exciting anymore. It’s responsibility. And the person who built it? They’ve moved on. Or they’re overwhelmed. Or they were never trained to do long-term maintenance at scale. That’s how you end up with business-critical systems running untested, unmonitored, undocumented, and unowned. We have to stop pretending low-code means low-risk. If it runs your business, it deserves real engineering practices. And real testing.

So what do you do?

First: acknowledge the danger zone. Business apps may look simple on the surface — but they’re full of integration, compliance, and user-specific behavior that make them fragile.

Then: test what matters. Start writing tests. But write fewer unit tests; write smarter integration tests. Test using real data patterns, not lorem ipsum. Validate API contracts, user roles, error flows, edge cases, and accessibility. Use tools that can test what actually happens — not just what’s supposed to.

And finally: shift left. Bring QA into the requirements. Make behavior testable before the code exists. If a business rule can’t be verified, it’s not ready to build.

Conclusion: If it looks boring, look again

The apps that look least exciting are often the most dangerous. Because we don’t give them the testing rigor they need. Because we assume low complexity where there’s actually high risk. Because we tape quality on at the end and hope it holds. And then we wonder why production keeps breaking after the “green” deploy.

It’s time to stop pretending business apps are safe. They’re not. But they can be — if we start testing like they matter.

This blog post is part of a series on testing software. You can find more parts here:

You can’t outsource accountability

Wed, 11 Jun 2025 07:01:35 +0000

There’s something oddly reassuring about blaming the vendor.

The timeline slipped? Must be their fault.
The app doesn’t work on tablets? Scope misunderstanding.
We spent $32 million and still don’t have a working product? Clearly a delivery issue.

But behind every disaster labeled vendor failure, there’s usually a deeper truth: someone on the client side stopped paying attention. Or was never really involved in the first place. Let me tell you a true story!

A multi-million-dollar website that never launched

A major brand in the travel sector decided it was time for a full digital overhaul. New website, mobile apps, content platform, modern user experience — the works. They hired one of the biggest names in global consulting to make it happen. They paid tens of millions over the course of the project. What they got:

A desktop website that didn’t adapt to tablets (no, seriously)
Code that was so poorly structured it had to be rewritten entirely
Missed deadlines, broken features, and a system that never went live

After nearly two years and multiple extensions, they fired the consultancy and brought in someone else to rebuild the whole thing. Was the vendor bad? Honestly, I don’t know. But the client wasn’t present. Yes, the consultancy messed up. They missed the mark on critical requirements. They misunderstood scope. They delivered incomplete and, in some places, insecure code. But the client let it happen. No strong internal product ownership. No meaningful validation of deliverables. No feedback loop that kept the work aligned to actual business outcomes. They thought writing a check would buy them transformation. Instead, it bought them frustration.

What actually went wrong

Key features were assumed, not defined. The client thought responsive design obviously included tablets. The vendor delivered desktop and mobile — and then asked for more money to add tablet layouts. Reusability across brands was a goal, not a requirement. The client wanted a single platform for multiple brands and regions. The vendor built something that only worked for one. Technically correct; strategically useless. The front-end code was riddled with issues. Performance, maintainability, and even basic logic were subpar. It didn’t follow the standards of the platform it was supposed to be built on. Testing was superficial. Some code was allegedly commented out to make it pass. The testing process looked good on paper — but failed to catch serious problems. Documentation and handover were incomplete. The client expected an interactive design system. The vendor sent PDFs and a bill for the rest. After terminating the contract, the client had to pay another firm to rebuild almost everything from scratch. Of course, there was a big lawsuit as well.

Lesson learned: No one will care about the outcome as much as you do

You can hire the biggest name in the business, but if you don’t stay engaged — if no one on your side owns the outcomes, asks the hard questions, and keeps the team honest — you’re not managing a transformation. You’re just spending money and hoping it works. I like to remind people of three things to remember for your next strategic project:

Vendors build what you tell them. Not what you wish for. If you want extensibility, accessibility, or scalability, write it down. Get it into the contract. Assume nothing.
Outcomes need owners. There must be someone on your side whose job is to understand the vision and the delivery. Not just approve invoices.
Working software beats perfect plans. Progress is not a slide deck. Test everything early. Look at real functionality. If you’re surprised at go-live, you weren’t looking closely enough.

Enter AI

Now why is all of that important to you? Because everywhere, organizations feel the pressure to implement AI, to digitally transform and to finally get all of that right. So organizations commit on buying new tools or explore ways to extend and integrate AI with existing systems. But if no one in your org understands how it’s being built, what it’s trained on, or why it matters, you’re just repeating that same IT failure, only faster and with more hallucinations.

Here’s how to not repeat the past

Start with the job, not the model. What work are you trying to improve? Who does it today? What’s painful about it? If you can’t answer that in plain language, you don’t need AI, you need clarity.
Own the decision-making. Don’t let external partners dictate what AI looks like for your business. Use them to build, not to decide. Your leadership team should define success and call the shots on what’s acceptable, usable, and scalable.
Don’t skip the governance conversation. It’s not just about data privacy. It’s about explainability, auditability, and long-term cost. Who’s updating this thing next quarter? What happens when the model drifts? If you don’t know, you’re not ready to ship.
Build internal muscle, even if you’re not coding. You don’t need a team of PhDs. But you do need product managers, domain experts, and data-literate leaders who can ask smart questions. If every AI decision is outsourced, you’re not transforming, you’re just renting tech theater.
The very inconvenient truth: the tools are better, but the habits are the same. We have better infrastructure, smarter models, and easier integrations than ever before. But if we approach AI with the same mindset that failed digital projects a decade ago, we’ll get the same result:

🚨 High spend 🚨 Little value 🚨 Lots of finger-pointing

AI is not a shortcut to strategic clarity.

It’s an amplifier. Of whatever culture and structure you already have. AI won’t save you, but ownership might. The lesson from that $32 million disaster wasn’t don’t trust vendors. It was: Don’t abdicate leadership.

If you’re serious about AI, don’t start with the pitch deck. Start with the problem. Start with the users. Start with someone internally who is accountable for every step from vision to deployment. And if you don’t have that person? Congratulations. You’ve just launched a very expensive experiment in disappointment.

If this hits close to home, let’s talk. Not about the vendor. About the part you can control: How to lead a project that actually delivers.

The benefits of testing (beyond working apps)

Wed, 11 Jun 2025 06:07:13 +0000

Most teams treat testing as a cost. Something you do because you have to — like documentation or status reports. It’s seen as a necessary drag on velocity. A checkbox to tick before the sprint ends. A stage in the pipeline you hope turns green quickly so you can merge and move on. But what if we’ve been seeing it wrong all along?

Good testing isn’t a drag. It’s leverage
It doesn’t slow you down but lets you move faster, with confidence
It doesn’t cost velocity but buys clarity, alignment, and trust

And in high-performing teams, it doesn’t live in isolation; it shapes design, guides development, and protects the entire product lifecycle.

When testing is done well: thoughtfully, deliberately, and close to the source, it becomes one of the most valuable assets your team can invest in. Not just to prevent problems, but to unlock what’s next.

Speed without fear

When teams don’t trust their tests, they hesitate. Releases get delayed. PRs pile up. Every small change feels risky, because no one knows what it might break. So they slow down — not because the code is hard, but because the safety net is full of holes.

But when tests are meaningful and trusted, speed returns. A developer makes a change and sees the feedback immediately. A release goes out and everyone sleeps that night. The test suite stops being a formality and starts being a source of confidence. Velocity isn’t just a product of tools or team size, but a product of trust. And trust comes from knowing that when things break, you’ll know — and that when tests pass, it means something.

Better software design

It’s almost impossible to write good tests for bad architecture. The moment you try, it becomes obvious which components are too entangled, which responsibilities are blurred, and where assumptions haven’t been made explicit. Testability is often the first signal of good design — or its absence. Teams that care about test quality naturally start writing better code. Functions become purer. Interfaces become clearer. Complex logic gets isolated, not buried. Dependencies are injected, not hard-coded. It’s not because someone read a book on clean architecture. It’s because good tests require clarity — and clarity, when enforced at the boundary of verification, reshapes everything.

You don’t write better software in spite of testing. You write it because of it.

Cleaner onboarding and easier maintenance

Tests aren’t just for catching bugs. They’re also for catching up. A well-written test suite tells new developers how the system is supposed to behave. It shows what matters, what edge cases exist, and what you’ve already thought through. When someone new joins a team, they often read tests before they read code. Because tests show intent. They give you a safe environment to break something and learn from the fallout. You don’t need to ask the original author of the feature — the test tells the story. And for maintainers, a trusted test suite is what allows refactoring. If you can’t touch the code without holding your breath, you’re not in control. You’re hoping 🤞🤞 . That’s not maintainable software. That’s a house of cards. Good tests change that. They give you a way to change things, even years later, without fear.

Real alignment across Dev, QA, and Product

Many bugs don’t come from bad code. They come from broken communication. A requirement that was misread. A business rule that was unclear. A stakeholder assumption that never made it into the ticket. When testing is part of the requirements process — through shared examples, testable acceptance criteria, or behavior-driven development — those gaps close. The discussion shifts from what are we building? to how will we know it works?

Developers, QA, and product speak the same language: expected behavior.

This doesn’t just reduce bugs, but it reduces handoffs, misalignment, and late-stage rework. It turns the test suite into a contract between everyone — and it turns done into something objective. No more done (at least for now 🤞) anymore!

Resilience under scrutiny

In regulated environments — healthcare, finance, energy, government — it’s not enough to say we tested this. You need to prove it. You need to trace requirements to tests, show who validated what, and demonstrate that the system behaves as expected across every critical workflow. A duct-taped test suite full of mocks won’t do that. But a well-structured, traceable, behavior-first test strategy will. Means: When the heat is on, good tests are your proof, your playbook, and your safety net.

Culture shift

Perhaps the most underrated effect of good testing is what it does to team culture. When tests are meaningful, developers start owning quality. When quality is visible, Product starts caring about edge cases. When releases are reliable, trust builds across the org. Testing becomes less about catching mistakes and more about making progress possible. People stop firefighting and start improving. They stop dreading releases and start focusing on impact. QA is no longer the safety net at the end — they’re the co-designers of resilience from the start.

And that’s when testing stops being a cost and starts being the reason your team performs like one.

Conclusion: testing is leverage

Good testing doesn’t just prevent failure. It enables trust, speed, clarity, and progress. It’s not a tax. It’s a force multiplier. If your team still sees testing as a necessary evil — a checkbox, a hurdle, a phase — maybe it’s time to ask a better question:

What would become possible if we actually trusted our tests?

That’s what good testing gives you. Not just fewer bugs. More possibility.

This blog post is part of a series on testing software. You can find more parts here:

Rethinking identity beyond passwords

Tue, 10 Jun 2025 08:38:17 +0000

Your password isn’t protecting you.

At least not in the way you think. Not anymore. We’ve built a whole mythology around passwords — how long they should be, how often they should change, what characters to include. We treat them like they’re the foundation of our digital security.

They’re not.

Source: https://xkcd.com/1200/

Usually, I don’t run security workshops. Most of the time, I’m there to talk about AI strategy, automation and custom apps with Power Platform and Azure, licensing and governance. But still every single time someone will eventually ask about passwords. Usually in a side comment. Should we increase password length? or Is it okay to allow password managers? or even What is a reasonable password policy? IT forces us to change passwords every 6 weeks!

It’s like a reflex. And every time it comes up, I realize just how much confusion and outdated thinking still surrounds this topic. Most of the ideas we still cling to about password security are based on assumptions that stopped being relevant many years ago. We’re still designing policies to protect against brute-force attacks — as if that’s the main threat. But in the real world, that’s the last thing an attacker tries. Before anyone even considers brute-forcing your password, they’ll try credential stuffing (using leaked passwords from another site). They’ll phish you with a fake login page. They’ll deploy malware to log your keystrokes. They’ll trick you into giving it away — and nine times out of ten, that works.

That’s the real threat landscape. And none of it is stopped by making your password a few characters longer or swapping a for @ or - as we collectively all decided, once vendors made it mandatory that at least one character needs to be a special character - adding an ! at the end of our existing password. So no, I don’t really care whether your password is 12 or 16 characters. It’s good practice to avoid reuse and common phrases, sure. But password strength is no longer a meaningful line of defense. If your identity strategy starts and ends with make better passwords, you’re solving the wrong problem.

What does work?

1. MFA

Multi-factor authentication changes everything. It stops account compromise even if the attacker has your password. And the numbers don’t lie — Microsoft’s own data shows that enabling MFA prevents over 99% of identity-based attacks. It’s not just effective; it’s essential. That’s why Microsoft enforced MFA for all accounts. But we can go further. And frankly, we should.

2. Passwordless authentication

Passwordless authentication with FIDO2 keys, Windows Hello, authenticator app push approvals, certificate-based logins: these are harder, better faster, stronger and far more secure than any password ever was. They’re phishing-resistant by design. They eliminate the weakest link: the password itself. When someone logs in with a biometric, or a device-bound key, or a hardware token, there’s nothing for an attacker to guess, steal, or reuse. Of course, going passwordless requires planning. You need a phased rollout, support for fallback methods, alignment with your Conditional Access policies. But it’s achievable — and honestly, overdue. The guidance is there. The tooling is mature. And the risk of doing nothing is growing. So the next time passwords come up — and they will — this is the conversation we need to have.

Not about complexity requirements or expiration intervals. Not about special characters or clever passphrases.

But about what actually works. What actually stops breaches. What actually reflects the modern threat landscape.

It’s time to start treating passwords as the liability we’ve failed to let go of.

Confidently wrong: Why we misquote Maslow and misunderstand AI

Mon, 09 Jun 2025 12:36:27 +0000

The pyramid that never was

You’ve probably seen Maslow’s hierarchy of needs: a five-level pyramid that starts with food and shelter and ends with self-actualization. It’s tidy. It’s visual. It’s wrong.

Maslow never drew a pyramid. He described needs as overlapping tendencies, not a strict ladder. You don’t need to finish belonging before pursuing esteem. You can feel creative even if you’re broke. And different people prioritize needs differently. Maslow himself said the hierarchy isn’t fixed.

But the pyramid stuck. Why? Because it’s simple, feels logical, and gives people a sense of understanding. Enter: The Dunning-Kruger Effect!

The confidence of the underinformed

The Dunning-Kruger effect is a well-documented cognitive bias where people with low expertise in a subject overestimate their competence, because they don’t know what they don’t know.

In the case of Maslow, people saw the diagram, heard a catchy explanation in a training once, and started citing it with total confidence. They didn’t realize how much nuance they were missing, because they weren’t aware there was any nuance to begin with.

This is exactly what’s happening with AI right now, especially in business.

AI: The new pyramid

We’re watching the same pattern unfold in real time. Executives and teams are:

Rolling out AI strategies based on tech they don’t truly understand
Making ethical claims with no grounding in data governance or model architecture
Confusing predictive text generation with reasoning or thinking
Assuming one flashy demo equals readiness for full enterprise deployment

Just like the pyramid, AI appears understandable at a glance. You talk to it; it talks back. It’s impressive. So, people assume they’ve got a handle on it. They feel confident talking about risks, investments, and capabilities, without seeing the missed complexities.

This is dangerous in business. Not because people are malicious, but because they make high-impact decisions from a place of false certainty.

Surface-level understanding leads to surface-level strategies

You wouldn’t base a company’s well-being strategy on a rigid version of Maslow’s pyramid. Yet many companies are building AI initiatives on equally flawed simplifications:

AI will replace this whole department
Let’s use Copilot for everything
We just need a chatbot to automate the process

These are not strategies; they’re assumptions cosplaying as insight.

The real cost of overconfidence

In both the Maslow and AI examples, the cost of misunderstanding isn’t just academic. It leads to:

Poor design decisions
Wasted investment
Frustrated employees
Missed opportunities
Ethical missteps

What’s missing isn’t intelligence; it’s depth. And humility. The willingness to say, I don’t fully understand this yet—let’s dig deeper.

So what can we learn?

Be skeptical of oversimplified models
Encourage questions, not just confidence
Balance excitement with education: Yes, explore AI. But build internal literacy before you commit to major rollouts
Remember that real expertise sounds cautious. The more someone knows about AI, the more they acknowledge its limits.

Final thought

Maslow didn’t give us a pyramid, and AI isn’t magic. In both cases, the danger lies not in the tool or theory, but in our overconfidence about how much we actually understand. So next time you hear someone explain AI with total certainty, pause for a second.

You might just be listening to a pyramid in the making.

BYOM: Using Azure AI Foundry models in Copilot Studio

Sat, 07 Jun 2025 08:51:08 +0000

Copilot Studio gives you a fast, secure way to build conversational agents and deploy them into the Microsoft 365 environment without writing code. But what happens when the default models aren’t enough? That’s where Azure AI Foundry comes in. Copilot Studio now supports direct integration with models deployed via AI Foundry. That means you can choose exactly the model you need, like a language model with stronger reasoning capabilities, an image analysis model, or something domain-specific, and then connect it directly to your Copilot Studio agent.

Example

An IT team is managing support requests across multiple business units. Users often submit screenshots: Error messages, UI glitches, device warnings, but rarely with context. Traditional agents struggle with this format. Text-only prompts don’t help when the issue is visual. Instead of trying to route these through a human queue, we use Azure AI Foundry to deploy a vision model capable of:

Performing OCR on screenshots
Identifying key UI elements
Classifying common issues based on screen layouts

We connect the model to a Copilot agent in Microsoft Teams. Now, users can upload a screenshot, and the agent can recognize a known error and suggest next steps within seconds. No manual ticket triage, no copy-paste from Outlook to ServiceNow.

How to connect an AI Foundry model to your Copilot agent

Find a model in the huge AI Foundry catalog. You can also fine-tune an existing model
Deploy your model in Azure AI Foundry
You will get 3 values, that you need in one of the following

A deployment name
An endpoint URL
An API key

Once you have that, navigate to Copilot Studio and open the agent you want to enhance.

Go to Settings –> Generative AI
In the Primary response model dropdown, select Connect a model in the From Azure AI Foundry (preview) section

Once prompted, paste in the:

Target URI (endpoint)
Deployment name
API key

Copilot Studio will verify the connection. Once successful, your agent is now powered by that specific model.

Boom, done! 🧨

PS: This is a super new feature. In case you don’t see the From Azure AI Foundry (preview) section please be patient, it will roll out soon™️. Also make sure, that in your Power Platform environment, you have the Get new features early switch set to Yes

Your Testing strategy is broken - Let’s fix it

Tue, 03 Jun 2025 14:01:35 +0000

Test coverage is not quality

That’s a hard truth most teams don’t want to hear. But we need to. Because too many development teams are stuck in the wrong mindset: chasing 100% test coverage as if it guarantees safe deployments, stable apps, and happy users. Spoiler alert: It doesn’t.

In fact, the more you worship coverage metrics, the more likely you are to miss the actual point of testing: to reduce risk and increase confidence in the system you ship. Most test suites in the wild aren’t robust safety systems — they’re duct-taped scaffolding, held together with mock data, over-simplified edge cases, and a hope that it probably won’t crash again 🤞🤞. You’ll find unit tests that mock everything except the actual behavior, stubs that assume the happy path, and assertions that test for the existence of a response rather than its correctness. While exact numbers vary, industry observations consistently show that many defects in production stem from logic errors and integration issues — the kind that unit tests alone rarely catch. Reports from quality tooling vendors and case studies in enterprise environments highlight how overly mocked test suites often miss real-world behavior and system contracts. This pattern is common in integration-heavy systems, especially when test suites don’t include API contract validation. For example, many teams have reported incidents where upstream API changes—such as renamed fields or altered data types—slipped past their test suites because mocked data hid the real risk. These failures are rarely caught by line coverage metrics and often occur in systems showing high test coverage but lacking true behavioral checks. The coverage looks impressive. The confidence, in practice, is often misplaced.

The illusion of safety

Test coverage tells you which lines of code have been executed during testing. That’s it. Not whether they were tested with relevant inputs. Not whether they behaved correctly. Not whether they matter to users. This is how you end up with 92% coverage and still break production.

These aren’t edge cases. They are blind spots: the kind you miss when your “quality gate” is a green bar glued on with test doubles and wishful thinking.

What coverage doesn’t tell you

Coverage can’t tell you if critical business flows actually work. It doesn’t confirm that your APIs behave correctly when the schema changes. It won’t catch performance regressions, accessibility issues, or security gaps. It tells you nothing about whether your tests reflect how real users interact with the system. You can hit every line and still fail when a third-party service returns null. Or break login for users with special characters in their email address. Or violate accessibility standards and expose your organization to lawsuits. If your strategy is built on coverage, you’re measuring activity, not assurance. You’re holding your production code together with duct tape and dashboard metrics.

Why business apps are especially at risk

Enterprise applications: ERPs, CRMs, finance systems, low-code tools amplify the problem. They integrate across systems. They rely on real-world, unpredictable data. They must meet compliance, access control, and auditing requirements. A green coverage report in this world is like saying the blueprint looks fine while the building has no plumbing. Or heating. Or working doors.

The real cost of bad testing

The cost of getting it wrong is massive. Gartner estimates the average cost of IT downtime at around $5,600 per minute: That’s more than $300,000 per hour. In large enterprises, that number can spike much higher. Amazon once lost an estimated $2.6 million from just 13 minutes of downtime. When it comes to data breaches, IBM’s 2023 Cost of a Data Breach Report puts the global average at $4.45 million.

These are just the direct financial losses. The indirect costs cut deeper: burned out developers scrambling to patch things that should’ve been caught earlier, users losing trust after yet another oops moment, and a team culture where people quietly tape things back together instead of fixing the foundation.

Fix it at the source: requirements

If testing happens after coding, it’s already too late. At that point, you’re not validating understanding — you’re validating assumptions you hope were right. Testing should begin the moment you define the requirement.

What’s the expected behavior?
What’s the risk if it fails?
How will we know it works — and how will we prove it?

Good teams test. Great teams integrate testing into the requirement process.

Modern engineering teams treat testing as part of requirements engineering. They don’t separate the what from the how we’ll know it worked. When a feature is proposed, so is its verification. A requirement without a testable outcome is a red flag 🚩.

This is where Behavior-Driven Development (BDD) and example mapping change the game. Instead of vague feature specs, teams define shared examples: edge cases, failure modes, and success criteria. A user story becomes a testable scenario: Given a customer has no active subscription, when they log in, then they are redirected to the upgrade screen. It’s not just about automation, but about alignment. When tests are derived from well-defined requirements:

Developers know what success looks like
QA doesn’t need to reverse-engineer intent
Business stakeholders can read and understand the criteria
Ambiguities are exposed before they become bugs

This practice shifts the energy from writing tests that merely touch the code, to designing tests that challenge the logic, the integration, the value. It closes the gap between we thought it worked and we proved it works.

It also changes team dynamics. Now, QA isn’t just testing functionality, they’re challenging clarity. Product owners aren’t just writing features, they’re shaping outcomes. Developers aren’t just building to spec, they’re validating intent.

This is where you stop taping quality on at the end and start designing it in from the beginning.

What to do instead of chasing 100%

Shift your strategy. Focus on critical user flows; the parts of the system that matter most in production. Write tests that validate behavior and integration, not trivial implementation details. Treat accessibility and security as testable requirements, not afterthoughts. Use coverage as a signal, not a goal. And involve QA from the start of the process, not the end.

Final thoughts

Testing isn’t about writing more tests. It’s about writing the right ones. Coverage makes you feel safe. Confidence means you are safe. Because if your test strategy is held together by tape and bubble gum, you can expect it to fall apart the moment anyone leans on it.

This blog post is part of a series on testing software. You can find more parts here:

Tired of the AI hype machine

Mon, 02 Jun 2025 07:12:23 +0000

The feed vs. the floor

Open LinkedIn and you’ll see the same recycled energy over and over:

AI will reinvent your entire industry!
The companies that don’t adapt will die!
Here’s how I use AI to 10x my thinking in under 3 minutes!

Then, in the comments:

🔥 “Incredible insight!”
🤝 “Exactly what I’ve been saying!”
🧠 “Have you tried asking ChatGPT politely?”

And so many rocket 🚀🚀🚀 emojis.

Meanwhile, in actual companies:

Our Copilot licenses are active, but no one knows where to start
We built a chatbot, but it just repeats things from our website
We don’t trust the output, so we still do it manually anyway

This is the real gap:

LinkedIn is busy arguing over whether AI understands ‘please’ and ’thank you’ while orgs are still struggling to make AI useful at all.

Most AI implementations right now are stuck at what I call the chatbot plateau. We’re not solving real business problems, we’re giving people a generic chat interface and calling it innovation. Instead of improving how knowledge is structured or decisions are made, we offer employees yet another vague prompt box: Ask me anything! The result? A confused user asking for the parental leave policy, only to get an outdated file, a broken link, or a non-answer dressed up in polite language. This isn’t transformation; it’s deflection. Slapping a chatbot onto an intranet doesn’t fix content chaos, broken search, or unclear ownership. It just buries it one layer deeper. And yet, this is what passes as AI integration in far too many orgs right now, because it demos well and looks futuristic, even when it delivers nothing. So while the feed celebrates another prompt tip or AI-generated image, the floor is dealing with broken systems and bigger questions.

The AI theatre is exhausting

You’ve probably seen the elephant. Someone prompts a generative model: Create an image of a group of people with no elephant in it. What do you get? A lovely picnic scene… with a giant elephant in the middle. Funny? Sure. Insightful? Maybe once. Helpful to anyone trying to automate a broken procurement process? Not even slightly.

This is the noise:

Prompt hacks, AI-generated carousels, and ethics debates held entirely in abstract
Thought leaders posting about their AI-first mindset from the comfort of a slide deck
Dozens of use cases that are clever, but not valuable

And in the background, the actual AI problems remain unsolved: Data quality. Governance. Integration. User adoption. Real-world constraints.

What working AI actually looks like

The irony? AI does have real potential. But the projects that succeed don’t start with elephants, ethics debates, or tip-of-the-day posts. They start with grounded questions:

Where is our time being wasted?
Which decisions are based on guesswork?
Which manual steps could be automated safely and meaningfully?

Transformation happens when teams define real problems, connect usable data, and build human-first, feedback-driven workflows and then, only then add AI where it helps.

Stop solving imaginary problems

Saying “thank you” to a language model doesn’t affect your ROI. Neither does creating a prompt that includes without an elephant. Here’s what does:

Building use cases that reduce real friction for real users
Understanding when automation is helpful—and when it’s just noise
Getting past the AI-as-magic thinking, and focusing on design, intent, and structure

I’ve seen far more impactful results from AI when it’s embedded deeply into processes and not just layered on as a chatbot. In past projects, I’ve worked with teams to implement predictive maintenance using sensor data to prevent costly downtime in industrial environments. We’ve used AI-powered document intelligence to extract clauses, renewal dates, and obligations from thousands of contracts. This saved legal teams hours of manual review and triggering automated workflows in Microsoft 365. In finance, I’ve helped build models to detect anomalies in transactional data to flag potential risks long before audits catch them. HR teams I’ve worked with now use AI to identify bias in job descriptions and streamline internal mobility by matching people to roles based on skills, not job titles. I’ve also helped service teams move past basic bots and into intelligent routing, where incoming requests are prioritized and sent to the right team based on AI-driven classification and not just a keyword match.

None of these required a chat with your data interface. They required clear goals, usable data, and the right architecture. These projects don’t go viral. But they solve actual problems. That’s the kind of AI transformation I’m here for.

Final thought

I believe in the potential of AI. But I also believe most organizations are still early in the journey, despite what LinkedIn would have you believe. So if you’re not chasing the elephant or debating prompt tone, good. You’re probably closer to meaningful AI than most of the visionaries. Let’s keep doing the work. The real kind.

Should I automate it?

Thu, 22 May 2025 12:11:24 +0000

Somewhere between your fourth copy-pasted email of the day and yet another spreadsheet update, you wonder: should I just automate this? It’s a fair question; and honestly, a tempting one. But context is everything. Before diving in, it’s worth pausing and asking yourself a few grounded questions. Think of this as a guided conversation with your future self (and hopefully someone from governance).

1. Who’s affected, and how badly?

Start with the scope. If this automation is just for your own inbox triage or filing PDFs you get daily, go ahead: low risk, low impact. The worst-case scenario is you create a Frankenstein flow, spend an afternoon debugging it, and walk away with a valuable lesson. But as soon as your automation starts to touch more than just your own workflow, it enters a different league. Automating a small handover between two people might seem harmless, but even simple automations can introduce fragility. What happens if your colleague is on leave? If they change the file name? If your flow breaks, will it quietly fail or silently drop the ball on a customer order? Let’s take it further. Automating a process that supports onboarding, procurement, or customer communication? Now you’re interfering with how others work, and you’re also reshaping accountability. You’re influencing SLAs, timelines, and expectations. If you’re working on payroll, compliance reports, or IT provisioning, the potential for damage gets even more real. These aren’t just workflows; they’re risk surfaces. That’s where architecture, stakeholder alignment, and robust testing come in. It’s not about being slow or bureaucratic but about building solutions that can withstand change, edge cases, and shared responsibility. You wouldn’t rewire the office network just because you read a blog post about routers. Don’t do it with processes either.

In short:

Personal automations are great playgrounds.

But the moment others rely on your output, it’s no longer just about your efficiency but about shared trust. And shared trust deserves structure.

2. Process quality: clarity or chaos?

Let’s assume the intent is noble. Automating repetitive work sounds good in theory, but is the process itself stable and well-understood enough to be automated? A well-documented, consistent, mostly manual process is a strong candidate. Think of steps like check incoming support tickets, assign them based on category, or send a weekly summary to stakeholders.These are clear, repeatable, and generally predictable.

Now compare that to a process that involves chasing people down via chat, digging up templates from someone’s personal OneDrive, or interpreting vague instructions like do what we did last time. That’s not a process, it’s folklore. If your workflow includes steps like just ping Sandra, she knows, or send a friendly reminder, automation won’t solve the real issue. You’ll just bury a flawed process under layers of technology. And that’s not just opinion. According to a McKinsey study, around 70% of large transformation efforts fail, often due to unclear or shifting processes. Automating something that’s ambiguous doesn’t reduce the problem, it reinforces it. It gives people a false sense of reliability while quietly perpetuating all the same inefficiencies.

Let me repeat this:

Automating junk processes is how you turn temporary inefficiencies into permanent confusion.

Before automating, consider mapping the process end-to-end. Identify who does what, when, with what inputs and expected outcomes. If you can’t write that down in a way others understand, automation isn’t the next step, clarity is. (if you need help with this step, hit me up)

3. Data quality: dream or disaster?

You can’t automate what you can’t trust. High-quality data (clean, structured, accessible via APIs or databases) is the fuel automation runs on. If your information lives in a reliable system of record, is updated consistently, and communicates in formats that other systems understand, you’re in a strong position. Automating with this kind of data feels like adding a turbocharger to a well-built engine.

But let’s be honest: many of us aren’t dealing with ideal conditions. If you’re scraping Excel files from email attachments or copy-pasting values from PDFs, you’re already on thin ice. These data sources often come with missing fields, inconsistent naming, and formatting quirks that break flows without warning.

A simple rule of thumb: if it takes a human 15 minutes to clean the data every time, automating that cleanup will likely take 15 hours, and it will still break the moment someone renames a column or inserts a rogue emoji into a free-text field. And when things break, they often do so silently, leading to incorrect outputs, corrupted records, or decisions made on flawed inputs. This isn’t just inefficient or expensive, but also dangerous. Bad data at scale is worse than no data at all. You’re not improving a process; you’re just accelerating your mistakes.

If you want a horror story, look no further than organizations still using spreadsheets as the backbone of operations, something we explored in this blog post. These legacy systems often masquerade as structured data sources but behave like digital sandcastles. So before you start automating, ask: is the data fit for purpose? If not, clean the foundation first. Otherwise, you’re building a robot that trips over the same mess every day.

4. Time saved vs. time spent

This is where that brilliant XKCD chart comes in handy. The premise is simple but powerful: how often do you do the task, how much time does it take, and how long will it take to automate it? This is the math behind whether your automation effort is worth it.

Visual taken from: https://xkcd.com/1205/

Say you spend five minutes per day manually doing a task. Over five years, that adds up to just over 21 hours. If your automation takes more than two to three full days to build, test, deploy, and occasionally fix, you may never see a return on that investment. Especially if the task is tolerable and unlikely to change. Now, this doesn’t mean all small automations are a waste. If the process is prone to human error, causes frequent context switching, or is a bottleneck for others, the value may go far beyond the raw time saved. Speed is only one axis of improvement, quality, accuracy, and scalability matter too.

Still, it’s important to be honest about the cost-benefit tradeoff. Many developers (I might be guilty of that as well) enjoy automating things for the intellectual challenge or the elegance of the solution. But sometimes, the smartest move is to keep doing that task manually, especially if you’ll spend more time maintaining the automation than you ever did on the task itself.

In short: let data and context, not just curiosity, guide the decision.

5. Cost: Labor and lost weekends

Automation is often sold as a quick win, an easy way to improve productivity without adding headcount. But the true cost of automation isn’t just the time it takes to build a flow. It’s also the maintenance, the troubleshooting, and the late-night Teams messages when it fails. Now add labor: time spent planning, building, testing, fixing edge cases, explaining it to stakeholders, and documenting the flow. Then sprinkle in the debugging hours (because we all know a 42-step flow with nested conditions never works perfectly on the first try). And then there’s the human bottleneck factor. If you’re the only one who understands how the automation works and you’re out of office, congratulations, you’ve just made yourself a critical point of failure. There’s a difference between being helpful and being irreplaceable in a way that stresses out your team.

Before jumping in, ask yourself: do we have the right tooling in place? Is this within our supported platform stack? Who else knows how this works, and are they empowered to help if something breaks? If you can’t answer those clearly, what you’re building isn’t just automation, it’s a support ticket waiting to happen.

6. Are you automating a moving target?

Some processes are beautifully stable: They’ve run the same way for years and aren’t likely to change next week. Others are in constant flux: driven by shifting regulations, changing business models, or the latest reorg. If you’re working with a process that evolves every quarter, take a step back. Automation only pays off when what you’re automating stays more or less the same. Otherwise, you’ll spend more time updating the automation than the task ever cost in the first place. This is especially common in fast-growing companies or departments undergoing digital transformation.

Think of it this way: Would you write a user manual for something that changes every few weeks? Probably not. So why commit it to code? That said, if you absolutely need to automate, consider designing for flexibility. Build modular flows with clear entry and exit points. Document them. Include versioning. And make peace with the fact that you might need to revisit and revise regularly, because the process isn’t done evolving just because your flow is live.

7. Ownership: Who owns this thing?

Ownership might sound like a formality, but it’s the backbone of every sustainable automation. When your flow fails at 3:27 am on the last day of the quarter, someone will be asked: Who owns this?. If the answer is I think I built it during a hackathon, that’s not just risky, it’s irresponsible. Every business process, no matter how small, should have a named owner. Someone who knows what the flow is supposed to do, who approves changes, and who can say yes or no when someone asks to tweak it. Ownership isn’t about bureaucracy, but only about clarity. It’s the difference between having a fire drill and a coordinated fire response.

Without clear ownership, automations slowly decay. A once-useful flow becomes a mystery nobody wants to touch, living somewhere in a forgotten environment, still trying to send weekly reports to a mailbox that no longer exists. And when it fails, the silence lasts until someone’s task goes missing, and fingers start pointing. So before you build, ask: who will own this a month from now? Six months? Will they know it exists? And if they leave, is anyone else ready to take over?

If the answer is me, I guess, and you’re not the person accountable for the business process, you might be building more technical debt than value. And no, dear IT-departments: It is not sufficient to just co-own every Power Automate flow owned by a user - you need to make sure that you know what it is doing.

8. Compliance, risk, and audits

Even if your automation runs beautifully and always triggers on time, processes the right data, and emails the right people, that doesn’t mean it’s safe. In fact, the more reliable it seems, the more dangerous it can be if it’s quietly doing the wrong thing with the wrong data. If your flow handles personal data, financial transactions, or anything that might touch compliance or regulatory frameworks, you’re no longer in casual territory. You’re in the land of data protection, security policies, and audit readiness. That means your automation must include:

Proper access control
Audit trails
Robust error handling
Clear fallback paths

These aren’t just nice to haves, they’re non-negotiables. One missed field, one hardcoded email address, or one forgotten permission level can turn a minor issue into a full-blown incident. A small bug becomes a data breach in the time it takes to hit Send.

And yes, automation absolutely counts as data processing under regulations like GDPR and its international cousins. If you wouldn’t be allowed to do something manually without compliance approval, you definitely shouldn’t automate it without the same scrutiny. Before deploying, ask: Would this pass an audit? Would I be comfortable explaining it to a privacy officer, or a journalist? If the answer is no, pause. It’s easier to build compliance in from the start than to retroactively secure a system that’s already caused harm.

9. Human touch vs. human error

Not all manual work is a waste of time. Some tasks genuinely benefit from human involvement, especially those that require context, empathy, or nuanced judgment. Think of reviewing a customer escalation, handling a sensitive HR case, or making an exception in a policy-driven workflow, humans still outperform even the best logic trees. Automating these interactions can unintentionally strip away the very qualities that build trust and engagement. A rejection email sent by a bot, no matter how well phrased, rarely lands the same way as one written by a person who understands the situation. Also AI won’t fix that. #justsayin

That said, automation shines in areas where the rules are clear and the data is structured. Examples are routine approvals with fixed thresholds, data validation between systems, or moving files and values between platforms. These tasks are low-value for humans but high-frequency and error-prone, making them ideal for automation. And sometimes the best path isn’t full automation but augmentation. Let the system do the prep work: gather data, check conditions, suggest actions. Then let a person decide. That hybrid model keeps humans in the loop without overwhelming them with routine work. It’s efficient and thoughtful. So when you evaluate a process, ask not just can I automate this? but also what part of this benefits from a human touch—and which parts don’t need one at all? And I know, the lines are blurring with LLMs and we see lots of agents who will handle interaction in our fast paced digital world 🤡 - but trust me… some things should just not be executed by AI.

10. Tool chaos and platform fit

Technology should make your life easier, but too often, automation becomes another layer on top of a confusing stack. If your organization already uses ten different tools for task tracking, approvals, and reporting, and everyone is using their own combination of them, your automation might not solve the problem. It might just add one more patch to a system that’s already showing stress fractures. Inconsistent tooling isn’t just an IT headache; it creates user confusion, duplicate work, and brittle processes. An automation that integrates two tools nobody else uses isn’t strategic, it’s just more siloed glue. Instead, look for opportunities to consolidate. Build on platforms your organization already supports and standardizes. If your IT team has blessed a core toolset, use it. Not because it’s perfect, but because it’s supported. That means security patches, maintenance windows, backup plans, and someone to call when things break.

When you align with platform strategy, your automation has a chance to scale. When you don’t, even a brilliant flow might die in obscurity the moment you change teams or someone sunsets one of the systems involved. So ask yourself is this the right place to automate it? Because sometimes, what looks like a workflow issue is really a tooling problem in disguise.

11. Transparency and traceability

People like to know what’s going on, especially when their work depends on it. Manual processes, for all their flaws, often have one major advantage: they’re visible. You see the handoff, you know who’s working on what, and there’s usually a paper trail, however informal. Automation can quietly remove all of that. A task that used to involve an email or a verbal confirmation now disappears into a black box. If it succeeds, great. But if something goes wrong and no one knows why or where it stopped, frustration builds fast. To avoid that, your automation should include visibility by design. Build in notifications that let people know when something’s been submitted or completed. Provide logs or dashboards that track status. Even a simple confirmation email or SharePoint update log can make the difference between trust and suspicion. The first time someone asks what happened to my task? and nobody knows, you’ll wish you had built in just a few more breadcrumbs.

Remember, automation should reduce uncertainty, not introduce it.

12. Just because you can doesn’t mean you should

This is the line that often gets skipped in enthusiastic automation conversations. Tools like Power Automate make it incredibly easy to stitch together workflows, call APIs, and spin up integrations in a matter of minutes. It feels powerful, and it is. But just because you can automate something doesn’t mean it’s wise to do it alone. As soon as your automation affects more than your own work, especially if it reaches into cross-functional workflows, customer-facing systems, or business-critical operations, it stops being a personal time-saver and starts becoming part of your organization’s digital infrastructure.

That comes with responsibility. You need testing. Documentation. Version control. Monitoring. You need to think like an engineer, even if you’re not one. And if you’re operating in a professional environment, you also need to engage with governance and architecture. Not to slow you down, but to protect the people who depend on the outcome. Rogue automation can create fragile systems, introduce silent errors, or violate compliance without anyone noticing, until it’s too late. Involving a subject matter expert doesn’t just make your flow better; it ensures it’s built for scale, clarity, and supportability.

The best automation is collaborative. It lives on a supported platform, it follows design principles, and it doesn’t break when you go on vacation. You might still enjoy building it, but you’ll also sleep better knowing you’re not the only one holding it together.

Conclusion: should you automate it?

The honest answer? Please don’t kill me:

It depends.

But it genuinely does. If the process you’re looking at is stable, well-understood, and worth the investment, if the data is clean, the impact is clear, and the scope is manageable, then yes, you should probably automate it. You’ll free up time, reduce errors, and maybe even improve morale. But automation isn’t always the answer. If you’re dealing with an unstable process, murky ownership, questionable data, or unclear value, then automating might just amplify existing issues. And once an automation is live, people assume it’s reliable, even when it’s quietly making the same mistake 1,000 times a day. Done well, automation scales good decisions. Done poorly, it scales dysfunction. That’s why every quick win deserves at least a few deeper questions before you dive in.

So take your time. Involve the right people. Document what matters. Build with care and intention. Because the goal isn’t just to automate, it’s to make work better, safer, more transparent, and yes, sometimes faster too.

From duct tape to data discipline

Sat, 17 May 2025 12:11:24 +0000

Where does the path toward a proper data strategy begin? With technology, processes, or mindset?

It’s a good question, which I received in a discussion on LinkedIn and it gets right to the heart of why so many organizations feel stuck.

Excel got us this far. but it won’t get us further

Excel filled the gaps. When systems were too rigid, when processes weren’t documented, when no one had the time or budget to do it properly: Excel stepped in. It’s fast, flexible, and widely understood. That’s precisely why it became the default platform for everything from planning and forecasting to reporting and reconciliation. It is the biggest LowCode Platform of all times. (😭)

But over time, flexibility becomes fragility. Business logic ends up buried in formulas. Data definitions evolve in isolation. Files multiply across mailboxes and shared drives, and nobody knows which version is the truth. What started as a quick fix becomes critical infrastructure—with no oversight, no ownership, and no backup plan.

We didn’t set out to build essential business processes on spreadsheets; it just happened. Now we’re trying to modernize, automate, and even build AI on top of that foundation. And it’s not holding up.

You can’t automate what you can’t trust

Every organization says they want to be data-driven. But that depends on one thing: trust. You can’t build automation, run analytics, or deploy AI unless your data is accurate, complete, consistent, and contextualized. More importantly, it needs to be owned. When a report is wrong, when a model fails, when an automation breaks: someone has to know why. And who that someone is, also needs to be known.

Spreadsheets rarely offer that kind of clarity. They’re opaque by design. There’s no version control, no lineage, and no governance. You can’t trace a number back to its source; you just have to trust whoever sent the file. That might work in a crisis. It doesn’t scale into strategy.

This isn’t just a tooling issue. It’s a question of confidence. And if you don’t trust the data, you won’t automate it. If you can’t explain the logic, you can’t expect AI to understand it.

So where does the shift begin?

There’s no single entry point. But you need a few conditions in place before anything meaningful happens.

You need some executive support: not a strategic program with three layers of steering committees, but enough cover to experiment without getting shut down the moment it gets uncomfortable. Someone up top needs to understand that doing nothing is the greater risk. That air cover gives teams the freedom to test, question, and improve.

But the shift doesn’t work if it’s only top-down. Real transformation starts when teams on the ground begin questioning the way things have always been done. Why is this file passed around by email? Why does it take a week to align numbers across teams? Why do three departments define active customer differently? These aren’t annoying details. They’re the fault lines that undermine every initiative built on top.

So, no, it’s not just mindset. And it’s not just process or tech. It’s a loop. You need room to act, courage to ask questions, and a willingness to rebuild some of the invisible scaffolding holding the business together.

From duct tape to data discipline

One of the most important mindset shifts is treating data not as a byproduct, but as a product.

Many organizations still run on data as a service: someone requests data, someone else extracts it, massages it, and sends it over, usually in a spreadsheet. It’s reactive and transactional.

Data as a product flips that. It means designing data with intent. It means treating datasets like reusable, reliable components with clear definitions, ownership, and documentation. Just like any product, they’re built to serve multiple users, not just one-off requests. They’re versioned, governed, and improved over time. That mindset unlocks scale.

Start with a lighthouse project

This isn’t a call for a grand data transformation program. Most of those fail under their own weight. What actually works is a lighthouse project. A focused, contained initiative that demonstrates what good can look like.

Pick a domain where data trust is low but business impact is high: customer records, service requests, onboarding metrics. Something visible. Then work through it end to end: Who owns it? How is it created? What decisions depend on it? Clean it up. Define it. Publish it. Govern it. Then show your work.

A good lighthouse doesn’t just solve a problem; it sets a precedent. It becomes the reference point for others. That’s how you build momentum without boiling the ocean.

The real cost of inaction

If you’re unsure where your organization stands, the warning signs are easy to spot. If Excel files are still passed around as the source of truth, if basic KPIs vary between teams, if no one knows who maintains the customer master list, or if AI pilots keep getting delayed because the data isn’t ready, you’re not dealing with a tech problem. You’re dealing with a credibility problem. And that won’t fix itself.

Build trust before you build AI

You don’t need to fix everything at once. But you do need to stop pretending that spreadsheets are good enough.

Start by identifying one fragile process, one risky spreadsheet, one misunderstood metric. Use it to show what’s broken. Then fix it. Not just with a better tool, but with clarity, ownership, and repeatability. Build your first real data product. And let it light the way 🔦.

If you want your AI to deliver value, your automation to scale, and your teams to make decisions based on something other than gut feeling, you need trust in your data. That trust isn’t built with dashboards. It’s built with discipline.

The tools will come. The governance will follow. But it starts with someone asking: Why are we still doing it this way? And it continues when someone else answers: We don’t have to.

Still running on spreadsheets: the hidden cost of outdated infrastructure

Fri, 16 May 2025 10:39:19 +0000

I often hear some version of this: We should probably modernize it… but to be honest, the Excel spreadsheet works just fine. It’s usually said with a shrug, as if running a key business process on a two-decade-old file is just how things are done.

We joke about it. We meme about it. But the truth is this: some of your most essential operations are still running on duct-taped Excel files built years ago by someone no longer with the company. That’s not just inefficient; it’s reckless.

You know the one.

The spreadsheet that handles pricing logic for every customer quote. Or the one that reconciles financials before reporting. Or the one with color-coded columns that only Kyle understands — and he’s on holiday.

Every organization has one. Sometimes dozens. And most are mission critical.

In fact, a study found that some firms maintain millions of spreadsheets, with a substantial number in daily operational use. These aren’t minor convenience tools; they’re accidental legacy systems at the core of business operations.

How we got here

Spreadsheets are brilliant. They’re flexible, fast, and accessible to everyone. They let business teams fix gaps, test ideas, and move quickly without waiting three months for IT to approve a ticket. That’s why they took root, and why they’ve become indispensable.

But what starts as a quick fix in someone’s Downloads folder slowly mutates into something far more dangerous: unofficial infrastructure.

This isn’t just a theory. The research backs it up. In their study Lessons from Mission-Critical Spreadsheets, Grossman and colleagues highlight how spreadsheets often evolve into production-grade tools without any formal development process. No documentation. No testing. No governance. Just layers of complexity added over time; until no one really understands how it works, but everyone depends on it.

Soon, you’ve got a dozen interconnected workbooks, each with their own fragile formulas, circular references, and hidden sheets. There’s no documentation; just a colleague named Martina who knows which cells not to touch. Half the logic lives in a macro written in 2016. The other half? Copied from somewhere and tweaked until it worked.

And this isn’t for tracking office snacks. It’s forecasting revenue, calculating commissions, or feeding data into a board report. A single corrupted cell, and the whole house of cards collapses. Because now you’re not just relying on a spreadsheet; you’re relying on a ghost system with no governance, no backup plan, and no accountability.

The hidden debt of spreadsheet dependency

Every time we lean on a spreadsheet to do the job of an actual system, we quietly rack up hidden costs. Here’s what that debt looks like:

User experience debt

Most business-critical spreadsheets are unusable unless you’ve been initiated into their secrets.

There’s no UI, just cells and chaos
Errors propagate like wildfire
Training new staff means walking them through 18 undocumented steps and praying they don’t press the wrong filter

You wouldn’t accept this in a customer-facing app. So why do we accept it in our internal backbone?

security risks

Spreadsheets get emailed. Uploaded. Downloaded. Left on USB sticks. Copied into random Teams chats. Synced across four cloud accounts. Dragged into personal folders just for backup. Then they sit there, untracked, unsecured, and forgotten.

(And please, don’t tell me your users would never do that. We both know they already have.)

The result? You’re not just dealing with bad habits; you’re dealing with a security disaster hiding in plain sight:

No access control: Anyone with the link, or just the file, can see everything. Customer pricing, payroll data, contract terms. It’s a goldmine for the wrong person.
No audit trail: Who changed that number? When? Why? No one knows. And no, last modified in Windows Explorer or your SharePoint library doesn’t count as governance.
No encryption — Most Excel files are wide open. Even password-protected ones can be cracked in minutes. And if they’re stored in an unprotected location, you’re already out of compliance.

Add to that the rogue versions scattered across devices, the shadow copies in email chains, and the manual updates happening off the radar, and you’ve got an environment where a single spreadsheet can undo years of trust, reputation, and regulatory effort. This isn’t a warning. It’s reality. One that too many organizations only recognize after the breach. And even then, they rinse and repeat.

Lack of governance

Who owns the spreadsheet? Who updates it? What happens if that person goes on leave, changes departments, or just stops responding to emails?

Even in organizations using SharePoint or OneDrive (yes, with version history technically enabled) that safety net unravels quickly. Why? Because people still save copies to their desktop. They still email attachments back and forth. They still rename files with cryptic labels like Q2_calc_FINAL_v2_UseThisOne.xlsx. They sync files across devices, edit them offline, and accidentally break the logic across three versions without realizing it.

So even if versioning is available, it doesn’t help when the right file isn’t in the right place, or when no one agrees which version is the source of truth. That’s not a tooling gap. That’s a governance void.

When something breaks (and it will), five people open five different versions, trying to reverse-engineer where it all went wrong. Everyone’s responsible. Which usually means no one is.

This kind of chaos would be unthinkable in your ERP or CRM, but somehow, it gets a pass when it lives in Excel. Until Kyle leaves… and takes half the operational logic with him.

Innovation gridlock

Sure, you can automate a process that relies on spreadsheets stored in shared drives. You can feed AI models with the output of nested IFERROR(VLOOKUP()) logic. But just because you can, doesn’t mean you should.

Because the real question isn’t what’s technically possible. It’s whether you can trust it, scale it, govern it, and explain it.

When your so-called data pipeline is a loosely managed web of spreadsheets — some on SharePoint, some on local machines, some emailed back and forth — you’re introducing friction at every step:

No single source of truth
No guaranteed structure
No lineage or auditability

And no confidence that what you’re automating is even correct

Data excellence is more than having numbers in rows and columns. It’s about consistency, validation, structure, and accountability. Without that, you’re not automating a process; you’re just automating chaos.

This is why so many digital transformation efforts stall. The tools are capable. The ambition is there. But the data is scattered across files, teams, and assumptions — full of outdated formulas and silent errors.

Spreadsheets are not the enemy. But building on them as if they were real systems? That’s just building on sand.

Operational fragility

Payroll doesn’t run because the macro didn’t. Compliance reporting gets delayed because the file won’t open. Revenue forecasts go sideways because someone broke a formula and didn’t notice. These aren’t edge cases. They’re everyday risks when your business relies on fragile spreadsheets.

In 2021, a UK health authority lost track of 16,000 COVID-19 test results due to Excel’s row limits. That’s not a tech problem. That’s using the wrong tool for the job — with real-world consequences.

Let me say it again:

Your spreadsheet is not a database.

It works fine — until it doesn’t!

Executives often justify the status quo with variations of:

We’ve always done it this way
It’s not worth the cost to replace
We’re too busy to change it now

But the real cost isn’t in the migration. It’s in every wasted hour, every manual fix, every security hole, every innovation that never ships because your data is stuck in Excel jail. You’re not saving money. You’re leaking value.

How to break the cycle

This is a call to use Excel for what it was built for: personal productivity and prototyping — not mission-critical operations.

Here’s how to start the shift:

Inventory your risks: Which spreadsheets support strategic decisions or operational workflows? You can’t fix what you don’t see.
Modernize incrementally: Don’t start with a six-month platform project. Start by moving logic into structured databases, and rebuilding workflows in Power Platform.
Establish ownership: Every spreadsheet with real business value needs a named owner, lifecycle policy, and documentation.
Invest in skills, not just tools: Equip your teams to design resilient processes, not just workarounds. This isn’t about replacing Excel; it’s about building maturity. And yes, this means investment in time and money.
Make the invisible visible: Track how much time is spent maintaining or correcting spreadsheet-based work. Show the hidden cost of doing nothing.

The bottom line

Spreadsheets aren’t the problem. Treating them like enterprise systems is. If you’re serious about innovation, resilience, and responsible governance, then it’s time to ask the uncomfortable question: What are we still propping up on Tom’s spreadsheet?

And what’s it going to cost us when that spreadsheet finally breaks?

Outsourcing your brain: cognitive offloading 'in the age of AI'

Thu, 15 May 2025 15:23:14 +0000

Here’s a fun experiment: when was the last time you memorized a phone number? Or did math in your head? Or remembered your colleague’s birthday without Outlook whispering it to you like a digital butler?

Exactly.

Welcome to the age of cognitive offloading, where our brains have quietly delegated entire functions to apps, calendars, and lately: AI. It’s efficient, it’s seductive, and depending on how you do it, it’s either genius… or digital lobotomy.

the case for outsourcing (some) thinking

Cognitive offloading isn’t a bug; it’s a feature.

Humans have always done it. Cave people probably scratched notes on walls because memory is unreliable and berries are seasonal. Fast-forward to 2025: we offload everything: navigation, scheduling, spelling, even ideation. And now, thanks to AI, we can outsource things that previously looked like our actual job: writing, analysis, even decision-making. And sometimes? That’s brilliant. And vendors like Microsoft tell us that it increases our productivity, as we do a thing faster. Managers keep echoing that, and now we have tighter deadlines to do that thing with the help of AI. Don’t get me wrong: You shouldn’t be doing long division if Excel can do it faster. You shouldn’t be rewriting the same email 17 times if Copilot nails it in one shot (If I’m really honest with you: not even Copilot should write the very same email 17 times… please rethink your processes before you automate them). And honestly, if an AI assistant reminds you that its your skip managers birthday today, that’s not cheating, it counts as survival.

But when does delegation become abdication?

Still there’s a difference between using a tool and becoming dependent on it. A recent study puts it plainly: when we offload without awareness, we lose track of what we know and what the tool knows. And then we start making decisions based on… vibes. Or worse, whatever the glorified autocomplete spits out.

Ever seen someone present an AI-generated deck with absolute confidence and zero clue? That’s offloading gone rogue. Another study on transactive memory (read: shared brainpower in teams) shows that when people coordinate their offloading (when they know who or what knows what) performance improves. But when everyone assumes someone else has got it, things fall apart fast. Sound familiar?

It does, because that’s the real reason why meetings are full of people Googling or ChatGPTing the same thing while pretending to be experts.

AI isn’t just a tool; it’s a mirror

What makes AI different is that it doesn’t just store info, but it also creates. It drafts, analyzes, summarizes, even jokes (as badly as prompted). It’s like a hyper-efficient intern who never sleeps and always says Yes, of course. That sounds great, but just like that overenthusiastic intern, AI tools have no idea when they are wrong unless you check. Please also don’t rely on them checking themselves when promoted. A lot of times, an LLM will confirm its wrong response with great confidence. So now we’re not just offloading memory, we’re offloading thinking. And if you’re not careful, you end up rubber-stamping whatever the AI produces and calling it productivity.

⚡ Newsflash: if you can’t explain your own report, you didn’t write it; the machine did. You’re just cosplaying a knowledge worker.

The creative paradox: more help, less soul

For creative workers, the risk is different. AI can be a great collaborator. It’s a jazz partner, a writing buddy, a second brain that never runs out of metaphors. But when every idea starts sounding like the internet’s greatest hits, you have a problem. If you’ve ever read a LinkedIn post and thought, this sounds like someone asked ChatGPT to write like a thought leader after three coffees, you know what I mean. Originality needs friction. AI removes friction. Which is great, until your work becomes smooth, bland, and utterly forgettable. And that means, that you become arbitrary as you don’t show your human ingenuity anymore.

How to use AI without becoming a puppet on a string

First things first: you don’t have to ditch AI completely. You just have to use it like a pro. A few rules for staying sharp:

Know what you’re offloading: Don’t just paste in a prompt. Ask yourself: what’s the actual work I’m avoiding
Interrogate the output: If it writes something for you, make sure you understand it. Better yet, rewrite it
Bring your own brain: Use AI to get unstuck, not to opt out. Use it to test ideas, not generate them wholesale.
Audit yourself: Can you explain the logic behind the conclusion? Can you defend it in a meeting without checking notes?

If your whole workflow is Ctrl+C from AI and Ctrl+V to your boss, you’re not a knowledge worker; you’re a middleman in a very short supply chain.

What’s at stake

Business leaders love AI because it promises efficiency. But there’s a cost to shaving off all the hard parts of cognition. Sometimes, the struggle is the point. That’s where insight lives. If we optimize everything down to content velocity and time to resolution, we may end up with faster output—and shallower thinking.

Closing thought: it’s your brain, use it (and have fun while doing so)

Look, I love AI. I use it daily. But it’s not my brain. It’s a sparring partner. A lab assistant. A caffeine substitute when I’m on deadline (because I quit drinking ☕). We need to stop pretending that delegating your thinking is the same as working smart. It’s not. It’s outsourcing your value.

Use AI to think better; not less.

I'm never going to financially recover from this

Thu, 15 May 2025 06:49:31 +0000

Don’t get knocked out by licensing costs

Power Platform licensing is often seen as the scary part. Mention a 5€ per user license, and someone inevitably reaches for a calculator: “Wait, with 3,000 users, that’s €15,000 a month — €180,000 a year… for a single app?!”

That reaction is common. And completely understandable, if you stop at the price tag. But if that’s the entire discussion, you’re missing the value conversation entirely.

Why the question is wrong

Too many Power Platform projects begin with the wrong question: “Can we build this without needing a premium license?” The better question is: What are we trying to achieve?

Are we looking to reduce costs? Improve efficiency? Free people from repetitive tasks? Reduce legal exposure? Support growth? If so, the conversation needs to be about value, not just license line items.

Because if we stop here, there will be a lot of canvas apps, that should have been model-driven apps in the first place, and this wrong architectural decision at the beginning of the project will have implications not only to security, compliance, performance, but also time to build the app. I saw it over and over again: Teams avoid premium licensing end up overusing canvas apps, over-engineering connections, and cutting governance corners. The result is higher development effort, lower performance, and avoidable complexity. Sometimes (often) it even leads to failure.

Trying to save money by avoiding licenses will cost far more in the long run. It’s inevitable. It’s not a maybe we need to revisit this app but this will by a massive cost grave if we don’t do it right straight from the beginning.

To make an informed decision, we should take a very close look at the options we have.

Decide based on data, not on bias

1 app vs App #1

One app might look expensive. But that app is rarely operating in isolation.

When you invest in the Power Platform as a strategic capability, not just a tactical tool to avoid some dev cost, you start to see compounding returns. Governance, security, Dataverse structure, and connectors become reusable assets. Every future app becomes faster to build and easier to manage. That’s where scale and efficiency live.

The benefits

Yes, there are direct, measurable results. Automating processes reduces operational costs. Workflows speed up. Time gets saved. Sales tools become sharper. Fewer mistakes, faster outcomes. But just as important, and often overlooked, are the long-term, strategic gains like security, risk mitigation, developer experience, employer branding.

These don’t always show up in your quarterly KPIs, but they move the needle in a sustainable way. And while they may seem intangible at first glance, they can be measured. You can quantify how much risk costs. You can measure reduction in incidents. You can track retention rates and hiring speed if your tooling is modern and attractive. These aren’t soft benefits. They’re just harder to fake.

The real cost of risk

Skipping proper licensing often means skipping governance, security roles, data segregation, and controlled environments. That introduces real risk. Not hypothetical. Real. To put a price tag on that, start with a basic framework:

Identify the risk (e.g., data breach, compliance failure, fraud, downtime)
Estimate the likelihood
Estimate the financial impact
Calculate the Expected Monetary Value (EMV): EMV = Probability × Impact

Then compare it to the cost of mitigating that risk. If the premium license helps you prevent a €100,000 issue with just a few thousand euros of investment, the business case is clear.

I made an app for that

So, if my customers wonder if paying the premium licenses are really worth it, I can help them with this decision, because I built a tool to help estimate benefits, costs, and risks. Not because it’s fun (though it is), but because too many decisions are made on instinct, not insight. If you’re not calculating return, and you’re not quantifying risk, you’re guessing. Of course, I built this as a model-driven Power Apps app, which first calculates all the hours that we can save by automating repetetive tasks away, how much manually post-processing needs to be done because of human errors that naturally occurs, but also assigns a risks score etc. to the more intangible benefits to put a price tag on things like effectiveness of dta classification, flexibility to new compliance requirements or speed of implementing changes. Organizations can assign a certain weight to those categories to get an individual assessment of the risk they are taking when they wonder of going the free route with creating Canvas Apps with a datasource on SharePoint would be a great idea.

In the long run

If you read this and wonder if you really, really, really need to buy the licenses… then here is some perspective, that might change your mind. If you constantly try to avoid licensing cost, then obviously, you drive Power Platform with the handbrake on. The not as obvious effects are even worse:

If you can’t spend costs, chances are, that there is no proper Power Platform enablement initiative in your organization. As you only work with included seeded licenses, you won’t put any effort into an onramp program. That leads to inadequate user training and adoption programs, Limited governance and security controls, absence of community and expert development as well as delayed innovation and competitive disadvantage.

Let me say this again: If you don’t invest in the platform, you have to deal with minimal-skilled users who are massively over-privileged in an immature environment. That is not saving costs, it is a recipe for desaster, as your projects will die and there will be data breaches and worse. But good news is: your competitors did invest. muahaha

Closing

If your app delivers less than $5 of value per user, it is just a toy, not a tool.

But most solutions I see deliver far more than that, especially when they reduce errors, cut manual effort, support governance, or provide real insight. The next time someone asks, Can we build this without premium? — flip the script.

Ask what it would cost to build it wrong.
Ask what risks you’re accepting.
Ask what you’re really trying to achieve.

Then measure that. And make your decision based on value — not fear. Hit me up if you need help with this!

Blueprint for a successful AI project

Wed, 14 May 2025 12:27:30 +0000

From chaos to clarity – how to build AI projects that actually work

If you’ve worked on an AI project recently, this probably isn’t a joke, it’s your backlog. For all the buzz around AI, many initiatives are still chaotic, short-lived, and poorly aligned with real business needs. The problem isn’t the technology but how we approach it.

And the landscape isn’t getting simpler. Especially in the Microsoft ecosystem, where customers are now faced with a growing menu of AI tools: Microsoft 365 Copilot for productivity, custom GPTs for tailored use cases, Copilot Studio for low-code automation, declarative agents for complex workflows. Each is powerful. Each promises value. But very few customers get clear guidance on what to use when and how these puzzle pieces fit together. This isn’t about a lack of choice, but about a lack of clarity. And clarity is exactly what AI projects need most.

Start with a problem, not a prototype

Too many AI initiatives begin with the tech. A new tool, a powerful model, or someone’s excitement about generative features. But without a clear, valuable problem to solve, even the most sophisticated solutions become expensive experiments. The right starting point is always the business challenge. What are we trying to change? What outcome defines success? And why is now the right time to tackle it with AI? If those questions aren’t answered upfront, the project isn’t ready, no matter how tempting the tooling looks.

Treat data like infrastructure, not a side task

Every successful AI initiative is built on data that’s available, trusted, and understood. That doesn’t happen by accident. It requires structure: governance, ownership, and often, a fair bit of human labeling work that rarely fits into the budget or timeline.

If the data isn’t usable, the model won’t be either. And if you’re not thinking about how that data will stay accurate over time, you’re not building a product, you’re making a throwaway demo.

Design for durability

Getting a model to produce decent results once is relatively easy. Keeping it accurate, explainable, and performant in a live system is not. That’s why so many PoCs vanish quietly after the initial excitement fades. From day one, design for monitoring, retraining, and change management. Make the system maintainable, auditable, and resilient to the inevitable drift in both input data and business priorities. A working model isn’t the end goal; it’s the beginning of a longer responsibility.

“Software being ‘finished’ is like the lawn being mowed. It’s not a state, it’s a moment.” - Ted Neward

Bring in compliance before it becomes urgent

Many teams delay thinking about legal, ethical, or regulatory implications until something breaks, or worse, ships. That’s not just risky; it’s expensive. Treat privacy, bias mitigation, and model explainability as design constraints, not edge cases. The earlier compliance gets involved, the more likely your solution is to make it to production…and stay there.

Assemble the right team

No single role can carry an AI project. Data scientists bring models to life, but without business context, domain expertise, and operational insight, even a technically brilliant model can misfire. The best AI outcomes come from cross-functional teams. Legal understands the risk. Ops knows the workflows. Designers think about trust and usability. Business leads connect the work to actual outcomes. AI isn’t a silo; it’s a team capability.

Measure outcomes, not just accuracy

It’s easy to over-focus on model metrics like precision, recall, confidence scores. They’re important, but they don’t tell you whether the project actually improved anything. Instead, measure impact: reduced costs, faster decisions, fewer errors, better customer experiences. And watch adoption. If no one uses the AI output, it doesn’t matter how accurate it is. Success means making the business better in ways that last.

Make AI boring

Commodity is the goal. Not shiny demos or endless PoCs, but systems that just work; models that can be trusted, maintained, and improved; solutions that quietly solve real problems and keep moving the business forward. Because right now, most organizations don’t need more AI options. They need AI decisions, based on purpose, not panic.

A hill to die on: there are no tiny changes

Tue, 13 May 2025 05:23:08 +0000

There’s no such thing as a small change

“Can we just move that button?”

“It’s just a quick fix."

“Tiny change, shouldn’t take long."

If I had a euro for every time I’ve heard that, I’d have long since retired from software, though probably not from cleaning up after so-called small changes. Let me say this loud and clear for the people in the back:

There is no such thing as a small change in software.

Every tweak, no matter how innocent it looks, sets off a chain of technical, architectural, and organizational consequences. Some are immediate; others quietly sit in the shadows until they break something important.

The myth of the harmless tweak

On the surface, it all seems trivial. Move a button. Rename a label. Add a checkbox. But under the hood, things are rarely that simple. Changing a layout might mean updating spacing logic, adjusting responsive behavior, and validating across multiple device types. A renamed label could trigger updates to automated tests, training documentation, screenshots, and localization files. Even a single UI element can ripple across the stack, touching everything from accessibility validation to release notes.

The development time for the change itself might be ten minutes. But doing it properly means ensuring nothing else breaks, verifying it behaves correctly in edge cases, and navigating governance processes. That can easily consume an entire day. Multiply that by the number of “quick wins” in a backlog, and you start to see the cost of this thinking.

When layout changes break real things

Changing a layout can, and often does, break things you didn’t intend to touch. That internal report used once a quarter? Gone, because the JavaScript function that rendered it was tied to a layout element that no longer exists. And oh I know! Ideally, a report-generating function shouldn’t be tightly coupled to a specific layout element. In a well-architected system, UI layout and business logic are clearly separated, with appropriate abstraction layers and clean interfaces. Unfortunately, lots of projects are not in that ideal state - and they suffer from just ship it mindset badly, where separation of concerns and encapsulation are treated as a nice to have, not a standard of how we develop software. But what about the screen reader that used to announce the “Submit” button? Now silent, because your oh-so-tiny change reordered the tab focus and wiped out the ARIA labels. The automated tests that ran fine last week? All failed last night, because your cleaned-up CSS classes broke the selectors used in the test scripts.

These aren’t hypotheticals. They’re the kind of things that creep in precisely because the original feature was rarely used, or only by specific teams like finance, legal, or compliance. It doesn’t matter that no one noticed during testing. They’ll notice when they actually need it. And by then, you’re already halfway through the next “minor” change.

Small surface, big impact

One of the most dangerous misconceptions in software is the assumption that something that looks small must be easy. It’s not.

Simplicity in appearance hides the complexity of interaction.

A design tweak that shifts the position of a component might sound like a harmless adjustment, but it could require revisiting layout logic, accessibility compliance, interaction flows, and translation strings, just to name a few. UI changes are rarely just UI. They’re system changes that happen to start with pixels.

What makes it worse is that developers often know this, but hesitate to say it out loud. Saying “this will take a day” makes you look like a blocker. So you nod, write the ticket, and let the cost show up later in the form of missed deadlines, brittle tests, or unhappy users. Everyone keeps the illusion alive because it’s easier in the moment.

Short-term relaxation means long-term tension, short term tension warrants long term relaxation.

The business cost of tiny lies

These illusions are expensive. You won’t see the impact of “just small changes” on a dashboard. It’s spread out: an hour lost here in testing, another in debugging, another rewriting documentation. But the cost is real. The more time teams spend chasing cosmetic requests, the less time they spend on real improvements. Productivity drops. Morale takes a hit. And quality quietly suffers. Meanwhile, the team that asked for the change? They’ve already moved on. The next request is in, and it starts with the same words: “Could we just…”

But what about typos?

This is where someone always chimes in: “Surely a typo fix is small?” Sometimes, yes. If it’s a plain text correction in a UI, it’s usually straightforward, just don’t forget to update the translation strings. But once you move beyond that, even typos can carry weight.

Fixing a typo in an error message, for example, can trigger a full localization workflow across ten languages. A label change might require updating automated tests, screenshots, and training documentation. A spelling mistake in a configuration file might not be a spelling mistake at all—it might be the one character that causes a parsing error and crashes the deployment.

Even a harmless code comment goes through version control, review, and deployment. It competes for attention with real fixes. So yes, some typos are genuinely tiny. But others are the software equivalent of stepping on a rake. And you usually don’t know which it is until your face hits the handle.

Treat change like the risk it is

If you want to move fast and deliver value, that’s great. But the path to speed isn’t paved with unexamined changes. It’s paved with clear priorities, contextual trade-offs, and honest conversations. Stop pretending that changes are small just because they’re visual. Evaluate changes by their impact, not their appearance. Bundle related work so teams aren’t testing blind. And for the love of software 💖, build a culture where asking “Why?” is seen as diligence, not defiance.

Final thought

Every change is a choice. Every “just one more thing” is a debt someone else pays. So the next time someone says, “Can we just…”, pause and ask: Do they understand what they’re asking for, or just what it looks like?

No, a crash course won’t make you an AI leader

Mon, 12 May 2025 06:49:31 +0000

Lately, I keep seeing weekend seminars popping up: Promising to turn you into an “AI leader”, prepare you for the role of Chief AI Officer, or help your company tick the compliance box for the EU AI Act. The messaging is clear: show up for two days, leave with a certificate after a multiple-choice test, and suddenly your organization has AI competency.

Does that sound convenient? Yes!

Is it dangerously misleading? Also Yes!

Does it get sold out anyway? [no comment💀]

Unfortunately, what’s being sold here isn’t transformation, it’s reassurance. And that won’t protect you from the real responsibilities that come with deploying AI at scale, especially in a regulatory environment that now requires you to prove that your teams are both competent and empowered to use AI responsibly. Now, you might think: “Sure, you can’t become an AI leader in a weekend, but what’s the harm in learning the basics?” On the surface, that sounds reasonable. But the problem isn’t the learning, it’s the illusion of readiness it creates. When a certificate suggests you’re now “qualified” to lead AI in your organization, it replaces the hard work of capability-building with a shortcut that feels productive but changes nothing. Worse, it can lead to false confidence, performative leadership, and decisions made without the depth to support them. Learning basics is good; mistaking them for strategic maturity is not. Self-organized learning is essential, especially for non-technical leaders. Understanding the basics of AI, its limitations, and its real-world implications should be part of every executive’s toolkit; not to become experts, but to ask better questions and make better decisions over time.

If you could solve transformation in a weekend, you would’ve done it by now

Change fatigue is real. So it’s tempting when someone offers a shortcut. A crisp two-day seminar. A certificate with “AI Officer” on it. A promise that you’re now ready to lead the future. I’m sorry to break it to you, but no title, no badge, no training event will fix what’s broken if your organization lacks the ability to learn, unlearn, and relearn as part of daily life. You can’t inject AI competency from the outside. You have to build it in.

Weekend seminars don’t change behavior. Culture does.

AI capability isn’t a line item

Most orgs aren’t suffering from a lack of information. They’re suffering from an inability to apply it consistently. A certificate doesn’t change that. A multiple-choice test at the end of a seminar won’t suddenly make your managers ask better questions, experiment responsibly, or challenge outdated assumptions.Worse: these kinds of “quick fix” approaches can create a false sense of progress. You’ve ticked the box, updated your Linkedin profile, announced the initiative, but nothing has actually changed. AI requires new patterns of work, new definitions of value, and a comfort with ambiguity that no workshop can magically install.

Transformation doesn’t come with a certificate

The work of AI transformation is messy. It involves tearing down legacy processes, empowering teams to make decisions faster, and shifting how you measure success. It’s cross-functional, ongoing, and often more than just uncomfortable. Change hurts.

So when you’re offered a seminar that wraps all this up into a neat package: beware. Real change doesn’t look like that.

Real change isn’t convenient.

What your company needs isn’t a weekend boost of inspiration. It needs a culture where learning is continuous, literacy is widespread, and leadership owns the responsibility for evolving the system, not outsourcing it.

If you still think the problem is skills, you’re not looking deep enough

Yes, technical skills matter. But the real blockers in AI adoption aren’t tools or training gaps, they’re structural. They’re the slow approvals, the siloed data, the outdated KPIs, the fear of failure, the lack of space for experimentation. None of that gets solved by putting a handful of people through a seminar, no matter how slick the website or how shiny the PDF you get at the end. A single event won’t shift how decisions are made. A certificate won’t fix the absence of psychological safety. A role title won’t overcome a culture that punishes risk.

You don’t need another training to feel good about progress. You need to build systems that allow progress to emerge, daily, from within. AI maturity is not a credential; it’s a condition of your organization’s culture. And you can’t buy that in a weekend.

What to do instead

If you’re serious about building AI capability in your organization, forget the fast-track badges. Focus on structure, not symbolism. Here’s what I do in projects that actually work out and move the needle:

Embed continuous learning into everyday work. AI isn’t a one-time rollout; it’s a moving target. Make learning loops part of your operating rhythm: cross-functional learning sessions, hands-on experimentation, peer exchange, and internal showcases. Not slides; not hype—practice. Make sure that people have time to do so. If they are buried in meetings that should have been an email, they won’t get far.
Distribute AI literacy, don’t centralize it. You don’t need a single “AI Officer”; you need hundreds of AI-literate employees who are confident to use the tools, question their outcomes, and escalate when something breaks. Make that normal. Make it safe.
Build trust into the process, not just compliance into the policy. The EU AI Act is about accountability. That starts with real governance: role clarity, transparency, auditability—and also with culture. If your people are afraid to touch AI without permission, you’ve failed before you began.
Tie AI efforts to actual business decisions. Stop treating AI like innovation theater. Use it to challenge cost structures, improve decisions, reduce friction, and rethink where human time is best spent. If it doesn’t change how value is created, it’s noise.
Invest in enablement, not vanity roles. The smartest AI initiatives are backed by practical enablement: internal communities, reusable templates, clear guardrails, and real leadership engagement. That takes time and commitment.

Transformation won’t happen in a seminar. But it will happen: quietly and sustainably, if you create the conditions for it.

AI as a finite vs infinite game in organizations

Wed, 07 May 2025 06:49:31 +0000

Most organizations are asking the wrong question about AI.

They’re asking: How do we win with AI? What they should be asking is: How do we keep playing?

The difference is subtle, but transformative. It’s the difference between approaching AI as a finite game or an infinite game. Simon Sinek popularized this distinction (originally developed by James P. Carse), and it offers a fresh, much-needed lens on how to lead AI adoption. (So now you know what’s on my nightstand :-))

Finite games vs infinite games

A finite game has fixed rules, known players, and a clear endpoint. Football is a finite game. So is a sales competition. In business, finite games are things like launching a product, completing a project, or winning market share in a specific quarter.

An infinite game has known and unknown players, changing rules, and no fixed endpoint. The goal isn’t to win, it’s to keep playing, to keep evolving. Relationships are infinite. So is learning. So is the long-term health of your organization.

Now let’s apply this to AI.

The finite game of AI: short-term wins, long-term waste

When companies adopt AI with a finite mindset, they’re thinking like this:

We need to show ROI in the next 6 months
Let’s automate something to cut costs fast
Let’s buy a tool and be seen as an AI-first company

This is the AI equivalent of trying to win a sprint when the race never ends. These companies launch a chatbot or predictive model, then stop improving it, they fail to build internal capabilities (so they stay dependent on consulting firms), they focus on tools, not data foundations and they treat AI as a tech implementation project, not a capability or culture shift.

Let me give you an example: A retail chain installs AI-powered cameras to detect shoplifting. They deploy fast, announce success, and move on. Six months later, false positives spike; staff don’t trust it; customers complain. The team has moved on to the next tech project. The AI system is abandoned or quietly switched off.

That’s a finite game result:

Project delivered, headline grabbed, but no sustained value 💀

The infinite game of AI: capability over completion

Organizations playing the infinite game think differently:

AI is a journey, not a deliverable
We need to build literacy, governance, and ethical capacity
Let’s focus on value creation over time, not one-off wins

This mindset leads to very different decisions. They start small but keep improving (e.g., one use case, continuously refined), they invest in data quality and cross-functional teams, they Align AI initiatives with long-term business goals, not quarterly targets and they create systems to learn from feedback; human and machine.

Also here I’d like to give you an example: A logistics company starts with a small route optimization model. It doesn’t save much money at first. But over 18 months, they improve their data quality, retrain staff, and integrate feedback from drivers. AI becomes part of how they think about operations. They begin experimenting with predictive maintenance and inventory forecasting. There is no big “launch”, just steady evolution.

That’s the infinite game at work: resilience, trust, and adaptability built over time.

5 Signs your AI strategy is playing a finite game

No long-term plan for AI talent development
Success measured only by ROI in months
Projects that launch but don’t evolve
AI decisions made in isolation from business strategy
Ethical risks treated as an afterthought

5 Signs you’re playing the infinite game

You’re building AI literacy across the organization
You have a data governance strategy aligned to AI goals
Your AI roadmap is flexible and revisited regularly
You learn from failures and adjust course
You’re measuring cultural and capability shifts—not just outcomes

Why this matters now

AI isn’t a tool you finish installing. It’s a capability you build and grow with. The rules will keep changing. New models will emerge. Regulations will evolve. Expectations from customers, employees, and the public will shift. If your mindset is fixed, your AI strategy will snap under pressure. But if your mindset is adaptive and designed to keep playing, you’ll build trust, innovation, and real value over time. This isn’t just about being more responsible, but about being more resilient.

AI is not a game to win. It’s a game to stay in.

Are you building to keep playing?

How to let your AI project fail in spectacular fashion!

Fri, 02 May 2025 07:39:11 +0000

There’s never been more urgency to do something with AI. Boardrooms are buzzing; slide decks are glowing; consultants are circling. And somewhere in between the executive mandate and the whiteboard workshop, someone says it:

Let’s just start with a few use cases.

What follows is rarely malicious. It’s process. It’s governance. It’s a carefully choreographed dance of inertia, ambition, and misplaced optimism. And it almost always leads to the same result: nothing that truly matters changes. So if you’re aiming to fail your AI project with grace and budget intact, here’s a carefully curated guide.

1. Begin with a boundless, context-free Excel file

Forget Miro. Or talking with people. Real AI projects start in Excel, always have, always will. Someone heard at a conference that you need to start with a list of use cases, so you do exactly that. You send out a template to every department asking them to fill in:

the use case title
a short description
expected value (TBD)
business owner (also TBD)
priority (which is always “High”)

By the end of the week, you have 137 rows. No duplicates, just thirteen slightly different versions of summarize meeting notes and seven interpretations of intelligent assistant for everything. Congratulations. You’ve achieved alignment through tabulation.

2. Democratize the discussion until it becomes unsolvable

Next up is stakeholder alignment. But make it a buffet. Invite everyone: product, HR, legal, compliance, data, ops. Now spend six meetings carefully defining terms like value and impact. Each department will have its own interpretation. The result? Two opposing paths:

A minimal, low-risk use case—safe, invisible, and guaranteed not to offend
A grand vision: AI-powered transformation, that spans every business unit and requires 18 months, 3 new vendors, and a dedicated tiger team. Choose whichever one ensures you won’t have to demonstrate impact before your next planning cycle.

3. Embrace the myths that quietly sabotage you

AI is new territory, but bad assumptions are timeless. These are the organizational beliefs that sound reasonable, until they quietly derail the entire effort:

You can’t give everyone Copilot licenses ’like Halloween candy’ - Because clearly, we should wait until we know who’s productive before enabling productivity tools. Genius.
We should only give licenses to power users - As if AI won’t reshape how non-power users work, collaborate, or decide. The logic: let’s transform work by empowering exactly the people who don’t want to change it.
Use cases must show immediate ROI - A classic. We’ll only invest in experiments that have guaranteed returns, thus eliminating the concept of experimentation entirely
Let’s focus on things that are easy to measure - Like token counts, number of summaries generated, or chatbot response times. Not actual impact on decisions, outcomes, or time saved
Let’s test this in a department where nothing mission-critical happens. Perfect. If it fails, it doesn’t matter; and if it succeeds, it’s still irrelevant. A no-risk, no-reward strategy.
We don’t need to involve IT until phase two. IT loves when people roll out security-sensitive pilots behind their back. Trust me.
AI can just learn from our content. Yes, of course! AI will parse our 15-year-old SharePoint graveyard and instantly understand our unique company culture and acronyms.

4. Misunderstand the value of an AI-driven workplace (on purpose)

For real. Most organizations aren’t failing at AI because they’re technologically incapable; they’re failing because they don’t know what success looks like. Or worse, they define success in such narrow, quantifiable terms that they miss the point entirely. When we talk about AI in the workplace, we usually rush to tangible benefits:

reduce hours spent on repetitive tasks
generate faster outputs (emails, proposals, analyses)
summarize content so we don’t have to read it
streamline approval flows or ticket triage
automate report generation and document creation

These are fine. They’re easy to measure and easy to sell. But if that’s all you get from AI, you’ve just made a slightly faster version of your current system, without changing how work actually happens.

The real potential lies in the intangible benefits:

cognitive relief: not having to remember which folder holds the policy document from 2021
confidence in starting: a blank page is intimidating; AI gives you something to react to
inclusivity: helping people with different working styles, language proficiency, or neurodiverse needs
better decisions: when analysis becomes trivial, people spend more time thinking
momentum: removing friction so good ideas don’t stall at the first approval gate

But these only emerge when you redesign the systems people work in. If you just drop AI into a dysfunctional process, you get slightly faster dysfunction. And most orgs are fine with that.

5. Replace strategy with prompt engineering

Now comes the execution phase. Naturally, you’ll skip over:

existing process inefficiencies
broken data foundations
user interviews
change management

Why? Because you found someone who knows how to ✨talk to the model✨. Your new prompt whisperer assures you that success isn’t about systems or behavior change; but about mastering phrasing. Invest heavily in personas, tone sliders, and clever ways to ask AI to act as a senior consultant with 20 years of experience in our industry. After all, if the demo works, surely production will be fine.

6. Automate dysfunction at scale

Every failing AI project eventually arrives here: automation without transformation.

don’t fix the process; just add a chatbot
don’t question the workflow; just wrap it in a summarizer
don’t challenge poor decision-making structures; just hope AI will clarify them

This is where AI becomes expensive window dressing. You might reduce some clicks, add a dashboard, or auto-generate a summary. But the system underneath—the approvals, the duplication, the unclear ownership—remains untouched. You’ve accelerated the wrong thing.

7. Celebrate the illusion of progress

At this point, you’ve technically delivered something. There’s a pilot. It has a name. Maybe even a logo. You announce it with fanfare:

🚀We’re proud to launch our first AI-powered assistant!🚀

No one uses it. No one trusts it. But it exists. And more importantly, it ticks the box on your innovation roadmap. You didn’t change how decisions are made. You didn’t create new leverage. But you did produce a very impressive PowerPoint. Mission accomplished.

8. The lesson we will now politely ignore

AI projects don’t fail because the models are weak. They fail because the organization avoids the hard stuff:

clearly defining a real problem
confronting the inefficiencies of its own processes
acknowledging cultural resistance to change
committing to outcomes, not experiments

We want the benefits of transformation without doing the work of transformation. And AI, with its promise of instant acceleration, makes that temptation harder to resist than ever. We could approach this differently. With honesty. With focus. With uncomfortable but necessary conversations. But there’s a new model out this week. Let’s start again 🙃

Still stuck in Permit A38? Stop AI-ing the wrong things

Wed, 30 Apr 2025 07:23:53 +0000

From control to trust: the cultural shift companies must embrace

In many organizations, getting anything done still feels like hunting for a mythical permit – a modern Permit A38 (Originally from the 1976 animated film Asterix Conquers Rome, “Permit A38” refers to a hilariously absurd bureaucratic ordeal, where characters are trapped in an endless cycle of forms, counters, and conflicting instructions. Over time, it became a cultural symbol for senseless administrative madness. My german readers will know it by the term “Passierschein A38”. For everyone who wants to cry in front of their screen: https://www.dailymotion.com/video/x36574i)

Employees battling endless approvals, layers of oversight and opaque rules find themselves stuck in bureaucratic mazes. This control‑based mindset is the legacy of industrial‑age management: every decision must climb a pyramid of sign‑offs. The result is a costly gridlock – projects stall, morale sinks, and the organization moves too slowly to adapt. In practical terms, managers who insist on rigid control create exactly the kinds of absurd roadblocks that the Asterix metaphor exposes through satire.

The antidote is a culture of trust and transparency (Yeah i know, what a revolutionary thought, that one could trust their employees and coworkers 😇) Instead of micromanaging every task, leaders give teams context and let them decide how best to achieve goals. Research shows that organizations with high‑trust cultures enjoy significantly better business results: high trust correlates with higher growth, profitability, employee retention and agility.

Trust means fewer hand‑offs and approvals: decisions happen where the work is done. Transparency (instead of information hoarding) removes hidden bottlenecks so staff can spot problems early. Together, trust and openness liberate creative energy: teams move fast because they aren’t slowed by fear of stepping on toes. Decisions aren’t rubber‑stamped by executives; instead teams act with great freedom as long as they align with clear company goals (but wait… did you communicate those? Just a friendly reminder to do this as well). An inspiring example? Morningstar (the tomato processing company) scrapped bosses entirely. Each employee negotiates their own mission and commitments, with all interactions being voluntary and no one forcing tasks on others.

This radical self‑management model has no place for the traditional HR “control tower”. The result is an extremely agile factory: employees handle surprises and make smart trade‑offs on the fly, instead of waiting on managers. Outcomes speak for themselves – Morningstar’s system yields record response times and customer loyalty.

Without this shift, companies will drown in bureaucracy

As Fujitsu strategist Robin Speculand puts it, painting a digital interface on old processes is just applying digital lipstick – it looks modern at first glance, but behind the scenes… there is too much bureaucracy. This will never deliver the agility and outcomes possible through true transformation

To genuinely break the A38 cycle, the entire culture must move from fear of risk and blind adherence to rules, toward trusting employees to do the right thing. As one study puts it: automation alone won’t fix flawed processes – you’ll just be doing the wrong thing, faster™️

Changing culture is hard, but the payoff is real

Organizations that invest in openness and empower their people become the agile, innovative ones. Indeed, Deloitte found that trusted companies outperform their peers by up to 400%, with trusted brands keeping customers and employees far longer.

In short, it’s time for executives to ask: are we creating more A38s in our org? Or are we replacing them with clear mission and trust? Companies that embrace a trust‑first culture move at the speed of ideas, not permissions. They bust bureaucracy instead of nurturing it, and ultimately achieve far more.

Breaking bureaucracy with tools?

It’s not just rules and forms – outdated tools fuel the madness. Too many offices still run on 1970s technology. Why are you still running your business entirely on email (1971) and spreadsheets (1976)? asks Nick Ellis – after all, time has moved on, but a lot of business practice has not.

In practice, clinging to email chains, paper forms and siloed spreadsheets costs time and money. Every hand‑written approval or attachment email is a mini‑A38: it forces employees to chase one another, re-enter data and wait days for a reply. Simple tasks like approvals that take an hour by email can be sliced to 10–15 minutes with an automated workflow.

But before we now jump onto the Everything is awesome wagon with Microsoft 365, Power Platform and more… let’s press pause for a while.

The most important insight is that technology should empower better processes, not just digitize flawed ones.

Before automating any workflow, leaders should ask whether each approval step still adds value. In many companies, extra sign-offs exist not to improve outcomes but to protect individuals from blame. We usually call this the cover my ass- culture. Simply automating an unnecessary approval only cements an outdated culture of caution and finger-pointing. Truly forward-looking organizations use new tools to question legacy habits. They strip out redundant approvals and give teams the autonomy to move quickly. The goal is not just a faster version of yesterday’s process, but a reimagined™️ process where trust, transparency, and clear responsibility replace rote checkboxes. By using technology to remove (not reinforce) needless checks and bureaucratic safeguards, businesses can unleash genuine agility and growth.

Let’s escape shallow AI use cases and fix systems that don’t work

After culture and tools, many executives pin their hopes on AI – yet too often it’s applied superficially. Let’s launch a chatbot, becomes the battle cry, without questioning if the root process is broken. In practice, these half‑baked AI deployments can create a new layer of frustration, not freedom. Consider chatbots: a recent survey found that more than two-thirds of customers have had a poor chatbot experience. The biggest complaints? Bots that can’t answer questions and fail to understand human needs, cited by roughly 70% of users.

In other words, people still demand to talk to a person when things get complex. Many companies indeed admit that replacing human agents with bots (to cut costs) leads to angry customers when the bot can’t help.

Internally, the story is similar: Helpdesk AI might quickly answer I need to reset my pasword, but when an unusual issue arises it simply dead-ends or loops. The net effect? Workers still spend hours waiting for a human fix – now worse off because they think the AI will solve it. This is the proverbial “new A38” in drag – technology promising relief but glossing over the real problem.

Slapping generative AI on a bad process is digital lipstick 💄

For example, a sales team might get an AI assistant that drafts emails, but if their CRM workflows are chaotic, they end up sending the wrong information to the wrong customer faster than before. We must be careful not to chase every shiny AI trend blindly. True “AI for good” is about fixing the system, not papering over it. It means applying AI to reduce friction and do work humans shouldn’t have to do. Here are some better examples than the let me chat to my documents because our SharePoint is an entire mess-use case:

Process Mining

Before automating, understand the flow. AI‑driven process mining tools connect to event logs (from email systems, ERPs, etc.) to map out actual business processes – including all the detours and rework. This “MRI scan” of the organization uncovers where approvals loop or people redo work. For instance, an analysis might reveal 15 ways a purchase order gets approved, with some taking 10 days. Armed with that insight, teams can eliminate a bad step, combine roles, or automate a hand‑off. Rather than guess-working, companies using process mining can identify millions in wasted time.

Intelligent Document Processing (IDP)

Many businesses drown in paperwork – invoices, forms, claims, contracts. AI‑powered IDP tools use OCR plus machine learning to read and extract data from any document. The impact is dramatic. Industry studies report that IDP can halve processing time and almost eliminate errors. In effect, IDP gives every worker a tireless assistant who “keys in” paperwork instantly.

AI‑Assisted Decision Support

Some decisions involve digesting complex data (risk assessments, scheduling, forecasts). Here AI can act as a true copilot. For example, machine learning models can score loan applicants instantly, highlighting the few that need human review. In inventory planning, AI can predict likely stockouts so buyers can reorder before shelves empty (fixing the “run down to the last piece” chaos). In HR, AI can flag the strongest candidates from thousands of resumes, ensuring recruiters focus on the best fit (rather than leaving applicants lost in inboxes). In each case, the bottleneck is not the chat, but the information overload – AI can cut through that.

Preventing “Fake Automation”

The worst trap is so-called automation that merely shifts work. For example, emailing a PDF and expecting staff to print-sign-scan it is not automation – it’s still a paper chase in disguise. Instead, organizations must integrate AI with workflow. An “AI‑powered invoice bot” should automatically post and pay the invoice once it recognizes approval, for instance.

Stop glorifying the pain

AI should make the pain points disappear, not glorify them. True success stories share a theme: AI unleashed human potential by eliminating drudgery. If employees felt stuck for a human reason (confusing form, unknown next step), talk to them and refine the process first. Then deploy AI to amplify the fix. Above all, remember Fujitsu’s warning: adding “digital lipstick” on broken processes frustrates both customers and employees alike.

Don’t let a bot become the new A38 – a sleek interface over a crumbling foundation. Instead, aim for digital transformation that truly, well, transforms: build trust and transparency and modern processes, then apply AI where it brings clear benefit. Escaping the bureaucratic maze isn’t about the next gadget or AI trick, but about aligning people, processes and technology. That means pausing after every automation sprint to ask: “Have we really solved the problem, or just done it faster?”

Automation does not equal transformation – if the underlying process is flawed, a faster car still gets you lost in the woods.

Now go fix the system, but don’t chase a new permit A38 with flashy new hats!

Some resources

Unmeasured Part 5 – Rethinking productivity for a human future

Mon, 28 Apr 2025 09:29:31 +0000

We questioned the obsession with “more” in Part 0, we exposed the wrong metrics in Part 1, we showed how running the business is easier to measure than changing it in Part 2, we dissected fake agility in Part 3 and finally we revealed the emotional wreckage of productivity theater in Part 4.

Now it’s time to ask: Is the system really broken or was it just built this way?

To me, it works as designed, still, let’s go fix it.

Productivity isn’t the enemy. Our definition is.

The problem isn’t that we want to be productive. The problem is what we’ve come to mean by productive. Faster. Louder. Busier. Visible. Measurable. Exhausted.

We’ve collapsed “productive” into “busy”, and then we wonder why teams move fast but go nowhere. Real productivity (the kind that actually changes things, builds value, and sustains people) is slower. It doesn’t neatly fit into sprint cycles, it doesn’t show up well in dashboards and it can’t b automated or templated. And that’s exactly why it matters.

Beyond output: measuring value and health

If we want a future worth building, we have to move beyond measuring units of work produced. We have to measure what actually creates progress:

Outcomes, not just deliverables
Learning velocity, not just story points
Sustainability of pace, not just effort levels
Creative breakthroughs, not just task lists
Psychological safety, not just attendance

You can automate output. You can’t automate meaning.

Rethinking systems, not just speed

The future of productivity isn’t about speeding up tired systems with better tools. It’s about redesigning the systems themselves. Systems that:

Leave space for deep work, real rest, and human rhythms
Reward challenging the status quo, not just clearing the backlog
Trust teams to make decisions, instead of drowning them in status meetings
Make recovery, creativity, and long-term thinking visible parts of performance

in short: Systems that see people as humans—not resources to be optimized. We don’t need faster teams. We need smarter environments.

So while we are at it: We should drop “HR” as in human resources. This technical framing on people is dehumanizing.

What real metrics could look like

Imagine this:

Instead of asking, How many tasks were completed this week? You ask, What friction did we remove?
Instead of tracking sprint velocity like a blood sport, you ask, What did we learn that will make the next sprint smarter?
Instead of bragging about being heads-down all quarter, you celebrate, What breakthroughs did space and rest create?

Numbers still matter—but they need to tell the right stories. Stories of impact, not just activity.

Copilot, AI, and the future of human work

AI is already taking over the visible, repeatable tasks:

Summarizing meetings
Drafting reports
Automating workflows

That’s not the threat. That’s the opportunity.

Because the parts of work that remain human, the ambiguous, the relational, the creative, the emotional, those are the parts we’ve historically undervalued and undermeasured. The future belongs to teams that stop fighting to outpace the machines and start doubling down on what machines can’t replicate: Judgment. Creativity. Empathy. Adaptability. Vision.

AI can draft a plan. Only humans can know whether it’s the right plan.

Closing: Beyond Unmeasured

We don’t need another round of optimization. We need a new philosophy of work. One that starts with a different set of assumptions:

People are not productivity machines
Value is not the same as volume
Rest is not a reward; it’s a requirement
Thinking time is not wasted time
Trust is not optional—it’s operational

This isn’t about working less, it’s about working right.

It’s about asking not just, How much did we do? but, Was it the right work? Did it matter? Did we leave space for better ideas, better systems, and better lives?

Better work begins with better systems. And better systems start when we finally measure the things that truly matter.

More parts of this series

Unmeasured: Part 4 – The emotional cost of the productivity theater

Sat, 26 Apr 2025 09:29:31 +0000

We gave everyone Copilot. We automated the meetings, the summaries, the reports. We freed up time. And what did we do with it?

We built a faster treadmill.

(I’d even call it a dreadmill)

We turned the productivity theater into a 24/7 show. We forgot that humans are not machines, and now we’re burning them out faster than ever.

Always performing, never breathing

Modern work has turned into a constant stage production. It’s not enough to do your job; you have to be seen doing it. Green lights in Teams chats, super-fast replies to emails, endless calendar invites that prove how busy and important you are. Every minute of your day is visible, trackable, and ultimately judged.

Thinking? Invisible. Strategic reflection? Invisible. Actual problem-solving? Mostly invisible too.

Copilot accelerates the visible tasks: writing emails, summarizing meetings, producing outlines faster than ever before. But instead of using the time gained to breathe, to think, to recover, we fill it with more noise. We push even harder. We demand even more.

We freed up time; then we punished people for not refilling it with even more visible busyness.

Speed isn’t freedom. It’s a trap.

Copilot and other AI tools were sold to us as a path to smarter, freer work. Less admin. Less repetitive grind. More room for creativity, for deep work, for innovation. But nobody updated the expectations. Nobody paused to ask: if the work speeds up, does the human pace stay the same?

Instead, faster output led directly to faster demands. Tasks that once took hours now take minutes, but rather than creating space to think better, we just stack more tasks on top. Deadlines shrink. Response times tighten. Expectations creep upward. The system got faster, but the humans inside it are still operating on the same biological limits, and they’re breaking.

The metrics are still killing us

The new world of Copilot-generated deliverables didn’t come with a new dashboard. It’s still the same old obsession: output, throughput, activity.

Managers look at the new velocity numbers with excitement, celebrating the “boost” in productivity without asking the harder questions:

Are people thinking better, or just producing faster?
Are teams learning, or just sprinting?

We have smarter tools, but we still treat people like battery packs: how much can we squeeze out before the lights flicker?

Productivity theater: a survival strategy

In this system, survival isn’t about doing better work but about being seen doing work. You learn quickly: Stay visible. Move fast. Never pause too long or someone will assume you’re slacking. The cycle feeds itself.

Hard thinking becomes risky. Questioning becomes dangerous. Deep work becomes a liability.

And so, people perform.

They perform busyness. They perform progress. They perform commitment. Not because they are lazy, but because the system rewards performance over purpose.

Productivity theater isn’t a glitch; it’s a rational adaptation to an irrational environment.

Burnout isn’t a bug

It’s the system working as designed. We pretend burnout is a personal failing. We say people should “manage their stress better”, “find balance”, “use their wellness apps”. Meanwhile, the entire structure demands more, faster, louder, constantly.

We don’t measure emotional load
We don’t track cognitive exhaustion
We don’t reward sustainable pacing or deep work or creative recovery

Burnout isn’t a rare tragedy. It’s a feature. It’s the predictable outcome of a system obsessed with deliverables and blind to human cost.

Now Copilot lets you create more deliverables, faster. And if you think that will reduce burnout, you haven’t been paying attention.

What if we measured what actually matters?

Imagine if the health of a team wasn’t judged by how many tickets they closed or how many meetings they sat through. Imagine measuring trust, safety, learning, and resilience. Imagine dashboards that asked:

Are teams making space for recovery after big pushes?
Are people allowed to say no to bad ideas without fear?
Are leaders modeling sustainable work, or just sprinting toward the next collapse?

You can’t automate empathy

Copilot can write your meeting summaries. It can help you draft your status updates. It can suggest faster ways to complete tasks.

But it cannot see when your engineer is one deliverable away from collapse. It cannot notice when your designer stops taking creative risks because they’re too drained. It cannot feel when your team starts working out of fear instead of purpose.

Empathy is leadership.
Empathy is strategy.
Empathy cannot be automated.

If we only optimize for visible output, we will burn through our best people, and no dashboard will warn us until it’s too late.

Closing thought

If your dashboards look great but your teams are exhausted, you’re not succeeding, you’re just managing a slow-motion collapse. Productivity gains mean nothing if they cost your people their energy, their creativity, their trust. The future isn’t about automating faster. It’s about caring smarter.

The next post will close out the Unmeasured series by exploring how we can rethink productivity altogether: Not just to get more done, but to build something more human, more sustainable, and ultimately more valuable.

Because better work begins with better systems. And better systems start by respecting the people inside them.

More parts of this series

Some resources

Unmeasured: Part 3 – The agility illusion

Thu, 24 Apr 2025 10:45:29 +0000

Agile is everywhere.
Every team is agile. Every board is a Kanban. Every meeting is a stand-up. Every backlog is groomed. Every two weeks is a sprint.

It looks good. It sounds good.
But let’s be honest—most of the time, it’s complete theater.

We don’t have an agility problem.
We have a pretending-to-be-agile problem.

How delulu are you?

Rituals without responsiveness

You can follow every step in the agile playbook and still be stuck in old behaviors:

Stand-ups that are just status updates
Sprints that are really just mini-waterfalls with fixed scopes
“Product owners” who just translate stakeholder requests
“Retrospectives” that produce action items nobody follows up on
“Velocity” charts used to pressure teams into overcommitting

These are rituals. And they often exist without the mindset that makes agility work: trust, adaptability, continuous improvement.

Teams burn through tasks at speed, but they’re not solving the right problems. They’re just sprinting in place.

If you ship fast but never stop to ask, “Should we be building this at all?”
You’re not agile. You’re just efficient at being wrong.

Weaponizing the Agile Manifesto

The Agile Manifesto wasn’t supposed to be a loophole.

It was written as a rebellion against heavy processes and rigid hierarchies: a call for teams to focus on people, collaboration, and real outcomes. But today? It’s often misquoted, misused, and turned into a shield for bad behavior.

Let’s talk examples:

“Working software over comprehensive documentation” becomes
“We don’t write documentation at all.”
“Customer collaboration over contract negotiation” becomes
“We’re building cool stuff… we throw it over the fence and keep fingers cross in hope for the customer likes it.”

Agility gets turned into an excuse not to plan, not to reflect, not to write things down. That’s not adaptive. That’s lazy.

Agile in form, waterfall in spirit

Many organizations claim to be agile but still operate with a waterfall mindset:

Quarterly “agile” planning cycles that lock in work for 3 months
Story point estimates (the bane of my existence) treated as fixed commitments
Teams with no autonomy, just assigned work from the top
Managers using Jira like it’s a performance tracker

You get speed, but not flexibility. Delivery, but no discovery. A product roadmap that’s full, but nobody’s sure why those things are on it.

It’s agile in form, but waterfall in spirit. (And a cry for help!)

The control paradox

Agile is supposed to be about trust. But in practice, it’s often wrapped in even tighter control:

More metrics. More meetings. More layers.
Teams are “self-organizing” on paper, but still need approval for everything
Leaders say they want experimentation (but only if it delivers predictable results on a fixed timeline with zero risk 🤡)

That’s not agility. That’s micromanagement in a hoodie and cool sneakers.

The Measurement problem (again)

Agile teams are constantly measured: velocity, burndown, throughput, cycle time. These can be useful. But when they become targets, they backfire:

Velocity becomes a scoreboard; teams inflate story points or sandbag to hit the number (been there, done that 😇)
Burndown charts become sources of anxiety instead of insight
“Team performance” becomes about moving units of work, not solving actual problems

Just like with productivity metrics, these tools stop being helpful when they’re used to judge instead of to learn.

If your metrics create fear instead of curiosity, you’ve lost the point.

So what does real agility look like?

Real agility is not stand-ups, sprints, or post-its on a whiteboard.

It’s a system that:

Empowers teams to make decisions
Encourages reflection and iteration
Prioritizes value over velocity
Builds space for thinking, not just doing
Respects quality—including tests, documentation, and design
Focuses on solving real customer problems, not just shipping features

It’s a system where people are trusted to change course. To challenge the brief. To say, “This isn’t the right thing to build”.

See how this neatly ties into the 2nd part of my unmeasured series (please, do yourself a favor and go read this if you came unprepared to this one, thanks)

Real agility supports “Change the Business” work.
Fake agility just helps you “Run the Business” faster.

Final thoughts

You can’t measure agility by counting how often you stand up. You can’t fake adaptability by sprinting harder. If the rituals are there but the responsiveness isn’t, it’s not agility. It’s performance. And performance is exhausting.

Part 4 will explore the emotional cost of productivity theater, and what it means to measure well-being, not just output.

Until then, maybe skip the retro this week and ask the real question:
Are we actually getting better? Or just faster at doing the wrong things?

More parts of this series

Some resources

Unmeasured: Part 2 – The difference between running and changing your business

Thu, 24 Apr 2025 06:45:29 +0000

Only measuring the visible half

In Part 0, I opened the series with a core challenge: How do we measure productivity in knowledge work when the work itself is abstract, dynamic, and often invisible? In Part 1, I unpacked how measurement tends to flatten complex human effort into simple outputs—units, tickets, hours, tasks.

Now in this part 2, we shift the lens from what we measure to where we measure. And the problem becomes clear: most organizations are only measuring the half of the work they can see: Running the Business, while ignoring the less visible but more impactful work of Changing the Business.

The comfort of the tangible

Dashboards are filled with numbers that signal control: cases resolved, hours billed, emails sent, campaigns launched. These are the markers of Run-the-Business performance. They feel satisfying because they’re concrete, immediate, and easy to quantify.

But there’s a trap here.

Tangible results are often short-term by design. They represent activity, not necessarily progress. Running the business efficiently doesn’t guarantee you’re heading in the right direction; it just means you’re moving fast.

In contrast, the work of Changing the Business is

Messy
Hard to measure
Long-term by nature
Usually intangible until much later

And yet, this is the work that drives real transformation. Strategy. Design. Capability building. Cultural change. These don’t show up in weekly reports, but they shape the next five years.

Run vs. change: The divide that shapes behavior

We often use “Run the Business” and “Change the Business” as simple labels, but their influence is anything but simple:

Run is visible, urgent, and metric-friendly. It thrives in dashboards.
Change is invisible, patient, and risk-laden. It often struggles for airtime.

Because Run work is easier to track, it becomes the default priority. That’s not just a reporting issue; it’s a behavioral one. When the organization rewards delivery over discovery, people adapt. They chase what’s measurable, even when it’s not meaningful.

The Eisenhower Matrix: Where Change Gets Lost

Let’s map this out using the Eisenhower Matrix:

“Run the Business” activities dominate the Urgent half. They feel vital, because they are. But they can also crowd out the Important half where Change work lives.

The most impactful work is rarely urgent. It’s strategic, slow-cooked, and context-heavy. But because it’s not immediately tangible, it’s the first to be postponed or deprioritized when the calendar fills up, especially, as there are rarely any passive-aggressive emails that state to be a “friendly reminder” or “bump this up in one’s inbox”. Change work is usually not depending on deadlines, nor does iit usually originate from someone else’s ideas.

The GenAI shift: productivity boost or treadmill acceleration?

Now enter Copilot and other GenAI tools. They promise a huge leap in productivity by handling summaries, content drafts, meeting notes, and even analysis.

That’s a game-changer for Run work. Copilot excels (pun intended) at accelerating the visible. But what does that mean for the invisible?

We now face a choice:

Accelerate the status quo, using AI to do the same tasks faster, creating space that gets filled with more of the same. (If you think that won’t happen, please dive into the beautiful rabbit hole of Parkinson’s Law)
Redesign the system, using the space AI creates to invest in strategic thinking, experimentation, and long-view transformation (but how do we justify this towards middle management with reliable stats 🤡)

Copilot can help us Change the Business, if we’re intentional. If not, it simply deepens our addiction to the tangible.

Why we need to measure the invisible

The obsession with short-term, measurable outcomes doesn’t just distort reporting; it distorts decision-making. It leads to

Undervaluing the people doing strategic or enabling work
Underfunding initiatives that take longer than a quarter
Mislabeling the slow, invisible work of systems change as unproductive

And yet, it’s precisely that work—planning, learning, experimenting that builds future value. We don’t feel the loss until it’s too late, as this is only noticeable in retrospective.

A new approach to measurement

To work smarter, not just faster, we need to

Surface the critical but hard-to-measure activities: coaching, stakeholder alignment, redesign work
Elevate metrics that track readiness, resilience, and options, not just velocity.
Use the capacity unlocked by GenAI to push deeper into transformation—not just crank the handle faster. AI should be your catalyst, not your crutch.
Pair operational metrics with insight-driven narratives. Numbers show activity; stories reveal impact.

Closing thought

We’re measuring the wrong half of the work. And we’re doing it with tools that are getting sharper, faster, and more seductive.

But if we don’t rebalance how we measure, we’ll keep winning at the wrong game. More emails. More deliverables. More output, without outcomes.

Part 3 will dive into agility—why so many teams look agile but don’t act agile, and how measurement plays a hidden role in that illusion.

More parts of this series

Some resources

Unmeasured: Part 1 – We are measuring the wrong things

Wed, 23 Apr 2025 08:41:29 +0000

There’s a spreadsheet* somewhere that says you had a good week.

You closed 19 Jira tickets
You replied to 143 emails
You joined 17 meetings and dropped 6 comments in a shared doc
You cleared your inbox twice
You sent a Teams message at 11:06 p.m., just so everyone knows you’re still “on it”

Congratulations. You’re crushing it. Right?

Right?

[* In fact, there is not one spreadsheet. There are several exported spreadsheets from all kind of apps that don’t talk to each other.]

Still worshipping the assembly Line

Most organizations today are swimming in metrics, but they’re still measuring knowledge work like we’re on the factory floor. It’s Henry Ford’s mindset in a Copilot world: track every movement, clock every hour, and reward visible output.

We call this “data-driven”. But let’s be honest: it’s mostly bullshit-driven.

We’ve built elegant dashboards on top of shallow metrics. We praise activity over impact, and we confuse quantifiable noise for real value. We pretend more data equals better decisions, but we’re just dressing up dysfunction in charts and calling it strategy.

The tyranny of vanity metrics

We celebrate the wrong things because they’re easy to track:

Lines of code written (even if they’re rolled back tomorrow)
Emails sent (even if they’re unread)
Meetings attended (even if they could’ve been a Loom)
Teams activity (even if it’s performative panic)
Time spent in the office (even if you’re just wandering between meetings)

These are vanity metrics. They give us the illusion of productivity. They make dashboards light up in happy greens and blues. But they don’t tell us if the work had impact. If it solved a real problem. If it made anything better.

And now? AI can write your emails. Draft your code. Summarize your meetings. You can game the system with ChatGPT and still look “productive” on paper. So what does your activity even prove anymore?

How do you measure thinking? You can’t.

You can’t measure the moment you step out of the shower and think, Wait, why are we doing it this way? You can’t measure the five-minute walk where your brain does the background processing and finally connects the dots. You can’t quantify the watercooler conversation that sparked a new direction for the team—because it wasn’t a scheduled “collaboration block” in the calendar. Thinking doesn’t show up in productivity metrics. Rest doesn’t either. Neither does curiosity, intuition, or the skill of asking the one question that unlocks a week’s worth of work.

The nonsense of the 40-hour week

And while we’re at it: who decided that a full-time job must be 40 hours? (I know, Henry Ford, but why do we still still stick to that?)

The 40-hour workweek wasn’t designed for creative problem-solving, deep thinking, or high-trust collaboration. It was designed for factory floors: to split the day into shifts and keep production lines moving. That model had one goal: obedience. Show up. Stay put. Follow the rhythm of the machine.

And we’re still running on it.

Say you’re a working dad*. You put in 30 focused hours a week, because you leave on time to pick up your kids, because you’re organized, and you don’t waste time. You deliver the same outcomes. Maybe better.

But you earn less. Get fewer opportunities. You’re treated as “less than full-time”.

Why? Because you didn’t reach the magic number. You didn’t conform to the schedule. You broke the rhythm of the system built around visibility, not value. This mindset punishes efficiency and rewards endurance. It favors people who perform time over people who perform impact.

Same goes for contractors - Customers want to know their daily rate and then compare these to the competitors and make the very big (and uneducated) assumption, that a lower daily rate will result in a less costly project. Well. Sorry to break it to you, but that’s not how things work.

The 40-hour week isn’t about productivity. It’s about control. And it’s time we stopped confusing obedience with contribution.

[* See what I did there 😇]

Success isn’t linear. So why do we measure it like it is?

The myth of linear productivity (that every hour produces an equal slice of value) is one of the most damaging ideas in modern work. Especially in knowledge work, where the value often comes in spikes: one conversation, one insight, one wild idea scribbled on a napkin.

Some of the most high-leverage work I’ve ever seen looked like “nothing”. Some examples?

A dev spending a day not coding to decide what shouldn’t be built.
A PM spending two hours rewriting the problem statement.
A senior designer deleting five ideas so the sixth one could breathe.

None of this shows up on a timesheet. But it’s the stuff that changes everything. But also… don’t get me started on timesheets 🙄. Well maybe a little rant:

Timesheets are a farce

Most timesheets are fiction. (will die on that hill)

They don’t capture what matters, because what matters (thinking, mentoring, unblocking, problem-solving) doesn’t fit neatly into time slots. So employees spend time they could use for something meaningful trying to retroactively guess how they spent their week. It’s not reflection; it’s a wild guessing exercise wrapped in administrative guilt.

And on the other side? Their manager:

Can’t verify whether any of it is accurate
Doesn’t have time to check even if they could
Just hits “Approve” to get on with their actual job

The result is a semi-automated, zero-value ritual that creates the illusion of control while delivering none. It adds overhead without insight. It’s bureaucracy disguised as accountability.

(And still every organization has some sort of timesheet approval process - or they ask me to build that for them. Thanks, but no, thanks.)

The Return-to-Office illusion

And then there’s the control problem that sits at the root of all that mess.

We don’t trust people to be productive unless we can see them. So we roll out return-to-office mandates. Mandatory in-person Tuesdays. Badge scans. Not because the work requires it, but because the building is lonely.

It’s not about outcomes. It’s about optics.

If someone delivers thoughtful, creative work from a quiet cabin, we call it slacking. If they’re triple-booked in glass-walled rooms five days a week, we call it committed. As if breathing stale air under fluorescent lights equals impact.

Especially to my US-american friends where this seems to be even more an issue than in europe: RTO isn’t strategy. It’s building management disguised as culture.

What are we actually optimizing for?

We build dashboards like they’re truth machines. But what if they’re just measuring noise? What if the things that really matter; insight, clarity, connection; are precisely the things that get crushed under the pressure to look busy?

What if we’ve built entire systems that punish the best parts of human work?

Creativity is messy
Progress is uneven
Meaningful work is often quiet
And the best ideas don’t come when we’re cranking out tickets; they come when we step away long enough to think

Toward something better

This isn’t just a rant. It’s a reckoning. We can’t fix the productivity problem by tweaking the metrics. We have to change the lens entirely. The question is no longer, How do we do more? It’s, How do we do what matters?

The next post explores the “Run vs. Change the Business” divide, and why we’re only measuring the part that’s easiest to track, not the part that drives transformation.

But until then, ask yourself:

Are you being productive, or just looking like it?

And who, exactly, benefits from the difference?

More parts of this series

Some resources

Unmeasured: Part 0 - More ain't better

Tue, 22 Apr 2025 08:41:29 +0000

If something grows endlessly, consumes everything around it, and destroys the host. What do we usually call it? Cancer.

It’s a stark metaphor, but an accurate one.

We’re obsessed with more. More meetings. More output. More growth, more velocity, more performance. Behind it all sits a deeply ingrained assumption: that more is better. Always. And the faster we can get to more, the more successful we’ll be. This logic is rarely questioned. It’s embedded into our calendars, OKRs, dashboards, and even our casual conversations. Ask someone how they are, and the answer is usually “busy” - and strangely they say it like it’s a good thing. We’ve accepted the idea that nonstop activity is a sign of relevance, that a packed calendar is a mark of status, and that burnout is just collateral damage on the path to achievement.

But we need to ask: at what cost?

We live in a culture that measures everything. Every click, every message, every hour. In the name of efficiency, we’ve turned productivity into something mechanical—transactional: Effort becomes recognition. Speed becomes value. Hustle becomes worth. It’s a system that promises clarity, but actually delivers alienation. Karl Marx once wrote about workers being alienated, not only from the things they produce, but from the process of work, from their fellow workers, and ultimately from themselves. In modern knowledge work, this is not theory, it’s everyday reality.

You finish the sprint, but don’t know who used the feature. You send the report, but don’t see the decision it informed. You sit in the meeting, speak your piece, and although you talk to people all day long, you are disconnected from any sense of shared purpose.

This isn’t just inefficient. It’s dehumanizing.

When rest becomes resistance

Against this backdrop, simply resting (truly resting) is radical:

Daydreaming. Lying in bed without reaching for your phone. Taking a walk with no productivity podcast in your ears. Staring out the window and letting your mind wander. In these moments, you are doing something profound: you are refusing to be productive in the way capitalism defines it. You are not producing. You are not consuming. You are not making someone else richer. You are simply existing, on your own terms.

And in a system designed to extract, track, and monetize every moment of your time and attention, that is an act of quiet rebellion. (and if you read my blog regularly, you know how much I like a lil rebellion)

Rest is not a reward

One of the most dangerous ideas we’ve internalized is that rest must be earned. Once the quarter ends. Once the deadline is met. Once the burnout becomes undeniable. But the truth is this: rest is not a luxury. It is not a treat. It is not something that comes after you’ve done the work. Rest is a prerequisite for clarity, resilience, and creativity. It’s the foundation, not the bonus. And yet our systems, our tools, and our culture often fail to account for this. They treat stillness as waste, silence as emptiness, and reflection as optional. This to me is a narrow and harmful view of what it means to be productive.

So what are we actually optimizing for?

We build dashboards and define KPIs. We measure tickets closed, lines of code written, emails answered. But rarely do we step back and ask: what’s the point?

Are we trying to maximize output or create lasting value?
Are we building faster teams or better ones?
Are we rewarding movement or meaningful progress?

Until we ask these questions, we’ll keep designing work environments that push people to perform but leave them detached from purpose. We’ll keep treating exhaustion as excellence. We’ll keep mistaking motion for meaning.

A more holistic perspective

This series is not about how to squeeze more out of people. It’s about stepping back and rethinking what productivity even means, especially now, in a world where AI tools like ChatGPT and Copilot are automating the visible, repeatable parts of knowledge work. We’re entering a new phase of work, one that demands a more holistic view of performance. One that honors strategy as much as speed, reflection as much as results, and people as more than inputs in a machine.

In the next post, we’ll explore how we ended up measuring the wrong things, and how we can begin to shift the focus back to outcomes, purpose, and impact.

But for now, let’s sit with this:

A full calendar is not a fulfilled life
Six figures is not a guarantee of happiness (unless they are the ones of the thumbnail of this post 😇)
And sometimes, the most productive thing you can do is absolutely nothing

What do you think?

Some resources

Isolation as a business model

Mon, 14 Apr 2025 08:41:29 +0000

Something strange is happening in how we live our lives. Helping a friend get to the airport, picking up groceries for an elderly neighbor, sharing a power drill with someone down the hall; these used to be everyday things. Now they feel rare. Not because people have changed, but because the system around us has.

When a friend drives you, Uber makes no money. When you help your neighbor, delivery apps lose a transaction. If four people share one drill, that’s three fewer sales. Every time we act together, someone loses a profit opportunity. And today’s economy is designed to make sure that doesn’t happen too often.

What we’re seeing isn’t just a shift in habits. It’s the result of decades of intentional design. A system that works best when we’re not working together.

The myth of the special individual

We’re constantly told that we are unique. And I know, I get it, we ARE!. But we are not the super special snowflakes entire industries like to tell us. That our preferences, needs, and routines deserve to be fully personalized. Every product and service is made just for you. Your news feed. Your fitness plan. Your therapy app. Your meal delivery.

It sounds empowering, but there’s something else going on. When everything is tailored to you, nothing is shared. No common experience. No shared reference points. No reason to talk to your neighbor about what you both saw, felt, or learned, because you each saw something different.

This isn’t a coincidence. It’s part of a larger strategy. If you think your problems are personal, you’re less likely to see the system behind them. If everything is about your individual needs, you stop looking for collective answers. And if you’re always focused on improving yourself, it’s hard to see how deeply connected your struggles are to everyone else’s.

Companies aren’t just selling you things. They’re collecting your behavior, predicting your actions, and shaping your decisions. Not to help you, but to turn your life into a set of profitable patterns.

Enter AI

Now AI is taking this even further. AI doesn’t just automate tasks. It automates connection. It gives you advice, teaches you new skills, and sometimes even talks to you like a friend. It never gets tired. It never asks for anything. It makes everything feel easier.

But in doing so, it slowly makes other people feel unnecessary. Why ask for help when an algorithm can give you what you want? Why deal with the mess of human conversation when you can talk to something that already understands you?

It sounds harmless. But when you step back, you realize what’s happening. AI isn’t just replacing jobs. It’s replacing relationships. It’s replacing the reasons we need each other. The more we turn to AI for emotional and social support, the more we forget how to do that with other people.

At the same time, these systems are far from neutral. AI systems tend to reinforce the same old inequalities. They rely on data from biased systems, and they’re built on the backs of underpaid and invisible workers who label, clean, and process the data. It’s exploitation hidden behind shiny interfaces.

Convenience as control

What’s striking is that none of this feels forced. No one is making you give up on community. You’re just tired. Busy. Looking for something that works. And the apps are there, ready to help. Personalized. Frictionless. Always on.

This is control through convenience. You’re not being locked up. You’re being nudged. Just slightly. Away from others. Toward the app. Toward the subscription. Toward the idea that being self-sufficient is the goal.

“I have become comfortably numb.” — Pink Floyd

We don’t resist it because it doesn’t hurt. It feels easy. Safe. Efficient. But that numbness, that dull sense of something missing, isn’t a bug. It’s the point.

It’s a quiet coup. Not a political one, but a psychological one. Where the tools that promise freedom slowly take away the things that made us human: interdependence, trust, shared experience.

What we’re losing

And with that, something deeper disappears. When we no longer share the same experiences, we lose collective memory. And without memory, it’s harder to notice patterns. To see injustice. To organize against it. To say, “This has happened before, and here’s how we responded.”

One of my favorite authors, Haruki Murakami, once said, “History is collective memories.” And if we let those go, we lose not just our stories, but our ability to resist.

What we can reclaim

The solution isn’t to reject technology. It’s to rebuild what it has quietly dismantled. Community. Mutual aid. Shared tools. Public spaces. Trust.

We have to make the choice to be less efficient sometimes. To ask each other for help. To slow down. To remember that not everything that scales is good. And not everything that’s frictionless is freedom. Because the more we act together, the harder we are to control. And that’s what makes solidarity so powerful. And so dangerous to a system that profits from our separation.

How to Build a List Formatting Web Part with all the cool samples from the Universal Sample Gallery

Thu, 20 Mar 2025 10:41:29 +0000

Introduction

If you’re a little bit like me and love working with SharePoint, you know how powerful it can be to format lists to make data more readable and visually appealing. But let’s be honest, the process of finding and applying column formatting samples can be a bit tedious. That’s why I decided to create an SPFx Web Part that simplifies this process. In this blog post, I’ll walk you through how I built this web part using React, PnP.js, and Octokit.

The Usual Process

Before I show you my the solution, let’s talk about the usual process for applying column formatting:

Find the Sample Solution Gallery or the List Formatting GitHub repo: This is where you can find a gazillion of formatting samples contributed by the community
Find a sample that is applicable to your column type: Not all samples work for all column types, so you need to find the right one Copy the code: Once you find the right sample, you copy the JSON code
Go back to your library: Navigate back to your SharePoint library
Paste the code: Finally, you paste the JSON code into the column formatting settings

My Idea

I thought, Wouldn’t it be great if we could choose from all the cool column formatting samples and apply them directly to a column without all the back-and-forth? So, I built a web part that integrates these samples seamlessly into SharePoint, where the work actually happens. This improves the user experience by making it easier and faster to apply column formatting.

To not make you scroll down, how this would look like: This is your sneak peek:

Project Structure

Here’s a mermaid diagram that illustrates the architecture of the web part:

Explanation

ListformattingWebpart: The main component that ties everything together
SiteSelector: Allows users to select a SharePoint site
ListSelector: Allows users to select a list from the selected site
ColumnSelector: Allows users to select a column from the selected list
ColumnTypeDisplay: Displays the type of the selected column
SampleGallery: Displays a gallery of formatting samples
SampleModal: Shows a preview of the selected sample
ApplyButton: Allows users to apply the selected column format
FeedbackForm: Allows users to submit feedback on the samples

Each component uses specific hooks to fetch data and manage state. For example, useFetchSites fetches the list of sites, useFetchLists fetches the lists, and so on. Using hooks makes my code modular, reusable, and easier to maintain. (Also I love that the individual files don’t get to long this way)

How to build this

Selecting the Site, List, and Column

Fetching Sites

We start by allowing users to select a SharePoint site. We use the useFetchSites hook to fetch the list of sites using the SharePoint Search API. Here’s how we integrate it into our SiteSelector component:

import * as React from 'react';
import { useFetchSites } from './useFetchSites';
import { Dropdown, MessageBar } from '@fluentui/react';
import * as strings from 'ListformattingWebpartWebPartStrings';
import { WebPartContext } from '@microsoft/sp-webpart-base';

interface SiteSelectorProps {
 context: WebPartContext;
 onSiteChange: (siteUrl: string) => void;
 className?: string;
}

const SiteSelector: React.FC<SiteSelectorProps> = ({ context, onSiteChange, className }) => {
 const { sites, message, messageType } = useFetchSites(context);

 return (
 <div className={className}>
 {message && <MessageBar messageBarType={messageType}>{message}</MessageBar>}
 <Dropdown
 placeholder={strings.SelectSite}
 options={sites}
 label={strings.Sites}
 onChange={(event, option) => onSiteChange(option?.key as string)}
 />
 </div>
 );
};

export default SiteSelector;

Fetching Lists

Once a site is selected, we fetch the lists within that site using the useFetchLists hook. This hook uses the sp.web.lists() method from PnP.js to retrieve the lists.

Fetching Columns

After selecting a list, we fetch the columns using the useFetchFields hook. This hook uses the sp.web.lists.getById(listId).fields() method from PnP.js to retrieve the columns.

Displaying Column Type

We display the type of the selected column using the useFetchColumnType hook. This hook uses the sp.web.lists.getById(listId).fields.getByInternalNameOrTitle(columnName)() method from PnP.js to retrieve the column type.

Fetching Column Formatting Samples from GitHub

We use the useFetchColumnFormattingSamples hook to fetch column formatting samples from the GitHub repository. This hook leverages the Octokit library to interact with the GitHub API.

import { useFetchColumnFormattingSamples } from './useFetchColumnFormattingSamples';
// ...other imports...

const SampleGallery: React.FC<SampleGalleryProps> = ({ columnType, includeGenericSamples, searchQuery }) => {
 const { samples, message, messageType, totalSamples } = useFetchColumnFormattingSamples(columnType, includeGenericSamples, searchQuery);

 return (
 <div>
 {message && <MessageBar messageBarType={messageType}>{message}</MessageBar>}
 <div>
 {samples.map(sample => (
 <SampleCard key={sample.key} sample={sample} />
 ))}
 </div>
 </div>
 );
};

export default SampleGallery;

Applying the Selected Formatting to the Column

We use the useApplyColumnFormatting hook to apply the selected column formatting. This hook uses the sp.web.lists.getById(selectedList).fields.getByInternalNameOrTitle(selectedColumn).update() method from PnP.js to apply the formatting.

import { useApplyColumnFormatting } from './useApplyColumnFormatting';
// ...other imports...

const ApplyButton: React.FC<ApplyButtonProps> = ({ selectedList, selectedColumn, selectedSample, selectedSite, context, selectedListName, resetInputs }) => {
 const { applyColumnFormatting, message, messageType } = useApplyColumnFormatting(selectedList, selectedColumn, selectedSample, selectedSite, context, selectedListName, resetInputs);

 return (
 <div>
 {message && <MessageBar messageBarType={messageType}>{message}</MessageBar>}
 <PrimaryButton text={strings.Apply} onClick={applyColumnFormatting} />
 </div>
 );
};

export default ApplyButton;

Recording Feedback in a SharePoint List

We use the useSaveFeedback hook to save feedback submitted by users. This hook uses the sp.web.lists.getByTitle('Listformatting-Feedback').items.add() method from PnP.js to save the feedback.

import { useSaveFeedback } from './useSaveFeedback';
// ...other imports...

const FeedbackForm: React.FC<FeedbackFormProps> = ({ context }) => {
 const { saveFeedback, feedbackSaved, error } = useSaveFeedback(context);

 const handleSubmit = (sampleName: string, rating: number, feedback: string, linkToSample: string) => {
 saveFeedback(sampleName, rating, feedback, linkToSample);
 };

 return (
 <div>
 {error && <MessageBar messageBarType={MessageBarType.error}>{error}</MessageBar>}
 {feedbackSaved && <MessageBar messageBarType={MessageBarType.success}>{strings.FeedbackSaved}</MessageBar>}
 <form onSubmit={handleSubmit}>
 {/* Form fields for sample name, rating, feedback, and link */}
 <PrimaryButton text={strings.SubmitFeedback} type="submit" />
 </form>
 </div>
 );
};

export default FeedbackForm;

Conclusion

In this blog post, I showed how to create a powerful SPFx Web Part that allows users to select a site, list, and column, fetch column formatting samples from GitHub, apply the selected formatting to the column, and record feedback in a SharePoint list. Next up: Applying Form formats!

Happy coding!

A Manifesto for Ethical Software

Wed, 19 Mar 2025 07:44:05 +0000

Technology shapes how we live, work, and interact. It has the power to create opportunities, but too often it reinforces inequality instead. Software should not contribute to racism, sexism, ableism, or colonial power structures. It should not automate oppression, deny access, or prioritize profit over people. The systems we build reflect the choices we make, and I refuse to create or deploy technology that harms marginalized communities.

This also means looking at who gets to make decisions. When leadership lacks representation from women, BIPOC, disabled people, and other marginalized groups, technology is shaped by a narrow perspective. That is not just a missed opportunity for innovation, but a direct cause of harm. Diverse leadership leads to better, more inclusive products. Without it, bias becomes embedded in the foundations of our systems. If a project does not reflect that reality, I will not be part of it.

Ethical responsibility does not stop at representation. Every developer has the right to know how their work will be used and to walk away from projects that put people at risk. AI trained on biased datasets, surveillance tools that target vulnerable communities, and software that collects data without informed consent all contribute to harm. These are not just technical challenges, but ethical failures. Transparency, accountability, and the ability to say no are essential in building software that serves rather than exploits.

Too often, the industry moves at a pace that ignores these responsibilities. Prioritizing speed and profit over care and safety has consequences. When accessibility is treated as an afterthought, people are excluded. When systems are tested only on a narrow group of users, they fail to serve the wider world. When documentation is written in a way that only a small group can understand, barriers are created instead of solutions. Ethical software requires slowing down, questioning assumptions, and designing for real people from the start. Testing must include diverse user groups, and documentation should be clear, inclusive, and available in multiple formats.

Privacy should not be a privilege for those with the resources to protect it. It should apply equally to everyone, without exception. Software should not rely on deceptive practices to extract user data, and consent should mean more than a checkbox hidden in fine print. People deserve to know what they are agreeing to in language they can understand.

Building technology is an ongoing responsibility. It is not enough to avoid harm. It is necessary to actively examine systems for bias, listen to those affected, and change course when needed. No software is neutral, and every project involves choices that impact real lives. Ethical development means taking those choices seriously, challenging the status quo, and refusing to accept systems that reinforce injustice.

Technology should serve people, not exploit them. It should empower rather than exclude. Every decision in software development shapes the future, and I choose to build a future that is fair, responsible, and inclusive. This is, what my claim means:

Changing the world one app at a time.

Why the infamous 'Lets make a list of use cases' is THE way to kill AI innovation

Sat, 15 Mar 2025 15:12:35 +0000

AI is here. Everyone knows it. Every leadership team wants a piece of the action. And so, the first instinct? “Let’s make a list of use cases!” Sounds logical, right? Compile a list, prioritize, evaluate, and eventually pilot the best ones. In theory. Because in practice, this approach rarely leads to anything meaningful. Instead, it becomes a corporate graveyard for AI ideas.

The illusion of progress

On the surface, making a list of AI use cases feels productive. It creates the illusion of momentum. Meetings are scheduled, brainstorming sessions are held, and a massive spreadsheet is filled with potential AI applications. But then… nothing. The energy fizzles out, and AI remains a PowerPoint slide rather than a business reality.

So what’s the problem?

Glad you asked. So many!

1. The black hole of stakeholder alignment

AI use cases often require input from multiple departments: IT, business units, compliance, legal, finance, operations. And if you are in Germany like I am: involvement of the workers council, the data protection officer, a union, and several more representative bodies. Getting all these stakeholders to the table is an exercise in herding cats. When they do finally meet, discussions stall because:

Some people don’t understand the technology well enough to make an informed decision
Others overcomplicate things, insisting on massive, transformative AI projects instead of quick wins
No one knows who actually “owns” the initiative

Result? Endless debates and no decisions.

2. Paralysis by analysis

Once the list is created, the next step is evaluation. This means assigning scores, defining impact metrics, and analyzing feasibility. But AI is complex. Many factors, like data availability, model accuracy, regulatory concerns, are unpredictable. Decision-makers, unfamiliar with AI (or only equipped with very superficial knowledge gained from private ChatGPT usage), struggle to evaluate viability.

So they delay. And delay. And delay. (Or have more meetings. Or both.)

Meanwhile, competitors who skipped the endless evaluation phase have already implemented something, learned from it, and moved forward.

One of the biggest, yet least discussed, blockers to AI success is low cloud maturity. Many organizations don’t have the foundational systems in place to even see where AI could be useful. They are essentially flying blind.

Take customer service as an example. In many companies, customer inquiries land in shared mailboxes, where service reps do their best to process them manually. But because these emails remain locked inside Outlook instead of being routed into a CRM or case management system, there’s no way to measure key metrics like:

When a ticket is opened
When it is resolved
What category of inquiry it falls under
How much back-and-forth is required to resolve it

Without this basic visibility, organizations can’t even begin to evaluate which categories of inquiries take the longest or where AI could automate processes. Instead of fixing this foundational issue by integrating emails into structured workflows (something that requires cloud maturity and organizational buy-in) companies stay in the dark, making AI decisions based on assumptions rather than data. And so, the “use case list” exercise becomes meaningless.

4. Skipping the homework: AI needs a strong foundation

Before AI can deliver value, organizations need to do their homework. Many companies want AI to solve their problems but haven’t built the necessary infrastructure to support it. This includes:

Cloud adoption - Without cloud-based workflows, AI cannot efficiently integrate into business processes
Governance frameworks - AI initiatives need clear rules on data access, compliance, and security
Data readiness - AI is only as good as the data it processes. If data is siloed, messy, or unstructured, AI will fail
Change management and adoption - Employees need training to understand and trust AI solutions, rather than resisting automation

Skipping these steps means organizations are trying to apply AI to broken systems. This will lead to inefficiencies, frustration, and failed projects

Ask me how I know!

5. Overcomplexity kills buy-in

Most organizations, when creating AI use case lists, aim high. They propose game-changing, business-critical, high-impact AI applications:

AI-powered supply chain optimization for global operations
Predictive maintenance across thousands of assets
Fully automated customer support with zero human intervention

Sounds great. But these require major investment, long implementation timelines, and buy-in from too many decision-makers. Getting approval for these is like pushing a huge boulder uphill.

Meanwhile, simpler, practical AI applications like document automation, intelligent search, email triage are overlooked because they don’t sound as exciting in a strategy meeting. Ironically, these are the projects that could actually deliver quick ROI and build momentum for larger AI initiatives.

6. Users don’t know what they need

Business users and decision-makers often struggle to articulate their AI needs because they don’t know what’s possible. They don’t understand the nuances of AI capabilities, nor do they have a clear picture of how different technologies (NLP, computer vision, machine learning) work together.

As a result, many use cases are either:

Overly generic (“Let’s use AI for customer service”)
Technically unrealistic (“Can AI predict exactly when each customer will churn?”)
Too vague to act on (“We need AI to improve efficiency”)

This leads to further delays as teams struggle to turn these ideas into actionable projects.

A better approach: Think small, move fast

Instead of making long lists, organizations should focus on rapid experimentation:

Skip the big list and start small - Pick one simple, tangible use case that solves a specific, well-defined problem
Build a quick Proof of Concept (PoC) - Instead of overanalyzing, test something small within weeks (or even days), not months
Measure impact fast - Focus on metrics that prove immediate value (e.g., time savings, cost reduction, accuracy improvements)
Expand based on learnings - Use insights from small wins to refine and scale AI initiatives

The reality: execution beats ideation

Most companies don’t fail at AI because of a lack of ideas. They fail because they get stuck in analysis mode. The longer they debate use cases, the further behind they fall. AI rewards action, not committee-driven wish lists.

Companies who fail to understand this, always remind me a bit of a cartoon I used to watch when I was way younger… These orgs try to “take over the world”, and for some reasons (see above) these nefarious world domination plans fail.

The question isn’t “What are all the ways we could use AI?” but “What’s one thing we can implement next month that delivers value?”

Narf.

What are we doing? I mean apart from back-to-back meetings and emails...

Mon, 10 Mar 2025 08:40:45 +0000

Your job title sounds impressive, but what do you actually do all day?

Most knowledge workers have impressive job titles. Strategy Lead. Innovation Manager. Digital Transformation Consultant.

Sounds impactful, right? But what do these people actually do all day?

Sit in endless meetings
Drown in emails
Chase approvals
Keep up with Teams, Slack and another dozen apps that act like Tamagotchis who desperately seek our attention

None of this is in anyone’s job description. But somehow, this is the job now.

And instead of fixing the root problem, we’re throwing AI at it.

AI to summarize meetings we probably didn’t need in the first place
AI to transcribe calls that could’ve been an email
AI to write emails no one really needs to read

We call this “progress”. But are we really winning anything?

We’re not solving the problem. We’re just making our inefficiencies more efficient.

How do we fix this?

AI isn’t the solution, work design is

Fewer, better meetings
- No agenda? No attenda.
- Default to async over sync
- Cap meetings at 20 minutes. No, for real. In case you can’t decide within that timeframe, it means that the participants aren’t prepared.
Kill the email addiction
- Reduce reply expectations
- Use structured communication (Teams threads > Email chaos)
- Automate low-value responses, but eliminate unnecessary emails entirely
Measure actual outcomes, not just activity
- Focus on impact, not hours logged
- Reduce performative “busyness”
- Give teams deep work time, not just AI-powered admin tools
Leverage AI for what actually matters
- AI should augment creative, strategic, and decision-making work—not just clean up our mess
- Use AI to eliminate low-value tasks, not make them easier to tolerate

If you need an AI-powered chatbot today to find the right document, you soon need an AI-powered chatbot to find the right chatbot, to find the right document…

In short: Do your homework first before you employ Copilot. Otherwise, the results will be disappointing (but then you get the chance to blame Copilot 🤡).

I am not saying that there are not good genAI use cases, but please stop this nonsense. We don’t need AI to be better at running in circles. We need to break the cycle entirely. Let’s stop optimizing inefficiency and start designing work that actually works.

Thoughts? What’s the worst example of “fake productivity” you’ve seen?

Productivity isn’t an assembly line: escaping the 1925 mindset with Microsoft 365 Copilot

Sun, 19 Jan 2025 11:04:59 +0000

Welcome to the age of AI – But let’s stop thinking like Henry Ford

For over a century, we’ve measured productivity the wrong way. Ever since Henry Ford revolutionized the assembly line, businesses have operated under the assumption that more hours worked = more output produced.

And sure, that works if you’re assembling Model Ts.

But if you’re a knowledge worker, the idea that productivity scales linearly with time spent at your desk is nonsense.

Yet here we are, in 2025, still thinking like we’re running factories

“If AI saves time, we need fewer workers.”
“If an employee finishes a task faster, they should take on more work.”
“Let’s measure productivity by how many emails, reports, and meetings someone completes.”

💡 Spoiler alert: Knowledge work doesn’t function like an assembly line. Adding more hours doesn’t necessarily add more value. (Usually, it’s even the opposite)

Which brings us to Microsoft 365 Copilot, and the huge misconception about its ROI.

The factory fallacy: Why productivity ≠ hours logged

In an assembly line, if a worker assembles 10 widgets per hour, they’ll assemble 80 in an 8-hour shift. Makes sense.

But if you tell a writer, analyst, marketer, or strategist to work 10% longer, will they produce 10% better work?

Will a lawyer’s contract be 10% sharper?
Will a marketer’s campaign be 10% more effective?
Will a strategist make 10% better decisions just because they sat at their desk longer?

Of course not.

Knowledge work is non-linear. Sometimes, an insight that takes 5 minutes is worth more than a full week of busywork.

Yet, despite overwhelming evidence, we still try to measure productivity in hours, not impact.

Parkinson’s Law: Why “busyness” is a lie

Have you ever noticed that work tends to expand to fill the time available? That’s Parkinson’s Law in action:

Work expands so as to fill the time available for its completion."

Meaning? If you give someone two weeks to write a report, they’ll take two weeks—even if they could have done it in three days.

The way we structure work creates artificial inefficiencies

Endless meetings that should have been an email
Reports filled with fluff because they “need to look substantial”
Workers staying late to seem productive, rather than being efficient

💡 Copilot doesn’t just save time: it removes the bloat.

The real ROI of Microsoft 365 Copilot: Less wasted time, more impact

Instead of seeing Copilot as a way to cut costs by reducing headcount, smart companies will use it to amplify human potential

Less Repetitive Work = More Creative Thinking
- If AI can generate a draft contract, the lawyer can focus on strategy
- If AI can summarize a meeting, the executive can focus on decisions
- If AI can clean up a dataset, the analyst can focus on insights

💡 Copilot doesn’t replace thinking: it enables it.
2. Time Saved ≠ More Time at Your Desk Just because an employee completes a report faster doesn’t mean they should immediately get another one

What if they used that time to

Think critically about the company’s strategy?
Experiment with new ideas?
Take a step back and ensure the work actually matters?

💡 High-value work happens in the gaps—not just in the grind.

Fewer Meetings, Faster Decisions
Copilot can generate meeting summaries, analyze trends, and suggest actions—meaning

✅ Fewer pointless meetings
✅ Decisions based on real-time insights, not gut feelings
✅ More time spent executing, less time spent debating

💡 Smart companies won’t fill freed-up time with more meetings. They’ll make faster, better choices.

The fatal ROI mistake: Trying to measure AI like an assembly line

Most ROI discussions around AI sound like this

“How many minutes does it save per employee?”
“How many fewer workers do we need?”
“How many tasks can we automate?”

🚫 This is the wrong way to think about it.

Real ROI isn’t just about saving time. It’s about using that time for work that actually matters

Would you rather:

Save 10% of your time and fill it with more low-impact work?
Save 10% of your time and use it to create something groundbreaking?

Smart companies choose option 2.

Final thoughts: The AI revolution is about impact, not hours

Microsoft 365 Copilot isn’t here to help businesses cut headcount, it’s here to help them redefine work itself.

The companies that thrive will be the ones that stop measuring productivity in hours and start measuring it in outcomes.

So the real question isn’t:
💭 “How many hours can we save?”

It’s:
💡 “What will we do with the time we save?”

Now It’s Your Turn: Are You Still Stuck in 1925?

Are you still measuring productivity like Henry Ford did 100 years ago?
Are you using AI to reduce costs, or to increase impact?
Are you thinking about time saved, or value created?

Let’s stop managing knowledge workers like factory workers. The future of work isn’t about doing more, it’s about doing better.

🔥 What will you do with your extra time?

Transform the way we think about Copilot

Thu, 16 Jan 2025 11:04:59 +0000

Bumblebee has been one of my favorite characters since REDACTED - this’d be too age revealing :-) Also, I LOVE building LEGO. There’s something magical about building a model that can seamlessly shift between a car and a robot. To me, this feels both playful and purposeful. The beauty of Bumblebee’s transformation is that it’s intentional and fluid, it adapts to the situation at hand rather than forcing a function where it doesn’t fit.

Much like how Bumblebee transforms based on necessity, we need to transform the way we approach AI projects. Instead of trying to find use cases to justify buying Microsoft 365 Copilot licenses (or really any AI powered app/solution/platform), we should be asking different questions:

Where are our biggest bottlenecks? Where do we waste time, money, or lose customers?

Only after identifying these pain points we should explore how to solve them, whether through automation, process improvements, or AI (and maybe Copilot). The real transformation comes from addressing fundamental inefficiencies, not just adopting technology for the sake of it.

Industry giants like Microsoft promote AI-driven products such as Copilot and Azure OpenAI and their compelling narratives and promises of enhanced efficiency and innovation (or should I say they just don’t stop talking about how everything is awesome with AI?) can entice organizations to prematurely incorporate these solutions.

However, this approach often leads to a scenario where businesses are retrofitting their operations to accommodate technology, rather than leveraging technology to address their unique challenges.

Read this again. Businesses try to proactively find use cases for AI, instead of exploring, evaluating, and addressing their pain points with appropriate tech (maybe AI).

To truly benefit of the transformative (🐝) potential of AI, organizations must pivot from a solution-first mindset to a problem-centric evaluation. That sounds counterintuitive as we all believe that we need to focus on solutions, not on problems. So let me guide you through how I approach this with my customers:

Take a step back and look at where things are getting stuck. Are employees spending too much time on repetitive tasks? Are budgets being drained in inefficient ways? Are customers frustrated with delays? Identifying these roadblocks first helps focus efforts on what actually needs fixing. Hint: If you find yourself or others saying We’ve always done it like this you might be already on the right track to find something that is worth to explore.
Once you know what’s slowing things down, it’s time to brainstorm solutions. Maybe it’s improving processes, automating routine tasks, or, yes, even bringing in AI where it makes sense. The key is to let the problem dictate the solution, not the other way around. Second hint: If you feel you need an AI agent to summarize all these long emails or all these long meetings for you… maybe it’s time to work on corporate culture. If entire days of the majority of employees are filled with meetings and emails, something is very wrong.
Prioritize solutions that offer tangible value and align with the organization’s overarching goals. For that, it’d be beneficial to know these overarching goals, which bring me back to: “Don’t make this an IT-only project”.

If you now think: “yeah, sounds all good, but in OUR super special organization, that wouldn’t fly, we will search for AI use cases and then implement them”: let me be a bit more candid here:

Your organization is not the snowflake you think it is.
Without a problem-driven rationale you will misallocate resources and you will need to deal with unwanted operational disruption, which will ultimately lead your AI initiative to fail to deliver the anticipated benefits.

The true essence of transformation, much like the LEGO Bumblebee model, lies in adaptability and purpose. Organizations can do the same, here are some ideas:

When we encourage teams to regularly assess and question existing processes, instead of having them overworked or pseudo-solving problems by throwing more manpower on them, we foster a culture of continuous improvement.
Get decision-makers and more stakeholders the insights and data necessary, we do not want them to navigate blindly. This also means, that you potentially need to be me open to share data in your organization
Stay open to a range of solutions, understanding that the most effective answer may not always involve the latest technology
Do more in terms of communication and training! Educating employees on AI use cases, governance policies, and best practices is the best investment you can make
Everything has a lifecycle, this also applies to governance policies, which are usually based on the frequency and impact of AI use cases

In the end, building and transforming that Bumblebee reminded me of something important: real transformation isn’t about just grabbing the newest, shiniest tech. It’s about stepping back, understanding what actually needs fixing, and making smart, intentional changes. If we approach AI the same way, focusing on real needs instead of justifying costs, we’ll create solutions that are actually valuable and sustainable 🐝.

Turning Culture Into Capital: AI and the new means of production

Tue, 10 Dec 2024 13:29:21 +0000

I love art. I love stories, music, and all the messy, beautiful ways humans express themselves. I’m also deeply fascinated by AI: It’s part of my job to consult companies on how AI can help them.

But I’m also scared.

Not because of the usual Terminator fever dreams (I’ve blogged about that) or even the Will AI take my job? fears. My unease comes from something deeper: the way AI intersects with late-stage capitalism and its relentless exploitation of our labor, creativity, and culture.

We live in a world (ChatGPT would even say: In today’s fast-paced digital world) where the gap between the wealthy and the rest grows wider by the day, and where every new technology seems to amplify that divide. AI isn’t just another tool, it’s a whole new means of production. The raw material? Us. Our stories, our art, and our collective creativity. The exploitation isn’t subtle, and it isn’t hypothetical. It’s happening now, and it’s reshaping not just jobs but society itself.

The Raw Material of AI: Us

AI doesn’t create from nothing. It generates text, art, music, and more because it’s trained on the cumulative output of humanity. Think about it: every book ever written, every photo uploaded, every Reddit comment, every meme: This is the data fed into AI systems. It’s a vast, unpaid labor pool of billions of people.

Take OpenAI or Mistral as examples. Their models are undeniably groundbreaking, but their success rests on data created by countless others. None of us signed up to have our posts, blogs, or digital creations mined to train these systems. And yet, the product that emerges is locked behind subscription paywalls, sold to us as something revolutionary. It is revolutionary, but it’s also exploitative. AI companies have essentially privatized the collective knowledge of humanity, transforming a shared resource into a commodity.

This mirrors the logic of capitalism: take what belongs to everyone, refine it, and sell it back at a profit. It’s the digital equivalent of the 18th-century enclosure movement, where common lands were fenced off for private gain.

Cultural Commodification in Late-Stage Capitalism

In the Marxist sense, AI perfectly embodies the concept of alienation. Creators, whether artists, writers, or coders, are divorced from the value of their labor. When your artwork is scraped from the internet to train a machine, you have no say in how it’s used or profited from. The product (an AI model) may replicate your style or generate content that competes with your work, but you see none of the profits.

AI has turned culture into a resource to be extracted. Just as capitalism once transformed raw materials like timber or coal into commodities, late-stage capitalism has done the same with creativity. The result? Tools like ChatGPT or MidJourney, which sell back the fruits of our collective cultural labor while further concentrating wealth and power in the hands of a few corporations.

For example:

Platforms like DeviantArt have seen AI tools mimic specific artists’ styles without their consent, flooding the market with cheap imitations
AI models can now create music indistinguishable from that of established artists, undermining musicians who rely on their unique sound to earn a living
Freelancers and content creators face growing competition from AI-generated articles that are faster and cheaper to produce, even if they rely on those same writers’ past works for training data

The exploitation isn’t limited to individuals: It’s systemic. AI tools are the perfect representation of this era: extracting maximum value from shared resources, privatizing the benefits, and leaving creators behind.

Reclaiming the Means of Production

In Marxist terms, the means of production refers to the tools and resources used to create value. In the industrial age, it was factories and machinery. In the AI era, the means of production are data, algorithms, and computational power. But unlike factories, the raw material for AI (the data) comes from the collective work of millions of people who never consented to its use.

This exploitation mirrors the capitalist dynamic of surplus value. The AI companies profit enormously, but the creators of the training data, whether knowingly or unknowingly contributing, receive nothing. It’s the same story told across centuries: labor (or creativity) is exploited to generate wealth for someone else.

But what’s truly at stake here is more than individual livelihoods. It’s culture itself. When the commons (the shared pool of human knowledge and creativity) is turned into a product, we lose something fundamental. Art and knowledge, once accessible to all, become luxuries reserved for those who can afford the subscription fees.

Imagining a Better Future

This doesn’t have to be our reality. There are principles that offer a lens to imagine alternatives: systems where the benefits of AI are distributed equitably and where creators retain ownership of their labor. Here are some ways we could start reclaiming the means of production:

Supporting open-source projects ensures AI remains accessible to everyone, not just those who can pay
Implement frameworks to compensate individuals whose work is used in AI training datasets, much like royalties in the music industry
Treat AI like a public utility. Publicly funded models could democratize access while preventing corporate monopolies.
Require companies to disclose their data sources and allow creators to opt out of having their work used for AI training

The AI revolution doesn’t have to mimic the inequalities of the industrial revolution. With collective action and a focus on equity, we can steer this technology toward a future where it serves humanity rather than exploiting it.

How to create a wordclock with Python

Tue, 19 Nov 2024 07:22:50 +0000

How I built a word clock that tells time in three zones

Some projects are born out of necessity; others, out of sheer “I never did this before so I guess it will turn out great”-attitude. This project firmly falls into the latter category. Inspired by the concept of word clocks (thanks Waldek Mastykarz) and motivated by the challenge of tackling time zones, I wanted to create a Python-powered word clock that tells time in phrases across three zones: Pacific Time (PT), Greenwich Mean Time (GMT), and Indian Standard Time (IST).

How I approached it

When I’m tackling something new, it helps to divide and conquer. Here’s how I broke the problem down into smaller steps:

Displaying time in words

The first step was figuring out how to translate digital time into phrases like “It’s a quarter past six.” I created rules based on the minute ranges:

If the minute is between 0 and 5, show “It’s [hour] o’clock.”
If the minute is between 15 and 20, show “It’s a quarter past [hour].”
If the minute is between 35 and 40, show “It’s twenty-five to [next hour].”

I stored these rules in a function called get_highlighted_phrases, which dynamically selects phrases to highlight based on the current time.

Building the clock GUI

Once I had the logic for the words, I needed a way to display them. I used Tkinter to build a graphical interface where the phrases are arranged in a circle, mimicking the feel of a classic clock. Each time zone has its own circle with phrases like “It’s” and “half past” positioned radially.

Handling time zones

Here’s where things got tricky. Time zones aren’t just about adding or subtracting hours. Some, like Indian Standard Time (IST), involve half-hour offsets. To handle this, I used the pytz library for PT and GMT but calculated IST manually using:

def get_ist_from_gmt(gmt_time):
 return gmt_time + timedelta(hours=5, minutes=30)

AM/PM quirks

One of the most unexpected challenges was ensuring the AM/PM indicator displayed correctly for IST, especially during transitions like midnight. I ended up flipping AM/PM specifically for IST using a conditional flag:

def get_am_pm(hour_24, invert=False):
 if invert:
 return "AM" if hour_24 >= 12 else "PM"
 else:
 if hour_24 == 0:
 return "AM"
 elif hour_24 < 12:
 return "AM"
 elif hour_24 == 12:
 return "PM"
 else:
 return "PM"

Debug tricks

Testing multiple time zones in real time meant countless print() statements, which eventually morphed into a helpful debugging function:

def debug_current_times(pt_time, gmt_time, ist_time):
 print("Debugging Current Times:")
 print(f"PT: {format_time(pt_time)}")
 print(f"GMT: {format_time(gmt_time)}")
 print(f"IST: {format_time(ist_time, invert_am_pm=True)}")
 print("-" * 30)

Where you can find the code

If you’re curious about how it all came together, or you want to try it yourself, check out the code at https://github.com/LuiseFreese/wordclock

Introducing Bluesky Terminal Poster

Mon, 11 Nov 2024 10:00:32 +0000

Hello World, Bluesky

Took me a while to fully adopt Bluesky, but here we are. One of the first things I try to do when adopting a service as a user, is also to have a peak the services API to understand what going on under the hood. So while I had a nice cuppa tea, I read in the Bluesky API documentation and had this nice geeky idea. Why not use that API to send posts directly from my terminal? When I just want to get my thoughts out, I do not necessarily need a UI (which will then only distract me again for the near forseeable future by making me read all the interesting posts others put out…I need to timebox the latter 🙈)

So how did I build this?

Setting Up the Project

In a new folder, create a new Python file: I named mine bluesky_post_image.py.
Install necessary packages: The requests library was essential for making HTTP requests to the Bluesky API. I also used Python’s json module to handle API responses. To install requests, run:


pip install requests

Understanding Authentication and Access Tokens

There is an ongoing joke in my filter bubble that’s like Once auth is done, everything else is easy. So let’s do this part thouroughly.

Bluesky’s API requires authentication to ensure that only authorized users can post on their platform. The first thing we need is an access token. Instead of directly using our username and password each time, we generated an access token, which acts as a key for logging in.

To get our access token:

We use an app password from Bluesky to authenticate with our handle.
This returns an access token, which we can use for any future requests within the session


import requests

def get_access_token(handle, app_password):
 url = 'https://bsky.social/xrpc/com.atproto.server.createSession'
 data = {
 'identifier': handle,
 'password': app_password
 }
 response = requests.post(url, json=data)
 response.raise_for_status()
 return response.json().get('accessJwt')

This function sends a POST request to the Bluesky authentication endpoint with our handle and app password, then returns an access token for further use

Posting Text Content

With the access token in hand, we can now focus on the main task: posting content to Bluesky. I decided to make the app post a simple text message first.

In the API call, I used the access token in the request headers:


def create_text_post(content, access_token):
 url = 'https://bsky.social/xrpc/com.atproto.repo.createRecord'
 headers = {
 'Authorization': f'Bearer {access_token}',
 'Content-Type': 'application/json'
 }
 data = {
 'repo': 'YOUR_DID', # Replace with your DID
 'collection': 'app.bsky.feed.post',
 'record': {
 '$type': 'app.bsky.feed.post',
 'text': content,
 'createdAt': datetime.utcnow().isoformat() + 'Z'
 }
 }
 response = requests.post(url, headers=headers, json=data)
 response.raise_for_status() # Check for errors
 print("Post created:", response.json())

This code sends the post content and metadata to the Bluesky API, where it’s added to our feed.

Attaching Images to Posts

An image tells more than a 1000 words, right? So once I had text posts working, I moved on to adding images. Posting images is a bit trickier because we need to:

Upload the image file to create a “blob” in the API
Use the blob’s metadata in our post request to attach the image


def upload_image(file_path, access_token):
 url = 'https://bsky.social/xrpc/com.atproto.repo.uploadBlob'
 headers = {
 'Authorization': f'Bearer {access_token}',
 'Content-Type': 'image/jpeg'
 }
 with open(file_path, 'rb') as img_file:
 response = requests.post(url, headers=headers, data=img_file)
 response.raise_for_status()
 return response.json().get('blob')

This reads the image file and sends it to Bluesky’s blob upload endpoint. The server responds with a blob object, which includes the image’s reference ID.

Creating a Post with Image

With the blob reference from our image upload, we can now attach it to a new post. I updated my create_text_post function to add the image as an embedded object


def create_post_with_image(content, image_blob, access_token):
 url = 'https://bsky.social/xrpc/com.atproto.repo.createRecord'
 headers = {
 'Authorization': f'Bearer {access_token}',
 'Content-Type': 'application/json'
 }
 data = {
 'repo': 'YOUR_DID', # Replace with your DID
 'collection': 'app.bsky.feed.post',
 'record': {
 '$type': 'app.bsky.feed.post',
 'text': content,
 'createdAt': datetime.utcnow().isoformat() + 'Z',
 'embed': {
 '$type': 'app.bsky.embed.images',
 'images': [{
 'image': image_blob,
 'alt': 'An image attached to the post'
 }]
 }
 }
 }
 response = requests.post(url, headers=headers, json=data)
 response.raise_for_status()
 print("Post with image created:", response.json())

In this function, I added an embed field with my image_blob, linking the image in my post.

Finally, I combined all my functions into a single script and added input prompts for the user to:

Enter the post content.
Optionally specify an image path to attach.

If you want to check it out, I put it on GitHub and would love for you to try it out!

And this is my first post from my terminal which attaches an image:

Can I post images straight from my terminal as well?

[image or embed]
— Luise Freese (@luisefreese.bsky.social) November 11, 2024 at 8:33 AM

Have any questions?

Contact

How to make a SharePoint Web Part multilingual

Sat, 02 Nov 2024 10:12:16 +0000

If you want to easily allow users to have your SPFx Web Part in a language of their liking, this guide is for you. To enable this multi language feature, we need

Define the keys and their types for localized strings in the mystrings.d.ts file like this:

declare interface ISvgToJsonWebPartStrings {
 saveConfiguration: string;
 libraryName: string;
 column: string;
 selectColumn: string;
}

declare module 'SvgToJsonWebPartStrings' {
 const strings: ISvgToJsonWebPartStrings;
 export = strings;
}

Depending on how much text you have in your Web Part, this can be a rather tedious task 😇.

(replace the SvgToJsonWebPartStrings with your Web Part Name)

Now in the en-us.js file (it’s in the loc folder) you will define for each of your keys that you have in the mystrings.d.ts file, a key-value pair in english. If you also need de-de.js for german, or fr-fr.js for french or any other language, create a file with the name of that locale in the loc folder and provide a translated version of the values of the en-us.js file (Hello 👋 Copilot).

This should look a bit like this:

define([], function() {
 return {
 "saveConfiguration": "Konfiguration speichern",
 "LibraryName": "Bibliotheksname",
 "column": "Spalte",
 "selectColumn": "Wählen Sie eine Spalte"
 }
});

Now replace all the hard coded strings like button texts, placeholders, labels, error messages etc. with strings.<keyname>, so for example strings.column.
As a last step, you need to import the strings into the file you want to use them with something like import * as strings from 'SvgToJsonWebPartStrings';

If you now run gulp build and gulp serve again to try out your masterpiece in te workbench and want to see your newly added languages, append the URL https://<your tenant>.sharepoint.com/_layouts/15/workbench.aspx with ?locale=de-de or any other locale that you created.

Congrats! You enabled a multi-language feature in your Web Part and also improved the logic of it. Now if you change a text, that will appear two or more times in your Web Part once it reflects this everywhere, so less manual changes!

If you want to have a look at the Web Part (which is still work in progress), you can do this here: react-svg-to-json-converter/. Let me know what you think!

#FF69B4 or how to read Hex Color Values

Fri, 01 Nov 2024 06:43:58 +0000

I like pink. Like, a lot. To an extent, where it’s not just ANY pink, but a very specific one. It’s #FF69B4 - hot pink. Whenever I mention this, people ask me how I can remember this value and also how to read hex color values.

The thing about hex colors is that they’re pretty straightforward once you understand what those six characters are doing. It’s not some magic - it’s just a different way of counting. Think of it as a very efficient way to tell your computer exactly how much red, green, and blue you want in your color. And since I’ve spent an embarrassing amount of time explaining this to fellow developers (who always tell me that they are just not good at anything with design 🙈), let me break it down properly.

Color Addition vs. Subtraction: Understanding Color Models

Colors behave fundamentally differently depending on whether you’re working with light (like on your screen) or pigments (like in print). Think of it as the difference between adding spotlights versus layering filters.

Additive Color (RGB)

On screens, we’re essentially working with three colored spotlights: red, green, and blue. When these lights overlap, they add together to create new colors:

Red + Green = Yellow
Green + Blue = Cyan
Red + Blue = Magenta (hello, hot pink's cousin!)
Red + Green + Blue = White

This is why combining all colors on your screen produces white - you’re adding all wavelengths of light together. It’s like pointing red, green, and blue spotlights at the same spot on a black surface. Where they overlap, you get white light.

Subtractive Color (CMYK)

Now flip that concept for physical media. Instead of adding light, we’re filtering white light through layers of cyan, magenta, and yellow pigments. Each layer acts like a filter that subtracts certain wavelengths:

Cyan = White - Red (blocks red light)
Magenta = White - Green (blocks green light)
Yellow = White - Blue (blocks blue light)

When pigments overlap:

Yellow + Magenta = Red (blocks blue and green)
Magenta + Cyan = Blue (blocks green and red)
Cyan + Yellow = Green (blocks red and blue)
All three = Black (blocks everything)

This is why printers use CMYK (Cyan, Magenta, Yellow, and Black). Each color acts as a filter, removing specific wavelengths from white light. Stack them all together, and you’re blocking all wavelengths - giving you black.

Hexadecimal Color Representation

A hex color code represents precise RGB color values in a base-16 numeral system. Unlike decimal (base-10) or binary (base-2), hexadecimal uses sixteen distinct symbols: 0-9 for values zero to nine, and A-F for values ten to fifteen. This makes hex particularly efficient for representing color values, as each hex digit perfectly represents four binary digits (bits).

The structure of a hex color code is straightforward


#FF69B4
 | | |
 R G B

Each pair of characters represents a color channel’s intensity, ranging from 00 (0 in decimal) to FF (255 in decimal).

Breaking Down #FF69B4

Let’s decode our hot pink example:

Red Channel (FF):
- FF in hex = 255 in decimal
- Maximum red intensity
Green Channel (69):
- 69 in hex = 105 in decimal
- Moderate green intensity (about 41%)
Blue Channel (B4):
- B4 in hex = 180 in decimal
- Substantial blue presence (about 70%)

This combination yields RGB(255, 105, 180), creating that distinctive hot pink color 💖

Let’s visualize this:

Fun Facts to drop at your next party

Hot pink isn’t real. Well, not in the traditional spectrum of light. It’s actually your brain trying to make sense of seeing red and blue at the same time. It’s basically a color hallucination we all agree on.
Hex codes could have been longer! They almost had seven characters instead of six, with an extra digit for transparency. But someone decided to keep things cleaner, and now we have our neat six-character codes. If you want to learn more on how to get transparent hex values: https://gist.github.com/lopspower/03fb1cc0ac9f32ef38f4
Red is boring, so you can also use

* {
 outline: 1px solid #FF69B4;
}

for debbuging! 4. For some reason, I also like #038186 - Can you guess why?

And just in case you missed it - Any idea what is the accent color of this blog? Now go forth and color the world! Just remember: when in doubt, hot pink is always a valid choice. 😉

Improving a Web Part with PnP.js and React Webhooks

Sun, 20 Oct 2024 06:43:58 +0000

I promised, I’d improve my initial draft. So I want to address three things in here:

Using PnPjs
Splitting up a huge component in a parent component and child components
Leveling up with custom hooks

💡 This post is part of a series:

Building my first SharePoint Web Part with SharePoint Framework Toolkit- From Web App to Web Part
📌 you are here: Improving a Web Part with PnP.js and React Webhooks
Making a Web Part ready for the Sample Solution Gallery - to be published soon

First things first - here is an up-to-date screenshot so that you know what we are talking about!

Additionally to introducing a new features that allows users to not only select lists and their columns on the site the Web Part lives on, but also select a site, and then the lists and columns, I focused on improving the code itself.

Using PnPjs

Oh boy, I did it the hard way and used native SharePoint REST API to get lists and columns. This made my code unnecessarily convoluted. It took me a while to realize that. I started without PnPjs as I thought it would be easier for me as a an SPFx beginner. I need to admit though, that quite the opposite was the case. So after a friend said “Wow I did not even know that one could use SharePoint REST natively as I always use PnPjs”, this was the sign for me.

Why not using the library everyone and their mom is using?

So PnPjs to the rescue!

I think this is the best thing that I discovered so far about SPFx! It’s a huge simplifier as URL construction, headers, authentication are handled by PnPjs, so no need to manually craft a URL, set headers etc.

To transform from a SharePoint REST API call to PnPjs, you will

install PnPjs with

npm install @pnp/sp @pnp/common @pnp/logging @pnp/odata

import the modules into your code

import { spfi, SPFx } from "@pnp/sp"; // PnP JS functions
import "@pnp/sp/webs"; // Import the SPWeb methods
import "@pnp/sp/lists"; // Import the List methods

initialize PnPjs with SPFx context

const sp = spfi(props.siteUrl).using(SPFx(props.context));

[props.siteUrl is the SharePoint site URL, props.context is the context provided by SPFx Web Part for authentication]

Replace REST API calls with PnPjs methods and remove headers - example

This is the native SharePoint REST API implementation


const response = await fetch(`${siteUrl}/_api/web/lists?$filter=Hidden eq false`, {
 method: 'GET',
 headers: {
 'Accept': 'application/json;odata=verbose'
 },
});
const data = await response.json();
const lists = data.d.results;

This is the PnPjs method:

const lists = await sp.web.lists.filter("Hidden eq false")();

SO. MUCH. CLEANER.

So rinse and repeat for all the other calls! This is stil a work in progress, but getting there!

Split up the main component in child components

At first, I only had one very lengthy SvgToJson.tsx file, which made it hard for me to read code and address issues. So I worked on splitting up this beast into several child components so that my main react component would orchestrate the functionality of the Web Part and takes care of managing state and rendering the child components. In my case, this means, that I have components for

SVGInput.tsx - Allows users to select an SVG file from a SharePoint library
SVGOutput.tsx - Displays the selected SVG content
ConvertButton.tsx - Converts the SVG content to JSON format
ToggleSwitch.tsx - Toggles visibility of SiteSelector, ListSelector, ColumnSelector, and ApplyButton
SiteSelector.tsx - Allows users to select a SharePoint site
ListSelector.tsx - Allows users to select a SharePoint list
ColumnSelector.tsx - Allows users to select a column from the selected SharePoint list
ApplyButton.tsx - Applies the JSON result as column formatting to the selected SharePoint column
Message.tsx - Displays messages users
TeamsSaveCongurations - Allows users in Microsoft Teams to set the site URL and the library Name where SVGs come from

To move functionality to a child component, you will

Create a new .tsx file in the same folder the other .tsx files live in
Move the logic from the main component to the new child component
Define props for the child component
Pass props from parent (main component) to child component

This takes care, that I have a lot more files, but that each file has a very dedicated scope which makes it a lot easier to go on bug-hunt 🐛.

Playing with react hooks

I learned about custom hooks and thought it would be a great idea to making my components even more maintainable as they get cleaner. I think of them like a function that can use the already existing hooks (like useState and useEffect). This means: You write the logic in a separate file like useFetchLists.ts and call this function from your child component file. So we can now use this custom hook (function) in any component that needs to get lists from a SharePoint site. That means you only need to write (and debug and test) that code once. Also, I find it way cleaner to separate data-fetching-logic from UI logic.

Here is my useFetchLists:


import { useState, useEffect } from 'react';
import { spfi, SPFx } from '@pnp/sp';
import "@pnp/sp/webs";
import "@pnp/sp/lists";
import { IDropdownOption, MessageBarType } from '@fluentui/react';

const useFetchLists = (siteUrl: string, context: any) => {
 const [lists, setLists] = useState<IDropdownOption[]>([]);
 const [message, setMessage] = useState<string | null>(null);
 const [messageType, setMessageType] = useState<MessageBarType>(MessageBarType.info);

 useEffect(() => {
 const fetchLists = async (): Promise<void> => {
 if (!siteUrl) {
 return;
 }

 try {
 const sp = spfi(siteUrl).using(SPFx(context));
 const fetchedLists: any[] = await sp.web.lists();

 // List of titles to exclude
 const excludedTitles = [
 'appdata', 'appfiles', 'Composed Looks', 'Converted Forms', 'Documents',
 'Form Templates', 'List Template Gallery', 'Master Page Gallery', 'Site Assets',
 'Site Pages', 'Solution Gallery', 'TaxonomyHiddenList', 'Theme Gallery',
 'User Information List', 'Web Part Gallery', 'Web Template Extensions'
 ];

 const listOptions: IDropdownOption[] = fetchedLists
 .filter(list => excludedTitles.indexOf(list.Title) === -1)
 .map(list => ({
 key: list.Id,
 text: list.Title
 }));

 setLists(listOptions);
 } catch (error) {
 console.error('Error fetching lists:', error);
 setMessage(`Error fetching lists: ${error.message}`);
 setMessageType(MessageBarType.error);
 }
 };

 fetchLists();
 }, [siteUrl, context]);

 return { lists, message, messageType };
};

export default useFetchLists;

which then reduces my ListSelector.tsx to a very minimal

import * as React from 'react';
import { Dropdown, MessageBar, IDropdownOption } from '@fluentui/react';
import styles from './SvgToJson.module.scss';
import useFetchLists from './useFetchLists';

interface ListSelectorProps {
 siteUrl: string;
 context: any;
 onListChange: (listId: string, listName: string) => void;
}

const ListSelector: React.FC<ListSelectorProps> = ({ siteUrl, context, onListChange }) => {
 const { lists, message, messageType } = useFetchLists(siteUrl, context);

 const handleListChange = (event: React.FormEvent<HTMLDivElement>, option?: IDropdownOption): void => {
 if (option) {
 onListChange(option.key as string, option.text as string);
 }
 };

 return (
 <div className={styles.dropdown}>
 {message && <MessageBar messageBarType={messageType}>{message}</MessageBar>}
 <Dropdown
 placeholder="Select a list"
 label="Lists"
 options={lists}
 onChange={handleListChange}
 className={styles.dropdown}
 aria-label="Select a list"
 />
 </div>
 );
};

export default ListSelector;

Full code here: SVG to JSON Web Part

Conclusion

Took me a while to get behind PnPjs, but once you get the hang of it, you will never want to do it differently. Splitting up my component file into an orchestrator and child components was one of the best ideas for working with the code. No more endless scrolling! What’s left? Need to polish the Web Part, work on styling it properly for Microsoft Teams and implement your suggestions as well. This Web Part still needs a lot of work/love. Logic needs to be hardened, it needs to also better be able with users who won’t choose the happy path, and there are still some more quirks to be ironed out. What do you think?

Building my first SharePoint Web Part with SPFx Toolkit

Wed, 16 Oct 2024 06:43:58 +0000

I’ll walk you through how I transformed my standalone JavaScript web tool into a SharePoint Web Part using SharePoint Framework (SPFx) Toolkit. My original web tool was pretty straightforward. It allowed users to paste in SVG code, click a Convert and copy to clipboard button, and get JSON output formatted for use in SharePoint list column formatting. But it was standalone - it wasn’t integrated into SharePoint itself, which meant users still had to copy the output manually and paste it into SharePoint.

Why not create a SharePoint Web Part that does all of this automatically and integrates with SharePoint’s own UI?

💡 This blog post is part of a series:

📌 you are here: Building my first SharePoint Web Part with SPFx Toolkit- From Web App to Web Part
Improving a Web Part with PnP.js and React Webhooks
Making a Web Part ready for the Sample Solution Gallery - to be published soon

Setting Up SharePoint Framework Toolkit

I chose the SharePoint Framework Toolkit, which is a modern approach to setting up SPFx projects. With the toolkit, everything is more streamlined - it eases a lot of tasks ands it was an easy way for me to get used to SPFx development:

No need to take care of any npm packages/dependencies (other than setting the right node version - I use nvm for that)
also no need to create all the files that are needed
samples where you can ~~steal~~ get inspired how others solved something
nifty commands available with CTRL + SHIFT + P - type in SharePoint Framework (or the first letters) and it will give you all the options

Here’s how I got started:

Install the SharePoint Framework Toolkit by hitting the Install button in the VS Code Markeplace Site
I created a new project, specifying the Web Part’s name (SvgToJson) and the framework (React) and the toolkit did the entire scaffolding for me.
I familiarized myself with the projects folders:
- src/webparts/: This is where all your Web Part code goes
- components/: Inside the Web Part folder, this is where React components live
- styles/: Where your custom styles are written (in my case, this means #ff69b4 –> that’s hot-pink all the way)

So far, so easy.

Moving the Web Tool to SPFx

My next task was to move the existing functionality from the web tool into the newly created SPFx project. This involved a couple of things:

JavaScript to TypeScript: SharePoint Framework uses TypeScript, which is JavaScript with type-checking. Lucky me writes TS for her PCF components since quite a while, that helped a lot!
React Component: The web tool was just Vanilla JavaScript 🍦 - so I needed to make some big adjustments here - but totally worth it! In React, everything is a component, meaning that each piece of UI is isolated and reusable. Instead of using DOM manipulation directly (e.g., document.getElementById), I used React’s useState hook to manage the SVG content, the JSON result, and UI feedback (messages, dropdown selections). Not gonna lie, GitHub Copilot helped me here. But after two examples, I got the hang of it and used my digital dev-friend only for debugging (still that dude wasn’t exactly totally unemployed 😇)

My very first draft looked like this (please don’t judge me!)

If you want to view your result in the browser, you will need to run gulp build - which will first build your web part (🤞🤞) - or give you errors that you first need to fix and then run gulp serve - it will display a URL for your workbench - make sure you open this in the browser profile that points to your dev tenant :-). From now on, you can see all the changes you make directly in the browser, just like having a liveserver. Trust me, the first time it actually builds is magic! ✨

Adding Interactivity and SharePoint Integration

Now, I wanted to add some features that would make it easy for users to apply the format directly to a column of their choice:

Select a SharePoint list from a dropdown
Select a specific column where the SVG formatting would be applied
Apply the SVG format to the column right from the Web Part

Here’s how I made it happen:

Fetching SharePoint Lists

To allow the user to select a SharePoint list, we need to interact with the SharePoint REST API and fetch the available lists:

const fetchLists = async (): Promise<void> => {
 const response = await fetch('/_api/web/lists?$filter=Hidden eq false');
 const data = await response.json();
 const listOptions = data.value.map((list: any) => ({
 key: list.Id,
 text: list.Title,
 }));
 setLists(listOptions);
};

This populates my Fluent UI dropdown with the lists.

Fetching the columns

Once a list is selected, the user can choose which column to apply the formatting to. Again, we use the SharePoint REST API to get the available columns for the selected list:

const fetchColumns = async (listId: string): Promise<void> => {
 const response = await fetch(`/_api/web/lists(guid'${listId}')/fields`);
 const data = await response.json();
 const columnOptions = data.value.map((field: any) => ({
 key: field.InternalName,
 text: field.Title,
 }));
 setColumns(columnOptions);
};

Applying the SVG Format to the Column

Once the user has selected both the list and column, they can apply the generated SVG format directly to the column using another API call:

const applyColumnFormatting = async (): Promise<void> => {
 const response = await fetch(`/_api/web/lists(guid'${selectedList}')/fields/getbyinternalnameortitle('${selectedColumn}')`, {
 method: 'POST',
 headers: {
 'X-HTTP-Method': 'MERGE',
 'IF-MATCH': '*',
 },
 body: JSON.stringify({
 CustomFormatter: jsonResult,
 }),
 });

 if (response.ok) {
 alert('Column formatting applied successfully!');
 }
};

Also, we open the selected list in a new tab for them. This is how it looks like:

After that, I got the very valid feedback that I should introduce the property pane so that users can decide where the SVGs come from and let them configure the Web Part with a siteURL and a libraryName.

protected getPropertyPaneConfiguration(): IPropertyPaneConfiguration {
 return {
 pages: [
 {
 header: {
 description: "Configure your web part by providing the Site URL and library name you want your SVGs to select from."
 },
 groups: [
 {
 groupName: "Settings",
 groupFields: [
 PropertyPaneTextField('siteUrl', {
 label: "Site URL"
 }),
 PropertyPaneTextField('libraryName', {
 label: "Library Name"
 })
 ]
 }
 ]
 }
 ]
 };
 }

I also added a message to the webpart before configuration has happened:


export default class SvgToJsonWebPart extends BaseClientSideWebPart<ISvgToJsonWebPartProps> {
 public render(): void {
 if (!this.properties.siteUrl || !this.properties.libraryName) {
 this.domElement.innerHTML = `
 <div>
 Please select the edit icon to configure your Web Part.
 </div>`;
 return;
 }

which will then look like this:

This makes this Web Part already so much more flexible! Quite happy with this first milestone, but will make sure to improve the Web Part, documenting becoming better at SPFx is a process.

You can find the code in here => PR tp PnP will be on the way as soon as I am ready for it (and the Web Part is good enough) ✨

Speaking of which: Here is the start of the list that I want to work on:

Using PnPjs
Splitting up my extra-long .tsx file in several smaller components
Maybe even make this a Teams app

Conclusion

It’s not much, but it’s honest work (Insert the gif that comes to mind here). Some habits, that I already quite adopted, helped me here the most:

Only make small changes at a time
Read error messages carefully

Now stay tuned for the next part :-)

AI and dinosaurs

Sun, 06 Oct 2024 06:43:58 +0000

Have you ever noticed how almost every kid goes through that intense dinosaur phase? You know the one. Suddenly, your five-year-old nephew can rattle off facts about the size, speed, and power of a Tyrannosaurus rex or Velociraptor as if he just graduated with a degree in paleontology. It’s impressive at first – until you realize he’s really just memorizing dinosaur names and random stats from a book or a TV show.

But in his mind? He’s unstoppable. Armed with this newfound knowledge, he doesn’t just know about dinosaurs; he becomes one, in a way. He projects their strength and power onto himself. It’s like he’s transformed into a mini-dinosaur expert, ready to take on the world. In reality, though, he’s still just scratching the surface – because memorizing cool dinosaur facts is a far cry from the in-depth understanding of a real paleontologist.

Funny enough, the same thing is happening right now with AI.

In recent months, it feels like we’ve been overrun by a wave of self-proclaimed AI experts. Everyone’s suddenly talking about machine learning, algorithms, and—my favorite term of all: prompt engineering. It’s almost like AI is the new T-Rex, and everyone wants to claim they’ve mastered it. People throw around buzzwords, mention how they’ve cracked the code on getting chatbots to do what they want, and present themselves as cutting-edge specialists in a field that, let’s be honest, is more complex than most of us realize.

Here’s where things get interesting: like the kid who knows all the dinosaur names but doesn’t quite understand how fossils are dated or what really makes a species go extinct, many of these so-called AI experts are only skimming the surface. They might know how to ask an AI tool a question or get it to spit out a clever response, but that doesn’t mean they understand how it all works under the hood. They’re not engineers, data scientists, or machine learning specialists who deal with the actual nuts and bolts of AI on a daily basis.

And yet, much like our dinosaur-obsessed kids, they don’t see it that way. There’s this sense of empowerment – they feel that by wielding these tools, they’ve somehow absorbed the power of the AI itself. They see themselves as being on the cutting edge, even though what they’ve really done is mastered the equivalent of a surface-level trivia game. Knowing a bunch of facts about dinosaurs doesn’t make you a paleontologist, and knowing how to get an AI tool to generate some interesting content doesn’t make you an AI expert.

But here’s where it gets tricky: in both cases, that surface-level knowledge is enough to make someone feel competent; sometimes overly competent. The term prompt engineering is a great example of this. It sounds complex and technical, but in many cases, it’s just about phrasing questions in a way that gets the response you’re hoping for. There’s no deep understanding required, but it’s packaged up in a way that makes it seem like a specialized skill. The result? A lot of people walking around feeling like they’ve tapped into the secrets of AI, when really, they’re still hanging out in the sandbox.

Meanwhile, the real experts—data engineers, machine learning specialists, and those who understand the math and algorithms that drive AI—are doing the equivalent of the hard, paleontological work. They’re the ones handling big data, running complex models, and troubleshooting problems most of us wouldn’t even know where to start with.

But just like a kid roaring around the living room pretending to be a T-Rex, the self-proclaimed AI experts are having a great time projecting all that AI power onto themselves. And honestly, can you blame them?

I don’t deny that someone needs to explain users how to use tools. But I have two issues here:

The focus on “THIS ONE TRICK”- posts shifts the responsibility for success to the user, who gets a one-size-fits-all-tool, that they are now encouraged to use for specialized jobs. To master these, they need to tweak the tool and follow lots of “tricks”, download “cheatsheets” and read “whitepapers”. That’s now how I envision a modern workplace. Yes, training and adoption are extraordinary important for software success, but what we see right now is going into the wrong direction. WE need to provide users with specialized tools (I talked about this in this post: ) and then teach them when to use what.
The way we are flooded by self-proclaimed specialists that barely scratch the surface makes it appear as if everyone is an authority in AI. Let me be very clear here: I use and build AI tools (way beyond hooking an LLM into a customer bot) and still I don’t claim to be an expert.

At this point I am bored by all the ~~dinosaur~~ AI- related LinkedIn posts that promise you that ONE trick that will make chatGPT transform your work. In the meantime, you just suffer through a tuesday full of back-to-back meetings (but luckily, the double bookings are now recorded, transcribed and tasks have been jotted down by Copilot so there is no excuse anymore to not catch up) and wait for the transformation.

What’s your take?

Introducing the SVG to JSON for SharePoint List formatter

Sun, 06 Oct 2024 06:43:58 +0000

In my latest blog posts, I played a lot of SVGs in SharePoint lists. For everyone who isn’t aware - Unlike other image formats like .png or .jpg, .svg are vectors - which can be expressed as code. If you open an SVG image in your browser, you can hit the F12 key on your Keyboard to inspect this code. You will see, that it contains lots of paths - the more complex the image is, the more paths you will find. If you only have a few paths, you can just copy them like I showed in this blog post, but at some point, this is a rather tedious task. So I asked myself, if there was a better way - and for sure, there is!

The minimal viable product

I created a super simple JavaScript file that would take an data.svg, extract each d attribute and fill and then output an array ob objects like this:

{
 "elmType": "path",
 "attributes": {
 "d": "<path goes here>"
 },
 "style": {
 "fill": "<hex value of fill color goes here>"
 }
}

Once that worked on my machine I thought about how I could make this better

The minimal lovable 💖 product

To take this from a something that is more or less viable to something that users can fall in love with, I had two main ideas:

Make it work as a public tool

To make this public as fast as possible (this was a sunday morning project), I decided to deploy with Netlify - this already works nice for this blog, so I already had an account. Netlify will use the code you have on GitHub and deploy it to a static site for you. You will need an account at Netlify, once you have that and are logged in

Select Add new site > Import an existing project
Select GitHub
You will now authorize Netlify to read your GitHub repositories
Select the repo that your code sits in
Enter a Site Name
Select Deploy

From now on, every push to main will trigger a new deployment. You can adjust this to your needs.

Provide the entire json that is needed to paste into a SharePoint List column

The core

The core functionality of the tool sits in the app.js file, which

takes as input the provided code (needs to be either pasted in or an SVG file can be dragged’n’dropped to the inputbox reading its file content)
builds the initial JSON structure for the column
extracts all the d and fill attributes from all paths
ingests these attributes into the object as shown above
initiates download of the result

document.addEventListener('DOMContentLoaded', () => {
 const svgInput = document.getElementById('svgInput');
 const convertBtn = document.getElementById('convertBtn');

 svgInput.addEventListener('dragover', (event) => {
 event.preventDefault(); // Prevent default to allow drop
 svgInput.classList.add('dragover-active'); // Add the highlight class
 });

 svgInput.addEventListener('dragleave', () => {
 svgInput.classList.remove('dragover-active'); // Remove highlight when drag leaves
 });

 svgInput.addEventListener('drop', (event) => {
 event.preventDefault(); // Prevent default to stop file from opening in a new tab
 svgInput.classList.remove('dragover-active'); // Remove the highlight class on drop

 const files = event.dataTransfer.files;
 if (files.length > 0) {
 const file = files[0];
 const reader = new FileReader();

 reader.onload = (e) => {
 svgInput.value = e.target.result; // Set the content to the textarea
 };

 reader.readAsText(file);
 }
 });

 convertBtn.addEventListener('click', () => {
 const content = svgInput.value;
 processSVGContent(content);
 });

 function processSVGContent(content) {
 const parser = new DOMParser();
 const svgDoc = parser.parseFromString(content, 'image/svg+xml');
 const paths = svgDoc.querySelectorAll('path');

 const result = {
 "$schema": "https://developer.microsoft.com/json-schemas/sp/v2/column-formatting.schema.json",
 "elmType": "div",
 "children": [
 {
 "elmType": "span",
 "txtContent": "@currentField"
 },
 {
 "elmType": "svg",
 "attributes": {
 "viewBox": svgDoc.documentElement.getAttribute("viewBox")
 },
 "children": []
 }
 ]
 };

 // Process each <path> element and add it to the JSON structure
 paths.forEach(path => {
 const pathObj = {
 "elmType": "path",
 "attributes": {
 "d": path.getAttribute('d')
 },
 "style": {
 "fill": path.getAttribute('fill') || "#000000" // Default to black if no fill is provided
 }
 };
 result.children[1].children.push(pathObj);
 });

 // Convert the result object to JSON and start the download
 const jsonString = JSON.stringify(result, null, 2);
 const blob = new Blob([jsonString], { type: 'application/json' });
 const link = document.createElement('a');
 link.href = URL.createObjectURL(blob);
 link.download = 'svg-to-sharepoint-json.json';
 link.click();

 // Clear the input field
 svgInput.value = '';
 }
});

UI

Now obviously, we would need some interface to let people drag’n’drop their SVG image or paste in their SVG code. I created a basic HTML page with an inputbox and a button and a corresponding style.css that would take care of making this a bit more 💖 pink and more visually pleasing. Additionally, I took care of giving users visual feedback when hovering with their drag-n-drop file over the dropzone.

See the tool in action

If you want to use this, you can choose between either drag’n’drop an SVG image onto the inputbox or pasting the SVG code:

For drag’n’drop

Open SVG to JSON for SharePoint List Converter
Drag’n’drop an SVG file to the input box (it will highlight)
Select the Convert and Download JSON button

For pasting the SVG code

Open an SVG in your browser
Hit F12 on your keyboard
In the first line of the code, right-click and select Edit as HTML
Select the entire code and copy it
Open SVG to JSON for SharePoint List Converter
Paste in your code
Select the Convert and Download JSON button

Format your SharePoint List’s column

After you did that, a .json file is being downloaded. Now head over to the SharePoint list that you want to prettify!

Select your field > Column settings > Format this column
Select Advanced mode
Delete the code in the box and paste the code that you just downloaded
Select Save

Conclusion

Now obviously, you will need to find the cool usecases for displaying SVG images in your List - most of them will make sense with some conditional formatting - like displaying an image only if a date column displays a certain date or month or if a choice column changes to a specific value. I hope my tool made the process of prettifying your apps a bit easier!

Display SVGs with multiple paths in a SharePoint list

Sat, 05 Oct 2024 06:36:00 +0000

I had this neat idea that depending on a value in a number column, the field would show a plant - a very small one for value 1, and then increasingly growing with more leaves up to value 4. To get you an idea on how to achieve this, here is the end result:

The SVGs 🪴

What we need for that is of course four similar SVGs. This is how I did that:

I found mine on Canva
separated them into individual SVGs,
downloaded the files
opened them in Edge
hit the F12 key on my keyborad to inspect them
extracted all the paths d and fill-color values

The List

Now let’s head over to SharePoint and

Create a number column in a list - mine is called Progress
If you want to, you can limit values to from 1 to 4
Select your field > Column settings > Format this column
Select Advanced mode
Delete the code in the box and paste the code you can find in this file (it’s nearly 800 lines, I will not make everyone scroll in here).

How the magic works

Let me explain what I did here:

I defined 4 svg elements, each of them carrying multiple paths of the SVG, being displayed under the condition of which value the field Progress shows. Each child item contains then a path with attributes: data (d) and a style with a fill property:

{
 "elmType": "path",
 "attributes": {
 "d": "M 367.652344 905.644531 C 367.652344 905.644531 403.539062 879.605469 423.945312 855.675781 C 423.945312 855.675781 426.054688 856.378906 423.945312 859.898438 C 415.5 872.566406 390.871094 907.050781 371.871094 928.164062 C 371.167969 928.164062 366.242188 913.382812 367.652344 905.644531 Z M 367.652344 905.644531"
 },
 "style": {
 "fill": "#9cc23c"
 }
}

We need such a child item for each path of the SVG that we want to display. Then it is just a question of copy-pasting the data attribute and the color into the respective fields - Boom - done!

Conclusion

Takes a bit of perseverance, but the result is rather stunning!

How to apply modern card design in a SharePoint list with listformatting

Fri, 04 Oct 2024 15:43:58 +0000

I wanted to explore if I could implement a nice overview card in a SharePoint list column, that would display at a glance for example customer feedback, whom this is assigned to and also display to buttons which would initiate calls, emails, etc.

The end result looks like this:

To achieve this we will first prep our list:

Create columns as per your liking, I chose Comment (Multiple lines of text), Assigned to (Person) and Product (Single line of text)
Fill in a few rows that you actually see a difference once we play with code ✅
Select the Title column > Column settings > Format this column
Select Advanced mode
Delete the code in the box and paste the code:

{
 "$schema": "https://developer.microsoft.com/json-schemas/sp/v2/column-formatting.schema.json",
 "elmType": "div",
 "style": {
 "box-sizing": "border-box",
 "padding": "8px 0",
 "height": "100%",
 "display": "flex",
 "align-items": "center"
 },
 "children": [
 {
 "elmType": "div",
 "style": {
 "display": "flex",
 "flex-direction": "column",
 "padding": "12px",
 "background-color": "#ffffff",
 "border": "1px solid #edebe9",
 "border-radius": "8px",
 "box-shadow": "0 2px 8px rgba(255, 105, 180, 0.3)",
 "max-width": "300px",
 "max-height": "280px",
 "overflow": "hidden"
 },
 "children": [
 {
 "elmType": "div",
 "style": {
 "font-weight": "600",
 "font-size": "14px",
 "margin-bottom": "4px",
 "color": "#ff69b4"
 },
 "txtContent": "[$Title]"
 },
 {
 "elmType": "div",
 "style": {
 "font-size": "12px",
 "margin-bottom": "8px",
 "color": "#605e5c"
 },
 "txtContent": "='Product: ' + [$Product]"
 },
 {
 "elmType": "div",
 "style": {
 "margin-bottom": "12px",
 "color": "#605e5c",
 "font-size": "12px",
 "max-height": "80px",
 "overflow": "auto"
 },
 "txtContent": "='Comment: ' + if([$Comment], [$Comment], 'No comment')"
 },
 {
 "elmType": "div",
 "style": {
 "display": "flex",
 "align-items": "center",
 "margin-bottom": "8px",
 "width": "100%"
 },
 "children": [
 {
 "elmType": "img",
 "style": {
 "width": "32px",
 "height": "32px",
 "border-radius": "50%",
 "margin-right": "8px"
 },
 "attributes": {
 "src": "=if([$Assignedto.email], '/_layouts/15/userphoto.aspx?size=S&accountname=' + [$Assignedto.email], '<URL of your fallback image>')",
 "title": "=[$Assignedto.title]"
 }
 },
 {
 "elmType": "div",
 "style": {
 "font-size": "12px",
 "color": "#605e5c"
 },
 "txtContent": "='Assigned to: ' + [$Assignedto.title]"
 }
 ]
 },
 {
 "elmType": "div",
 "style": {
 "display": "flex",
 "justify-content": "space-between",
 "margin-top": "8px"
 },
 "children": [
 {
 "elmType": "button",
 "style": {
 "padding": "4px 8px",
 "background-color": "#ff69b4",
 "color": "#ffffff",
 "border": "none",
 "border-radius": "4px",
 "cursor": "pointer",
 "margin-right": "8px",
 "font-weight": "600",
 "font-size": "11px",
 "transition": "background-color 0.2s ease",
 "white-space": "nowrap"
 },
 "attributes": {
 "class": "ms-fontWeight-semibold"
 },
 "txtContent": "Celebrate with team",
 "customRowAction": {
 "action": "executeFlow",
 "actionParams": "{\"id\": \"<flow 1 id goes in here>\"}"
 }
 },
 {
 "elmType": "button",
 "style": {
 "padding": "4px 8px",
 "background-color": "#40e0d0",
 "color": "#ffffff",
 "border": "none",
 "border-radius": "4px",
 "cursor": "pointer",
 "font-weight": "600",
 "font-size": "11px",
 "transition": "background-color 0.2s ease",
 "white-space": "nowrap"
 },
 "attributes": {
 "class": "ms-fontWeight-semibold"
 },
 "txtContent": "Set up emergency meeting",
 "customRowAction": {
 "action": "executeFlow",
 "actionParams": "{\"id\": \"<flow 2 id goes here>\"}"
 }
 }
 ]
 }
 ]
 }
 ]
}

How the magic works

This code turns a boring SharePoint list item into an elegant card with a dynamic title, product info, comments, and even the assignee’s profile picture. It’s styled to look good with borders, shadows, and action buttons that can trigger Power Automate flows, like celebrating with the team or setting up a meeting. When I showed this to someone who never did listformatting so far, they asked me to explain this very thoroughly and in detail in this blog post - so here we go:

General structure

The parent div is like a container that holds other elements (like text, images, or buttons)
The style block applies styling to the container, like padding, height, and alignment. In this case, it ensures that the container takes up 100% of the height, aligns everything neatly in the center, and gives it some padding.

Child elements (what’s inside the card)

Now let’s look at what’s inside the card (the children array):

Card Container: another div inside with a border, and rounded corners to make it look like a neat card. It also has a max size and a shadow effect.
Title is styled as a bold, hot-pink (#ff69b4) title. It displays the value from the Title column of your SharePoint list (with [$Title]).
Product is a text block that displays the product associated with the item. It uses a formula (="Product: " + [$Product]) to prepend the word “Product” before showing the value from the Product column
Comment: Here’s where the comment shows up. If there’s no comment, it will display “No comment” instead of leaving it blank. This is controlled by a simple if statement: if([$Comment], [$Comment], 'No comment').
Assigned to (Profile Picture + Name): displays a profile image and name of the person assigned to the task. It shows a small circular image (profile picture), and if no picture is available, it falls back to a generic person icon. The email is used to fetch the image (/userphoto.aspx?size=S&accountname=), and it also shows the person’s name next to it.
Action buttons: At the bottom of the card, you’ve got two buttons:
- Celebrate with team: This button when clicked, it runs a Power Automate flow with an ID specified in the actionParams. It can do something like sending an email to the team or scheduling a meeting.
- Set up emergency meeting: This button triggers a different flow, maybe to create an emergency meeting or some other urgent task. Again, the flow ID is defined in actionParams.

Let’s take action: The Power Automate flow

Obviously, if we want something to happen on the click of one of the buttons (I know, they really look great already without any functionality, but still 😇), we will need to trigger a Power Automate flow.

Create a new instant cloud flow in your default environment
Add a Create a Meeting action from the Microsoft Teams connector
Fill in the details as per your needs
Save the flow
Once the flow is saved, copy the flow id from the URL. The full URL will look like this: https://make.powerautomate.com/environments/Default-<your Azure Tenant-id>/flows/<this is your flow id>/details
Copy paste your flow ids into the json snippet - Boom - done!

A few remarks though

Mind, that my very simple flows shall just illustrate the idea to run a sequence of events on the click of a button in such an elegant card design in list. Here are a few suggestions:

if you need context of the selected list item (and for instance get the customer name, their feedback or the assigned person from it), change the trigger to the SharePoint’s For selected item trigger
if you try to schedule a meeting so that everyone is actually free, you can utilze Microsoft Graph API’s user: findMeetingTimes, it will need an array of users and of course a meeting duration. Once you got the slot, you can schedule the meeting easily. (Let me know if you want me to write a blog post on this.)

Conclusion

A list, 2 flows and a json snippet is all you need for this beautiful and functional card layout! What are your use cases?

Populate SharePoint List multiple choice column with Microsoft 365 Groups-and add some List formatting

Wed, 02 Oct 2024 06:36:00 +0000

Recently, a customer asked me if I could automagically populate Microsoft 365 Group Names to a multiple choice column in a SharePoint list. Of course I told them that one can create an ootb Person field and allow group selection, but that was not quite what they wanted. So I built a simple Power Automate flow that would populate the choice column and applied some nice list formatting to it.

Prerequisites

Have a SharePoint list
Create a Choice column (I named mine Group)
Under More options flip the switch Allow multiple selections to Yes

The Power Automate flow

We will use non-Premium connectors, first leveraging the Azure AD Group connector (time for a rename @Microsoft, huh?) to get all the groups, then use the SharePoint connector to send a request via SharePoint REST API. Let’s get started!

Get your groups

We trigger the flow as per our needs (manually, if there is not a lot of change in groups) or on a schedule (if there is a lot of changes in groups)
we then initialize a variable (I used string, but you can also do an array) for the groupNames
then we use the Azure AD Groups - List Groups action to list all groups. Filter if needed!
Then we append the Name (and a comma) in a loop to our groupNames variable

Obtain listguid and fieldguid

Now we need to obtain 2 things

the listguid of our SharePoint list: Select the Settings gear ⚙️ on your list, List Settings, you will find it in the URL. The List guid sits right in between %7B and%7D (Of course there are a gazillion of other ways to obtain this, but that is a super easy one). If you like to, write this value into a variable - it looks just more neat and tidy!
the fieldguid of the field that we are trying to populate: You can either follow this post here or stick with me and:

Use Send an HTTP request to SharePoint
- Method: Get
- URI:_api/web/Lists/GetById('@{variables('listGuid')}')/Fields

This will return a massive json object from which you can now find the id of the field you are interested in. Again, use a variable if you like to!

If you need this for several multiple choice columns, I suggest that you filter down your results array to the column that you are interested in and then select the id from that.

Patch the choice column

As a last step, we just patch our choice column with the groupNames. As we comma-separated the variable, we need to make sure that we remove that comma now:

Use Send an HTTP request to SharePoint
- Method: Patch
- URI:_api/Web/Lists(guid'listGuid')/Fields(guid'fieldguid')
- Headers:
  - Accept: application/json;odata=verbose
  - Content-type: application/json;odata=verbose
Body:

{
"__metadata": {
"type": "SP.FieldMultiChoice"
},
"FieldTypeKind":15,
"Choices": {'results':[@{substring(variables('groupNames'),0, sub(length(variables('groupNames')),1))}]}
}

If we now check in SharePoint, this already looks good, but I want to improve the experience with some colors.

Some List Formatting

What I want is a refection of which department is selected - remember that this is a multiple choice field? Let’s make that happen!

Go tou your list
Select the multiple choice field > Column settings > Format this column
Select Advanced mode
Delete the code in the box
Paste in this snippet and select Save

{
 "$schema": "https://developer.microsoft.com/json-schemas/sp/v2/column-formatting.schema.json",
 "elmType": "div",
 "children": [
 {
 "elmType": "div",
 "txtContent": "=if(indexOf(@currentField, 'Dept-Finance') >= 0, 'Dept-Finance', '')",
 "style": {
 "display": "inline-block",
 "width": "25%",
 "background-color": "=if(indexOf(@currentField, 'Dept-Finance') >= 0, '#ffcc99', 'transparent')",
 "color": "black",
 "text-align": "center",
 "padding": "5px"
 }
 },
 {
 "elmType": "div",
 "txtContent": "=if(indexOf(@currentField, 'Dept-IT') >= 0, 'Dept-IT', '')",
 "style": {
 "display": "inline-block",
 "width": "25%",
 "background-color": "=if(indexOf(@currentField, 'Dept-IT') >= 0, '#ccffff', 'transparent')",
 "color": "black",
 "text-align": "center",
 "padding": "5px"
 }
 },
 {
 "elmType": "div",
 "txtContent": "=if(indexOf(@currentField, 'Dept-HR') >= 0, 'Dept-HR', '')",
 "style": {
 "display": "inline-block",
 "width": "25%",
 "background-color": "=if(indexOf(@currentField, 'Dept-HR') >= 0, '#ff9999', 'transparent')",
 "color": "black",
 "text-align": "center",
 "padding": "5px"
 }
 },
 {
 "elmType": "div",
 "txtContent": "=if(indexOf(@currentField, 'Dept-Marketing') >= 0, 'Dept-Marketing', '')",
 "style": {
 "display": "inline-block",
 "width": "25%",
 "background-color": "=if(indexOf(@currentField, 'Dept-Marketing') >= 0, '#b3ffcc', 'transparent')",
 "color": "black",
 "text-align": "center",
 "padding": "5px"
 }
 }
 ]
}

How does this list formatting work?

We separate into the number of <div> we need (note this is just an example, there were way more groups to select from) and that set the width to the percentage the <div> may consume. The colors are applied dynamically using indexOf(@currentField, 'Dept-Name') >= 0, which checks if the department is selected in the column. Each part of the cell shows the department name if it is selected. If the department is not selected, the <div> will be empty and have no background color (transparent).

Conclusion

Good old Send and HTTP request to SharePoint saved the day again! No need for app registrations, but a super straight forward flow that populates the multiple choice colum to our needs. Of course you don’t need to do groups, but can apply any array that you fits your use case!

Resource naming reloaded: Azure Policy and Bicep for the winner!

Tue, 01 Oct 2024 06:36:00 +0000

Let’s solidify naming conventions with Azure Policy

In one of my last blog posts, How to use Azure Policy to enforce resource naming conventions in your DevOps pipelines I explained how one could leverage Azure Policy to standardize naming of your Azure resources. But it would be too easy, if it was that easy. We have a few issues with that:

some resources can’t handle the pattern that Microsoft suggests - for example Storage Accounts can only have lowercase letters and numbers in the name and only up to 24 characters
if we want people to stick to a certain pattern it’s easier if they can choose from a list of valid values

So we will parameterize the resource name with in Organization Unit, the appName that the requester provides us with, the location, the appType, the environment and the instance. This is how that looks like in Bicep:



param orgUnit string = 'Contoso' // Organization Unit
param appName string // Name provided by the requester

@allowed([
 'weu' // Short name for West Europe
 'eus' // Short name for East US
])
param shortLocation string // Selectable location for naming purposes

@allowed([
 'storageaccount'
 'webapp'
 'functionapp'
 'logicapp'
 'sqlserver'
 'cosmosdb'
])
param appType string // Selectable app type from a predefined array

@allowed([
 'Dev'
 'Demo'
 'Test'
 'Prod'
])
param environment string // Environment (e.g., 'Prod', 'Dev', etc.)

@allowed([
 '01', '02', '03', '04', '05'
])
param instanceNumber string // Instance number or other identifier

// Mapping for short location codes to full Azure region names
var locationMapping = {
 weu: 'westeurope'
 eus: 'eastus'
}

// Get the full Azure location name for deployment
var fullLocation = locationMapping[shortLocation]

// Base resource name using short location code
var baseResourceName = '${orgUnit}-${appName}-${shortLocation}-${appType}-${environment}-${instanceNumber}'

// Exception for storage account
var storageAccountName = toLower('${appName}${environment}${instanceNumber}')
var truncatedStorageAccountName = length(storageAccountName) > 24 ? substring(storageAccountName, 0, 24) : storageAccountName

// Final resource name with exception handling
var resourceName = appType == 'storageaccount' ? truncatedStorageAccountName : baseResourceName

// Resource declaration for an Azure Storage Account
resource storageAccount 'Microsoft.Storage/storageAccounts@2021-04-01' = if (appType == 'storageaccount') {
 name: resourceName
 location: fullLocation // Use full location name for deployment
 sku: {
 name: 'Standard_LRS'
 }
 kind: 'StorageV2'
}

// Resource declaration for an Azure Web App
resource webApp 'Microsoft.Web/sites@2021-02-01' = if (appType == 'webapp') {
 name: resourceName
 location: fullLocation // Use full location name for deployment
 kind: 'app'
 properties: {
 serverFarmId: 'your-app-service-plan-id'
 }
}

// Resource declaration for an Azure Function App
resource functionApp 'Microsoft.Web/sites@2021-02-01' = if (appType == 'functionapp') {
 name: resourceName
 location: fullLocation // Use full location name for deployment
 kind: 'functionapp'
 properties: {
 serverFarmId: 'your-app-service-plan-id'
 }
}

// Resource declaration for an Azure Logic App
resource logicApp 'Microsoft.Logic/workflows@2019-05-01' = if (appType == 'logicapp') {
 name: resourceName
 location: fullLocation // Use full location name for deployment
 properties: {
 definition: {
 '$schema': 'https://schema.management.azure.com/providers/Microsoft.Logic/schemas/2016-06-01/workflowdefinition.json#'
 actions: {}
 contentVersion: '1.0.0.0'
 outputs: {}
 parameters: {}
 triggers: {}
 }
 parameters: {} // Add your logic app parameters here
 }
}

// Resource declaration for an Azure SQL Server
resource sqlServer 'Microsoft.Sql/servers@2021-05-01-preview' = if (appType == 'sqlserver') {
 name: resourceName
 location: fullLocation // Use full location name for deployment
 properties: {
 administratorLogin: 'your-admin-login'
 administratorLoginPassword: 'your-admin-password'
 }
}

// Resource declaration for an Azure Cosmos DB Account
resource cosmosDb 'Microsoft.DocumentDB/databaseAccounts@2021-04-15' = if (appType == 'cosmosdb') {
 name: resourceName
 location: fullLocation // Use full location name for deployment
 kind: 'GlobalDocumentDB'
 properties: {
 databaseAccountOfferType: 'Standard'
 locations:fullLocation
 }
}

// Output the generated resource name and location for verification
output resourceName string = resourceName
output fullLocation string = fullLocation

Save this as main.bicep, We can now deploy this using Azure CLI:

$resourceGroup = "<your resourcegroup>"
az deployment group create --resource-group $resourceGroup --template-file main.bicep

If you run the CLI command, you will notice that you now get prompted for the parameters and for those that only allow a choice of values, you can choose but not use any free text. The template will now craft the resourceName out of the provided values:

As a result, we get nicely named resources:

Conclusion

Don’t get me wrong though! Having Azure Policy in place ensures, that regardless which way someone chooses to create resources, they need to stick to the naming pattern that you defined! So while this template makes it easy to deploy resources via Bicep, people could still use the Azure Portal and do what they want - if there is no policy in place! So in fact, this is yet another better together scenario! So in case you don’t have a policy so far, please go back to my previous blog post and set up a policy that fulfills your needs of consistent naming.

How to rotate secrets with Azure Logic Apps, Key Vault and Managed Identity

Mon, 30 Sep 2024 06:36:00 +0000

Do we REALLY need to rotate secrets?

Ever wonder why we’re always harping on about rotating secrets in Microsoft Entra App Registrations? Rotating secrets is kind of like changing the locks on your house. Sure, you might trust your neighbors, but what if someone made a copy of your key without you knowing? Yikes, right?

That’s pretty much what we’re dealing with when it comes to secrets in the cloud. Unfortunately, sometimes these secrets can accidentally end up in places they shouldn’t, like that one time you left your house key under the doormat (we’ve all been there, no judgment). So, rotating these secrets is our way of staying one step ahead of the bad people. But hold up - is it always necessary? In case you can use Managed Identities, it is not - as then Microsoft manages secrets for you and you don’t even have access to the secrets. But that is not always possible and lots of people asked me how one could rotate secrets. Happy to explain! So in case you ever wondered how you could rotate secret automagically 🦄, then this blog post is for you.

Create a Logic App that will rotate secrets

We will do it as simple and as secure as possible: We will use a Managed Identity in a Logic App that will create a new secret and store in a Key Vault. Why? For me everything starts with identity - so if we needed an app registration to change an app registrations secret, that would be a chicken/egg problem, as this app registration’s secret needed to be rotated as well. So a good way to prevent this secret-ception would be a Managed Identity. If we want to use a Managed Identity and still stay low-code, the easiest way to do that, is to call Power Automate’s big sister - Azure Logic Apps and leverage two HTTP actions to create and store secrets securely.

Our Logic App will look like this

You can create for now an empty placeholder Logic App in the portal, with Bicep, or right away with the definition I provided a bit further down in this post. Once you did that, let’s create our Managed Identity.

Create a Managed Identity

I chose a user-assigned Managed Identity here:

# Define our variables
$ResourceGroupName = "<your resource group>"
$Location = "<your preferred location>"
$LogicAppName = "<name of your Logic App>"
$UserAssignedIdentityName = "<Name of the managed Identity>"
$SubscriptionId = "<Id of your Azure Subscription>"
$GraphAppId = "00000003-0000-0000-c000-000000000000" # don't change! 
$KeyVaultName = "<name of the Key Vault>"

# Create the user-assigned managed identity
az identity create --resource-group $ResourceGroupName --name $UserAssignedIdentityName --location $Location

# Get the User-Assigned Managed Identity ID
$UserAssignedIdentityId = az identity show --resource-group $ResourceGroupName --name $UserAssignedIdentityName --query id --output tsv

# Assign the User-Assigned Managed Identity to the Logic App
az logic workflow identity assign --resource-group $ResourceGroupName --name $LogicAppName --user-assigned $UserAssignedIdentityId

Create an Azure Key Vault

Next up, we will create our Azure Key Vault

$KeyVault = New-AzKeyVault -ResourceGroupName $ResourceGroupName -VaultName $KeyVaultName -Location $Location

Grant access to Graph API and the Key Vault to a Managed Identity

Now let’s solve how we can access our resources! We want two things to be assigned to the Managed Identity:

Microsoft Graph permissions Application.ReadWrite.All (this will allow us to add secrets to an App registration)
Azure Role assignment (RBAC) Key Vault Administrator and Key Vault Secrets User (this will allow us to read from and push secrets to the Key Vault)

Assign Microsoft Graph permissions on a Managed Identity

This is the script that does this:


Connect-MgGraph -TenantId $DestinationTenantId -Scopes $MgRequiredScopes

$AssignPermissions = @(
 "Application.ReadWrite.All"

)

$MgRequiredScopes = @(
 "Application.Read.All"
 "AppRoleAssignment.ReadWrite.All"
 "Directory.Read.All"
)

$ManagedIdentityObjectId = Get-MgServicePrincipal -Filter "displayName eq '$UserAssignedIdentityName'"
$ServicePrincipal = Get-MgServicePrincipal -Filter "appId eq '$GraphAppId'"

$AppRole = $ServicePrincipal.AppRoles | Where-Object {($_.Value -in $AssignPermissions) -and ($_.AllowedMemberTypes -contains "Application")}

foreach($AppRole in $AppRole)
{
 $AppRoleAssignment = @{
 "PrincipalId" = $ManagedIdentityObjectId.Id
 "ResourceId" = $ServicePrincipal.Id
 "AppRoleId" = $AppRole.Id
 }

 New-MgServicePrincipalAppRoleAssignment `
 -ServicePrincipalId $AppRoleAssignment.PrincipalId `
 -BodyParameter $AppRoleAssignment `
 -Verbose
}

Assign Azure Role assignments to a Managed Identity

Now we want to assign the Key Vault Secrets User and the Key Vault Administrator role to our Managed Identity:


# Assign the managed identity the Key Vault Secrets User role
New-AzRoleAssignment -ObjectId $ManagedIdentityObjectId.Id -RoleDefinitionName "Key Vault Secrets User" -Scope $KeyVault.ResourceId

# Assign the managed identity the Key Vault Administrator role
New-AzRoleAssignment -ObjectId $ManagedIdentityObjectId.Id -RoleDefinitionName "Key Vault Administrator" -Scope $KeyVault.ResourceId

Once we have that, let’s take care of our Logic app. In case you did not already create the entire definition, you can now update it. Make sure that - if you use the Designer - you select the correct managed Identity for authentication.

💡 You can find the json definition in this gist.

Conclusion

What this does is exactly what we wanted: Every 30 days (you can change that to any other value) it will create a new secret and store it in the Azure Key Vault using a Managed Identity. If you like to, you can also delete the old secret. But as this automatically expires, there is no need for this :-) Now I’m curios: How do you rotate secrets?

How to use Azure Policy to enforce resource naming conventions in your DevOps pipelines

Wed, 25 Sep 2024 06:36:00 +0000

Lets talk about Azure naming conventions

I know, I know, you are probably thinking, “Seriously? We’re gonna talk about names?” But trust me, this stuff matters.

Why Should You Care About Names?

Think about it like this: imagine you’ve got a massive garage full of tools, but nothing’s labeled. Nightmare, right? That’s kinda what it’s like when you’ve got a ton of Azure resources with random names. It’s a mess, and nobody wants to deal with that.

Good names make life easier. You can tell at a glance what something is, where it belongs, and what it’s for. Plus, when it comes to tracking costs or making sure you’re following the rules, good names are a lifesaver.

What Microsoft Says About It

Microsoft’s got some ideas about how to name stuff in Azure. They suggest something like this:

<org>-<proj>-<env>-<region>-<resource-type>-<instance>

So, if you’re working on a web app for Contoso, it might look like:

contoso-webapp-prod-eastus-app-01

Not too shabby, right? You can tell it’s for Contoso, it’s a web app, it’s in production, sitting in East US, and it’s an app service. The ‘01’ at the end is just in case you need more than one.

The problem with doing this manually

Trying to make sure everyone follows these rules manually is a pain in the butt. People forget, they get lazy, or they just don’t care. And then you’ve got a mess on your hands.

Plus, going through and checking all the names by hand? Boring. And fixing mistakes after the fact? Even worse.

How to make it suck less

This is where the cool part comes in. We can use Azure CLI and Azure Policy to do the heavy lifting for us. Basically, we set up a system that checks the names before anything gets created. If the name’s wrong, it doesn’t let it through.

Here’s the general idea:

Figure out what pattern you want your names to follow - welcome to Regex hell!
Write a little script that checks if a name matches that pattern
Hook that script in your Azure DevOps pipeline

Now, every time someone tries to create something, it has to pass the name check first. Pretty slick, huh? But if we just wrote the script in DevOps, then it would only apply if someone tries to deploy resources via DevOps. It wouldn’t catch non compliant resources that are created for example in the Azure Portal. Our hero? It’s once again Azure Policy! Azure Policy makes sure that regardless how a resource is being created, it needs to comply to the policy that you set.

Use Azure Policy

We have several options now… either create the policy with Azure CLI or deploy the policy definition and policy assignment with Bicep.

I’ll cover how to use Bicep for this:

targetScope = 'subscription'

resource policyDefinition 'Microsoft.Authorization/policyDefinitions@2021-06-01' = {
 name: 'enforce-resource-naming'
 properties: {
 displayName: 'Enforce resource naming pattern'
 mode: 'All'
 policyRule: {
 if: {
 field: 'name'
 notMatch: '^[a-zA-Z0-9]{1,}-[a-zA-Z0-9]{1,}-[a-zA-Z0-9]{1,}-[a-zA-Z0-9]{1,}-[a-zA-Z0-9]{1,}-[a-zA-Z0-9]{1,}$'
 }
 then: {
 effect: 'deny'
 }
 }
 parameters: {}
 metadata: {
 category: 'Naming'
 }
 }
}

resource policyAssignment 'Microsoft.Authorization/policyAssignments@2021-06-01' = {
 name: 'enforce-resource-naming-assignment'
 properties: {
 displayName: 'Enforce resource naming pattern assignment'
 policyDefinitionId: policyDefinition.id
 scope: subscription().id
 }
}

If we now deploy a resource:

resource storageAccount 'Microsoft.Storage/storageAccounts@2021-02-01' = {
 name: 'contoso-webapp-prod-weu-stg-01' // This name must comply with the policy
 location: 'westeurope'
 sku: {
 name: 'Standard_LRS'
 }
 kind: 'StorageV2'
 properties: {
 accessTier: 'Hot'
 }
}

Azure policy will check if the name complies. If not, it will block the deployment due to the deny in the policy.

You can also check your previously created resources with

az policy state list --query "[?complianceState=='NonCompliant']"

Make it work in your DevOps pipeline

And the best part? You can hook it right into your DevOps pipeline. So before you deploy anything, you can double-check that it’s all the way you wanted it in the first place. It runs the az policy state list command to check whether any resources are non-compliant. If violations are detected, the pipeline exits with a non zero status which causes the pipeline to fail.

trigger:
- main

pool:
 vmImage: 'ubuntu-latest'

variables:
 azureSubscription: '<Your-Service-Connection>'
 resourceGroupName: '<Your resource group name>'
 location: 'westeurope'

steps:
# Install Azure CLI and Bicep
- task: AzureCLI@2
 inputs:
 azureSubscription: $(azureSubscription)
 scriptType: 'bash'
 scriptLocation: 'inlineScript'
 inlineScript: |
 # Install Azure CLI Bicep extension
 az bicep install
 displayName: 'Install Bicep CLI'

# Deploy Bicep File to Azure
- task: AzureCLI@2
 inputs:
 azureSubscription: $(azureSubscription)
 scriptType: 'bash'
 scriptLocation: 'inlineScript'
 inlineScript: |
 echo "Deploying Bicep template..."
 az group create --name $(resourceGroupName) --location $(location)

 # Deploy Bicep file
 az deployment group create \
 --resource-group $(resourceGroupName) \
 --template-file main.bicep
 displayName: 'Deploy Bicep Template'

# Check Azure Policy Compliance
- task: AzureCLI@2
 inputs:
 azureSubscription: $(azureSubscription)
 scriptType: 'bash'
 scriptLocation: 'inlineScript'
 inlineScript: |
 echo "Checking Azure Policy compliance..."

 # Check for any non-compliant resources in the resource group
 compliance_results=$(az policy state list --resource-group $(resourceGroupName) --query "[?complianceState=='NonCompliant'].{resourceId:resourceId, policyAssignmentName:policyAssignment}" --output table)

 if [ -n "$compliance_results" ]; then
 echo "Non-compliant resources detected:"
 echo "$compliance_results"
 exit 1 # Fail the pipeline if there are non-compliant resources
 else
 echo "All resources are compliant with Azure Policy."
 fi
 displayName: 'Check Policy Compliance'

Conclusion

Naming conventions aren’t exactly the most thrilling topic. But trust me, getting this stuff right can save you a ton of headaches down the road. It’s like organizing your garage – it’s a pain to do, but once it’s done, life gets so much easier. Azure Policy does the heavy lifting here for us and hooking that approach into your Azure DevOps pipeline will just make sure that you’ll never ever have to think about naming again. You are welcome!

How to automate vulnerability scans in Azure DevOps with Microsoft Defender for Cloud

Tue, 24 Sep 2024 08:25:03 +0000

You know how it goes. You are working on a project, pushing code left and right, and then someone asks, “But is it secure?” Cue the collective groan. Well, what if I told you there’s a way to bake security right into your development process without slowing everything down to a crawl?

Enter Microsoft Defender for Cloud and Azure DevOps. Together, they’re like the dream team of cloud security. We can integrate Microsoft Defender for Cloud into our Azure DevOps pipeline, which means that we can perform vulnerability scans as part of our CI/CD process so that every deployment is scanned for security issues before it goes live.

That means:

no more “oops” moments (remember my blog about how to get from Dev?! Oops! to DevOps?)
consistency as every build gets the same treatment and it doesn’t depend on the someone’s mood, how close lunch break is or other very human factors what gets scanned
speeding things up as automated scans are way faster than Bob from IT manually checking everything (Sorry Bob!)

I see too often that security scans are an afterthought or that scans are performed after a deployment hits production. So they just hope for the best.

What is Defender for Cloud

(and why would I care?)

Microsoft Defender for Cloud is a robust security solution that’s becoming increasingly important in the Azure ecosystem. It acts as a comprehensive monitoring system for your cloud resources, continuously scanning for potential vulnerabilities and threats. It doesn’t just alert you to issues, but provides actionable recommendations to improve your security.

A bit of prep work

Before we can leverage this approach, we need to check some prerequisites

Azure subscription with Microsoft Defender for Cloud turned on
A Azure DevOps account and project with some code in a repo
The right permissions (you’ll need to be a Contributor or Owner)
Microsoft Defender for Cloud plan that covers your resources (there is a free trial)
A Log Analytics Workspace (If you don’t know how to do this, here is a tutorial by Microsoft Learn)
A way for Azure DevOps to talk to Azure (like a Service Principal or Managed Identity)

Defender for Cloud Setup

First things first, let’s turn on Microsoft Defender for Cloud:

Open portal.azure.com and find Microsoft Defender for Cloud
Switch on the Defender plans for the services you care about (e.g., VMs, App Services, Key Vaults, SQL database)

Now, let’s set up Continuous Export:

Find Environment Settings and then Continuous export
Enable the export of security recommendations and alerts to a Log Analytics workspace.

DevOps Pipeline Magic

Now for the fun part – setting up the pipeline that’ll do our security scans:

We need to give our pipeline a way to talk to Azure:

Use either a Service Principal or a Managed Identity to create a Service Connection
Create a new pipeline (or edit an existing one) with this yaml snippet:

trigger:
- main

pool:
 vmImage: 'ubuntu-latest'

variables:
- group: AzureSecurityVariables

steps:
- task: AzureCLI@2
 inputs:
 azureSubscription: 'AzureSecurityConnection'
 scriptType: 'bash'
 scriptLocation: 'inlineScript'
 inlineScript: |
 echo "Starting vulnerability scan with Microsoft Defender for Cloud"

 # Query the Log Analytics workspace for any critical security recommendations
 result=$(az monitor log-analytics query \
 --workspace $(logAnalyticsWorkspaceId) \
 --analytics-query "SecurityRecommendation | where Severity == 'High'" \
 --timespan P1D \
 --output tsv)

 if [[ -n "$result" ]]; then
 echo "High-severity security vulnerabilities found:"
 echo "$result"
 echo "##vso[task.complete result=Failed;]Security vulnerabilities detected."
 else
 echo "No critical vulnerabilities found!"
 fi

💡 Make sure that you create a variable for your logAnalyticsWorkspaceId - you can obtain it from the Azure Portal

Our pipeline does a few cool things:

It logs into Azure using your Service Principal (you know I love managed Identities for a variety of good reasons, but I wanted to keep this blog post focused on DevOps and Defender for Cloud so let’s cover DevOps and Managed Identity in a future post)
It checks your Log Analytics workspace for any high-severity security recommendations from the last day
If it finds anything scary (Severity High), it’ll fail the pipeline and show you what it found

Run your pipeline, if it tells that “No critical vulnerabilities found” you are good to go, otherwise, it will stop the pipeline and exactly tell you what it found.

Conclusion

Scans do not need to be performed after deployment, with everyone getting hectic or rolling back to previous versions. Microsoft Defender for Cloud got your back and you can integrate it into your DevOps scenario.

Go Go governance! Enforcing Azure Policies with Azure CLI

Sun, 22 Sep 2024 08:25:03 +0000

This post is part of a series about Deployments, Role Assignments and more!

How to deploy Azure LogAnalytics Workspace and link Application Insights to it
How to use Azure Container Registry to standardize deployments using Bicep across your organization
How to secure access to an Azure Container Registry with RBAC
How to secure access to an Azure Container Registry with a Managed Identity
Azure RBAC is so 2023! Let’s get ABAC to the rescue!
📍 you are here - Go Go governance! Enforcing Azure Policies with Azure CLI
How to utilize the Azure Container Registry in your Azure DevOps pipeline - to be published soon

In my last post about ABAC I showed that we can assign a role to resources that are tagged with for example with Department == Finance or Project == DeathStar? Well that only makes sense if noone forgets to tag resources correctly, right?

If you’ve worked with Azure for any amount of time, you know how easy it is for things to get out of control. Different teams deploying resources, some in the wrong regions, others without proper tags—before you know it, your cloud setup looks like a mess. That’s where Azure Policies come in to save the day.

Think of Azure Policies as guardrails that help you keep everything in line. They make sure that everyone follows the rules you set. No more resources popping up in unapproved regions or missing critical information like cost tags.

The Workaround (and Why It Doesn’t Work)

Manually enforcing these rules by trusting teams to follow best practices or having endless spreadsheets and documents for tracking resource usage, doesn’t work (Ask me how I know 😇). Without policies, you’d rely on documentation, hope (🤞🤞), and good intentions. Maybe you’d have a workaround where people manually check if resources are in the right region or tag everything properly. Sorry to break it to you, but that ain’t a proper process. Azure Policies automate all of that, so you don’t have to chase people down. Once you set a policy, it just works. If someone tries to break the rules, the policy will stop them. No manual enforcement needed. The policy stops non-compliant resources from being created in the first place.

It’s not a trick, it’s an Azure policy

What We’ll Do Here

Today, we’re going to enforce two simple, but super effective policies:

Let’s Enforce a Location Policy for the Entire Subscription

First up, we’ll make sure everything in your Azure subscription is deployed in westeurope.

Create the Location Policy

The Azure CLI makes this process easy. First, we’ll create a policy that only allows resources to be deployed in westeurope.

# Create the policy definition in Azure
az policy definition create `
 --name "AllowedLocations" `
 --display-name "Enforce West Europe Location" `
 --description "Ensures that resources are only deployed in West Europe." `
 --rules '{
 "if": {
 "field": "location",
 "notEquals": "westeurope"
 },
 "then": {
 "effect": "Deny"
 }
}' `
 --mode All

This policy checks the location of any new resource, and if it’s not set to westeurope, the creation gets blocked.

Assign the Policy to Your Subscription

Now that we’ve created the policy, we need to assign it to the whole subscription to make sure it applies everywhere.

# Get your subscription ID
$SUBSCRIPTION_ID=$(az account show --query "id" -o tsv)

# Assign the policy to the subscription
az policy assignment create `
 --name "RequireWestEurope" `
 --policy "AllowedLocations" `
 --scope "/subscriptions/$SUBSCRIPTION_ID" `
 --display-name "Enforce West Europe Location"

With this in place, no matter how someone tries to create a resource (CLI, portal, etc.), if it’s not in West Europe, it won’t happen. 🎤💧⬇️

Enforcing a Tagging Policy for a Specific Resource Group

Now let’s focus on enforcing tags for a particular resource group. Let’s say you have a resource group where every resource needs a CostCenter tag, so you can track cloud spending effectively.

Create the Tagging Policy

Here’s the policy that checks if the CostCenter tag is present. If it’s not, the policy blocks the creation of that resource.


# Create the policy definition in Azure
az policy definition create --name "EnforceCostcenterTag" `
--rules '{
 "if":{
 "field":"tags.Costcenter",
 "exists":"false"
 },
 "then": {
 "effect":"Deny"
 }
 }' `
--mode All `
--display-name "Enforce Costcenter Tag on All Resources"

This policy checks each resource, and if it’s missing the CostCenter tag, the policy kicks in and denies its creation.

Assign the Tagging Policy to a Resource Group

Now, assign this policy to a specific resource group where you need to enforce tagging.

# Define the resource group name
RESOURCE_GROUP_NAME="YourResourceGroup"
SUBSCRIPTION_ID=$(az account show --query "id" -o tsv)
SCOPE="/subscriptions/$SUBSCRIPTION_ID/resourceGroups/$RESOURCE_GROUP_NAME"

# Assign the policy to the resource group
az policy assignment create `
 --name "RequireCostCenterTag" `
 --policy "EnforceCostCenterTag" `
 --scope "$SCOPE" `
 --display-name "Require CostCenter Tag on Resources"

From now on, if someone tries to create a resource in this group without a CostCenter tag, they’ll get stopped right away.

Why This Works for Every Deployment Method

What makes Azure Policies powerful is that they work no matter how you deploy resources

If someone uses the Azure Portal, they’ll be blocked if they try to create a non-compliant resource
Using Azure CLI? The policy still applies!
Even if you’re using Infrastructure as Code (like Bicep or Terraform), the policies will ensure that every resource meets your standards.

Sneak Peek into Azure DevOps pipelines

In a future post, I’ll explain how these policies play an important role when integrating Azure DevOps pipelines into your deployment workflows. Imagine automating your entire deployment process, and still having these policies enforce compliance on every resource that gets created. No more manual checks, just smooth, policy-driven deployments.

Stay tuned 🤖

Azure RBAC is so 2023! Let’s get ABAC to the rescue!

Sat, 21 Sep 2024 08:25:03 +0000

This post is part of a series about Deployments, Role Assignments and more!

How to deploy Azure LogAnalytics Workspace and link Application Insights to it
How to use Azure Container Registry to standardize deployments using Bicep across your organization
How to secure access to an Azure Container Registry with RBAC
How to secure access to an Azure Container Registry with a Managed Identity
📍 you are here - Azure RBAC is so 2023! Let’s get ABAC to the rescue!
How to utilize the Azure Container Registry in your Azure DevOps pipeline - to be published soon

In the last post, I showed you how assigning an RBAC role to a Managed Identity saves you some password rotation related tasks, and I promised to write the next post about ABAC. So here we go:

Quick recap: RBAC

Azure Role-Based Access Control (RBAC) lets admins assign roles to users, groups, and services to control access to Azure resources. With roles like Owner, Contributor and Reader, RBAC makes sure everyone has just the right permissions to get their jobs done, which cuts down on admin headaches.

But as businesses (and their cloud maturity) grow, so do their access control needs. If you’ve been managing permissions with RBAC you know it’s fabulous for broad, static access. But what happens when your access requirements start getting more complex? Enter ABAC (Attribute-Based Access Control): It’s the next level of fine-grained, dynamic access control.

ABAC adds context.

Instead of just assigning permissions based on a user’s role, you can now use attributes like department, project, or even location to grant access to specific resources. Think of it as RBAC with superpowers.

A Real-World Scenario: Using RBAC and ABAC Together

Let’s say you’re running a multi-tenant SaaS app for different departments like Finance, Sales, and HR, and you need to limit access within each department. RBAC helps you set up basic roles (like Storage Contributor or Reader), but it doesn’t go far enough when users or apps only need access to specific resources, like data tagged with Finance or Project Deathstar.

That’s where ABAC comes in. You can assign broad roles with RBAC, and then fine-tune access with ABAC policies. Here’s how that works:

RBAC Role Assignment: John from Finance gets the Storage Contributor role, allowing him to manage all storage accounts in the Finance resource group
ABAC Policy: We add a rule that says John can only access resources with project=Deathstar tags. So even though his role allows him broader access, ABAC restricts him to only what’s relevant to his project.

That is exactly what principle of least privilege means!

Often times, security ad convenience are perceived as a sea-saw. The more secure convenient something is for a user (or an admin, or a developer), the less convenient it is. The more convenient something feels, the more e can expect it to be insecure. With ABAC we balance the two approaches - making access secure AND convenient at the very same time.

ABAC allows you to adapt permissions on the fly based on user and resource attributes, making it perfect for dynamic environments where things change frequently – like employees working across regions or switching between projects.

Assigning ABAC Roles with Azure CLI

# Variables
$subscriptionId = "<your subscription id>"
$resourceGroupName = "rg-building-blocks"
$userEmail = "<email of the user>"
$roleName = "Storage Blob Data Contributor"
$storageAccountName = "<name of the storage account>"
# Get the user object ID using the user email
$userObjectId = $(az ad user show --id $userEmail --query "id" --output tsv)
# Define the scope
$scope = "/subscriptions/$subscriptionId/resourceGroups/$resourceGroupName/providers/Microsoft.Storage/storageAccounts/$storageAccountName"
# Define the condition
$condition = "@Resource[Microsoft.Storage/storageAccounts/blobServices/containers/blobs/tags:Project<`$key_case_sensitive`$>] StringEquals 'Deathstar'"
$conditionVersion = "2.0"
# Assign the role with the condition
az role assignment create --assignee $userObjectId --role $roleName --scope $scope --condition $condition --condition-version "2.0"

We can check in the Azure Portal that this worked:

This ABAC policy ensures that our user only gets access if the tag is Project == Deathstar.

💡 If you want t try this out, make sure you do in fact have such a tag! (Ask me how I know 😇)

Conclusion: Better Together

Instead of asking yourself now if RBAC or ABAC is better: RBAC and ABAC aren’t competitors – they’re complementary. RBAC handles the heavy lifting of defining broad access, while ABAC gives you the flexibility to refine access based on real-world conditions. Think of ABAC as a precision tool you can use alongside RBAC when things get a little more complex.

Why you shouldn’t say 'please' or 'thank you' to AI (and why it matters)

Fri, 20 Sep 2024 08:25:03 +0000

We’ve all been there: asking ChatGPT, Copilot or whatever AI, for something and instinctively saying “please” or “thank you.” It feels polite, right? But AI doesn’t care. Talking to it like it’s a person isn’t helping anyone, and it might actually harm how we think about these systems.

We humans love to project human traits onto things that aren’t human - a concept called “anthropomorphism”. We name our cars, swear at our laptops when they freeze, and now, we talk to AI as if it has thoughts and feelings. AI, however, doesn’t think, feel, or care about your mood. When we say “please” or “thank you” to it, we’re blending the lines between what’s human and what’s not.

This tendency to anthropomorphize AI is everywhere. We refer to AI as “learning”, “reasoning” or even “understanding”, but in reality, these systems aren’t experiencing anything like a human would. We talk about AI this way because it helps us make sense of the complex tech behind it. But in doing so, we risk overestimating its capabilities and assuming it has qualities - like empathy or understanding - that it simply doesn’t. This leads to problems:

it creates false expectations: We’re subtly reinforcing the idea that it understands us in the same way a human would. It doesn’t. AI processes data and performs tasks. It’s not reading between the lines, and it doesn’t “feel” appreciated when you’re polite.
it distorts what AI can really do; anthropomorphizing AI can make us think it’s more capable than it is. We might assume AI can “learn” like a human or make decisions with some form of understanding. But that’s not the case.
it shifts responsibility away from us. The more we treat AI like it’s human, the more we might let go of our own responsibility. AI can’t be held accountable for its actions or biases - we can.

Oh yeah, how could I forget “Being Nice to the Future Overlords”? Some of us joke about being polite to AI “just in case they become our future robot overlords.” The idea is that if AI takes over, those of us who were nice to them will get a better deal. It’s a funny thought, but it also fuels this whole Terminator-style narrative where AI is this malevolent force waiting to exploit us. That’s not what AI is about - treating it like a potential overlord makes it harder to understand what AI really is: a tool designed by humans, for humans. When we treat AI like it’s something with power or agency, we buy into this dystopian idea of AI taking control, which really just distracts us from thinking about AI responsibly. The killer robot storyline harms our ability to grasp the real issues around AI, like biases, privacy, and ethical usage.

If we want to use AI responsibly, we need to understand it better. It’s not enough to not anthropomorphize it - We need to know how to interact with it to advance society.

How to secure access to an Azure Container registry with a Managed Identity and RBAC

Tue, 17 Sep 2024 08:25:03 +0000

This post is part of a series

How to deploy Azure LogAnalytics Workspace and link Application Insights to it
How to use Azure Container Registry to standardize deployments using Bicep across your organization
How to secure access to an Azure Container Registry with RBAC
📍 you are here - How to secure access to an Azure Container Registry with a Managed Identity
How to utilize the Azure Container Registry in your Azure DevOps pipeline - to be published soon

I like to deploy my Azure resources using Bicep - If you never heard about it, I blogged a while ago on how to get started with Bicep - please catch up first!

In the last post, I showed you how assigning an RBAC role to a service principle can be used to make sure that someone can only pull images from an Azure Container Registry. This post will cover how to secure your Azure Container Registry with a Managed Identity.

What is a Managed Identity?

If you don’t know about Managed Identities yet: a Managed Identity gives your app an identity in the cloud without the need to register an app in Microsoft Entra (the artist formerly known as Azure Active Directory). This means, that you don’t need to create secrets or certificates and you also don’t need to store secrets or rotate them - Microsoft manages that for you. Because if we are all being honest: Yes, we know that we should rotate secrets. But not enough organizations do this. Managed Identities come in 2 flavors: system assigned and user assigned.

System assigned means that they belong to a certain Azure resource and share its lifecycle
User-assigned means, that they are resource on their own and can be assigned to one or more other resources.

I covered more about this in this blog post

Now let’s get started:

A little bit of prep work

To assign a Managed Identity to an Azure Container Registry we need have an Azure Container Registry in the first place. If you followed the blog post series - this should already be done. If not - please catch up now.

After that, we create the user-assigned Managed Identity itself:

$Managed_Identity = "<name of your managed identity>"
az identity create --resource-group $RESOURCE_GROUP --name $Managed_Identity

You can check in the Azure portal that it does in fact exist:

Assign Managed Identity to ACR

Now let’s assign our Managed Identity to the Azure Container Registry


az acr identity assign --name $ACR_NAME --identities $Managed_Identity --resource-group $RESOURCE_GROUP

Create the role assignment

As a last step, we need to create the RBAC in our identity. To do this, we need the principalId property (aka the Object ID of our Managed Identity)

$PRINCIPAL_ID=$(az identity show --resource-group $RESOURCE_GROUP --name $Managed_Identity --query "principalId" --output tsv)

Now we will use this to create the role assignment:

az role assignment create --assignee $PRINCIPAL_ID --role "AcrPull" --scope "/subscriptions/$subscriptionId/resourceGroups/$RESOURCE_GROUP"

That’s it! Let’s quickly check in the Azure portal that it worked and we are done:

The elephant in the room

You might now ask - if I am such a fan of IaC, why wouldn’t we then deploy the Managed Identity with a bicep file (preferably published to an Azure Container Registry for easy use by all developers in the organization)? I’m so glad you asked! 😇

I love to have more than just one tool under my belt. For quick demos or to try out things during first phase of development, I usually use Azure CLI to get started. It’s the easiest way to create and modify the resources I need.

If my solution then scales, I like to have proper Bicep files in place, so that deployments are so repeat and we can easily track what exactly we deployed via source control. So if you want to create a Bicep file for a Managed Identity, here is the module that I would use:

Let’s first get the role id for AcrPull


$ACRPULL_ROLE_ID=$(az role definition list --name acrpull --query "[0].id" --output tsv)
$roleId = (az role definition list --name "AcrPull" --query "[0].id" --output tsv)
$ACRPULL_ROLE_ID = $roleId.Split('/')[-1]

Main Bicep file (main.bicep)

param resourceGroupName string
param subscriptionId string
param managedIdentityName string
param acrName string
param location string = resourceGroup().location
param acrpullRoleId string

module managedIdentityModule 'managedIdentity.bicep' = {
 name: 'managedIdentityDeployment'
 params: {
 name: managedIdentityName
 location: location
 }
}

module roleAssignmentModule 'roleAssignment.bicep' = {
 name: 'roleAssignmentDeployment'
 params: {
 managedIdentityPrincipalId: managedIdentityModule.outputs.principalId
 acrName: acrName
 subscriptionId: subscriptionId
 acrpullRoleId: acrpullRoleId
 }
}

Managed Identity Module (managedIdentity.bicep)

param name string
param location string = resourceGroup().location

resource managedIdentity 'Microsoft.ManagedIdentity/userAssignedIdentities@2018-11-30' = {
 name: name
 location: location
}

Role Assignment module


param managedIdentityPrincipalId string
param acrName string
param subscriptionId string
param acrpullRoleId string

var acrId = resourceId(subscriptionId, 'Microsoft.ContainerRegistry/registries', acrName)

resource roleAssignment 'Microsoft.Authorization/roleAssignments@2020-04-01-preview' = {
 name: guid(acrId, managedIdentityPrincipalId, 'AcrPull')
 properties: {
 roleDefinitionId: '/subscriptions/${subscriptionId}/providers/Microsoft.Authorization/roleDefinitions/${acrpullRoleId}'
 principalId: managedIdentityPrincipalId
 scope: acrId
 }
}

You can now either deploy this from here (locally) with Azure CLI or you publish these modules to an Azure Container Registry so that others can consume them from there easily. I described earlier in this series how the latter works; here is the Azure CLI command:

$ACRPULL_ROLE_ID = (az role definition list --name "AcrPull" --query "[0].id" --output tsv).Split('/')[-1]
az deployment group create --resource-group $RESOURCE_GROUP --template-file main.bicep --parameters resourceGroupName=$RESOURCE_GROUP subscriptionId=$subscriptionId managedIdentityName=$Managed_Identity acrName=$ACR location=$location acrpullRoleId=$ACRPULL_ROLE_ID

Boom - done ✅

You now have two ways to automatically create a Managed Identity, and assign the RBAC to it.

Conclusion

We can now use the Managed identity instead of our service principal and don’t need to worry anymore that we really don’t care about secret rotation. Azure Key Vault is already good to store credentials, but following best practices we would want to regularly rotate them. This is now automagically being take care of by Microsoft :-)

PS

When I mentioned “Writing ablog post about Bicep and RBAC”, Janek Fellien very casually told me that RBAC is so 2023 and that ABAC is the hottest shit. Let me know if I should find a good scenario for that and write about it!

Hasta la vista?! About how we picture AI

Sun, 15 Sep 2024 08:25:03 +0000

Ever searched for “AI” on a stock image site or even used an AI tool to generate an image of “AI”? I can’t help but noticing three recurring themes:

robots that look like the Terminator
hypersexualized “sexy” robots
cute, cartoonish androids

It’s like we’re stuck in a loop, constantly cycling through the same old clichés. And it’s not just stock images; even AI-generated visuals tend to follow these patterns.

There are some deeper socio-cultural reasons behind the depiction of AI - capitalism’s love for familiar ideas, the way tech infantilizes users, and even outdated sexism. All of this is rooted in people’s fear of AI taking over, a fear that The Terminator helped cement. But now, with AI tools becoming accessible to nearly everyone, there’s an even bigger conversation around the kind of AI we’re building - models that threaten to change the workforce as we know it.

Visuals of the Terminator-style robot are instantly recognizable and pack a punch. The red-eyed robot is a symbol of the danger of AI and has become a kind of visual shorthand for artificial intelligence. This touches on a real fear: the idea that AI could surpass human control and, like in The Terminator, threaten humanity. While we’re not necessarily expecting killer robots to come for us (🫰🫰🫰), that image sticks with us, and it sells.

Even AI image generators, which should theoretically offer something new, fall back on these familiar tropes because they’re learning from the data we’ve already created. They scrape through millions of images online, and since our media and advertising spaces are already full of these familiar robots, they just reinforce them. AI reflects our existing biases and sells us back the same stories we’ve been telling for decades.

On the other side of the spectrum, we see another type of AI imagery - robots that are almost too cute. Big eyes, soft colors, and friendly, toy-like appearances. These images are designed to make AI seem approachable and harmless, a far cry from the intimidating robots of dystopian movies.

This is part of a bigger trend where tech companies work hard to present AI as a friendly, easy-to-use tool. By making AI look cute and non-threatening, they make the tech feel accessible, something anyone can use without needing to worry about the complexities behind it. This approach infantilizes users, making it seem like we don’t need to think too hard about what’s going on under the hood.

But AI isn’t a toy. It’s a powerful technology that’s already affecting jobs, privacy, and decision-making in ways that matter. When we constantly see AI depicted as a cute, harmless assistant, we stop asking the important questions about ethics, control, and long-term impacts. And AI-generated images, learning from these same visual cues, end up reinforcing this “friendly robot” narrative, even when the reality is far more complicated.

One of the most frustrating trends in AI visuals is the hypersexualized “sexy” robot. These robots are usually female-presenting, sleek, and designed with exaggerated features. You see this type of imagery not only in stock image libraries but also in AI-generated visuals, regardless which tools you use.

This societal issue persists in and reflects on tech. When AI is depicted as a hypersexualized female robot, it reinforces harmful ideas that women (or, in this case, feminized robots) exist to serve or entertain.

Even in our most futuristic visions, the “sexy robot” trope reflects a culture that still struggles to see women as equals in tech and innovation. Instead, they’re often depicted as objects of desire or subservience, reinforcing sexist stereotypes even in a space that should be about pushing boundaries and imagining new possibilities.

While most of us don’t actually expect robot overlords anytime soon, there’s a real fear behind this: that AI could grow beyond our control.

And now, we’re living in a time when that fear is starting to feel a little too close for comfort. AI isn’t just a cool futuristic idea anymore; it’s here, and it’s becoming more powerful every day. We now have large language models (LLMs), large action models (LAMs), and supposedly “reasoning” models that can automate processes we thought only humans could handle. These tools can write, code, create, analyze, and even make decisions - essentially doing more and more of what we thought only people could do.

This is where things get tricky. As AI becomes more accessible, available for nearly everyone to use and experiment with, we start to feel the pressure. Companies are adopting these tools at breakneck speed, and some of these models are already threatening to replace human jobs. AI is no longer just the future; it’s the present, and it’s here to stay.

The original fear—that AI could take over—might not look exactly like The Terminator, but it’s real. AI tools are already reshaping industries, changing the workforce, and shifting how we think about the future of work. And when you have AI creating images of AI, it’s no wonder we keep seeing these fear-based visuals pop up—they’re reflecting our very real concerns about AI’s role in society.

So, what’s the solution? It starts with how we think about and visualize AI. We need to break out of this loop and start demanding images that reflect the full complexity of AI - not just the dystopian, overly simplified, or hypersexualized versions we’ve been fed for decades. At least: stop using these images to to perpetuate the false narrative even further.

AI can now REASON?! tl;dr: no, it cant!

Thu, 12 Sep 2024 06:36:00 +0000

Another day, another AI model drop! This time, it’s the OpenAI o1 series, and wow, the hype is all over my feed 🙄 Is this the breakthrough in reasoning we’ve all been waiting for? 🤔

OpenAI claims these models are designed for coding, math, and science. Supposedly, they’re better at reasoning through tough problems. But wait, what?! They aren’t actually reasoning. What they are doing is mimicking reasoning using a technique called “chain-of-thought” processing. How this works? Instead of jumping straight to an answer, these models break down a problem step-by-step, processing more data (tokens) and taking longer to respond. This mimics how humans reason through problems, but at the end of the day, it’s still advanced pattern recognition – the model is just generating text based on its training, not “thinking” like we are 💡

In theory, this should lead to more accurate outputs in areas like coding and math, where getting things wrong is a big issue. But there are trade-offs:

Reduced context windows due to the model using tokens for “reasoning steps”
Longer wait times for responses (something between few seconds to few minutes)
And yes, more money – these models are far more expensive to run

For now, they’re only in preview (with very strict usage limits) and limited to text-based tasks.

To me, the bigger takeaway is the shift toward specialized models. Instead of trying to make one model do everything, OpenAI is focusing on building models for specific, high-demand tasks like coding, math, and science. Maybe this specialization is the real innovation here.

What do you think?

How to secure access to an Azure Container registry with RBAC

Mon, 02 Sep 2024 07:13:02 +0000

This post is part of a series

How to deploy Azure LogAnalytics Workspace and link Application Insights to it
How to use Azure Container Registry to standardize deployments using Bicep across your organization
📍 you are here - How to secure access to an Azure Container Registry with RBAC
How to secure access to an Azure Container Registry with a Managed Identity
How to utilize the Azure Container Registry in your Azure DevOps pipeline - to be published soon

I like to deploy my Azure resources using Bicep - If you never heard about it, I blogged a while ago on how to get started with Bicep - please catch up first!

How to Secure Access to an Azure Container Registry with RBAC

We discussed in the previous post how an Azure Container Registry may help you standardize and ease the work with deployment files. One of the questions I received (thanks Christian 👏) and wanted to address in this post was why not just use git (for example in Azure repos)? The answer is, that while git is amazing for during development, enabling teamwork, version control, traceability, images published to Azure Container Registry are immutable, so that they can’t be modified anymore. This ensures, that the files we work with are not being altered anymore. In this post, we’ll explore how to now secure access to an Azure Container Registry (ACR) using Role-Based Access Control (RBAC).

Before we start

Hate to break it to you, but there is a standard setting in Azure Container Registry, that I very much dislike.

It’s called Azure Container Registry Admin Access and allows accessing the entire ACR as an admin. Sounds super convenient, but pretty scary to me. And as if that wasn’t scary enough, for everyone who like to read audit logs as good night stories: If this stays enabled (because yes, this is ON by default 😱), it’s always the admin’s username appearing in the log files. That will make traceability of any issue really hard. So do yourself and me a favor and turn this off.

Ok, I’m glad we can finally proceed :-)

Understanding Azure RBAC for Container Registry

Azure Container Registry (ACR) supports a set of built-in Azure roles that provide different levels of permissions. These roles can be assigned to users, service principals, or other identities to control access to the registry. The primary roles include:

Owner: Full access to all resources
Contributor: Can manage all resources but cannot grant access to others
Reader: Can view all resources but cannot make changes
AcrPush: Can push container images to the registry
AcrPull: Can pull container images from the registry

Using Azure RBAC, you can assign these roles to ensure that only authorized identities can interact with your registry, whether it’s for pulling or pushing container images. For example, someone would be the person to exclusively push images (for examples the bicep deployment files from the last blog post) to ACR, but a set of developers should be able to consume (pull) the imaged from ACR.

Creating a Service Principal

To automate interactions with your ACR, you can create a service principal and assign it the necessary RBAC roles. I’d like to use a Key Vault then to securely store the credentials. Let’s go:


# Variables
$vaultName = "<name of your key vault>"
$spName = "<name of the service principal>"
$subscriptionId = "<your Azure subscription id>"
$resourceGroup = "name of the resource group>"
$acrName = "<name of your Azure Container Registry>"
$location = "<name of the location>"
$userObjectId = "<object id of our user>"
# Assign `Owner` to your user so that you have enough privileges to create service principal
az role assignment create --assignee $userObjectId --role "Owner" --scope /subscriptions/<your-subscription-id>
# Create a service principal and capture the output
$spOutput = az ad sp create-for-rbac --name $spName --role acrpull --scopes "/subscriptions/$subscriptionId/resourceGroups/$resourceGroup/providers/Microsoft.ContainerRegistry/registries/$acrName" --query "{appId: appId, password: password, tenant: tenant}" -o json
# Parse the JSON output to extract appId, password, and tenant
$spDetails = $spOutput | ConvertFrom-Json
$appId = $spDetails.appId
$password = $spDetails.password
$tenantId = $spDetails.tenant

Store the values in Azure Key Vault

Now we want to store the values in an Azure Key Vault. If you don’t already have one (and permissions to write to it), let’s create one first:


az keyvault create --name $vaultName --resource-group $resourceGroup --location $location

To be able to push values into the Key Vault, we need to assign an RBAC role Key Vault Secrets Officer. So let’s get that done as well:

# Assign the Key Vault Secrets Officer role to your user
az role assignment create --assignee $userObjectId --role "Key Vault Secrets Officer" --scope "/subscriptions/$subscriptionId/resourceGroups/$resourceGroup/providers/Microsoft.KeyVault/vaults/$vaultName"

💡RBAC in Key Vault can be a bit tricky, as sometimes we will need to allow a bit more of propagation time for the role assignment to be fully effective. We can solidify our little script like this:


# Wait for role assignment to propagate
$maxRetries = 10
$retryCount = 0
$roleAssigned = $false
while (-not $roleAssigned -and $retryCount -lt $maxRetries) {
Start-Sleep -Seconds 10
$roleAssignment = az role assignment list --assignee $userObjectId --scope "/subscriptions/$subscriptionId/resourceGroups/$resourceGroup/providers/Microsoft.KeyVault/vaults/$vaultName" --query "[?roleDefinitionName=='Key Vault Secrets Officer']" -o json | ConvertFrom-Json
if ($roleAssignment -ne $null) {
$roleAssigned = $true
} else {
$retryCount++
Write-Output "Waiting for role assignment to propagate... ($retryCount/$maxRetries)"
}
}
if (-not $roleAssigned) {
Write-Error "Role assignment failed or has not propagated yet. Please try again after some time."
exit 1
}

Once that is completed successfully, we will push our credentials into the Key Vault


az keyvault secret set --vault-name $vaultName --name acr-sp-id --value $appId
az keyvault secret set --vault-name $vaultName --name acr-sp-password --value $password
az keyvault secret set --vault-name $vaultName --name acr-tenant-id --value $tenantId
Write-Output "Service principal credentials stored in Key Vault successfully ✅."

Lets briefly check this in the Azure portal:

Select the resource group in which the ACR resides
Select the ACR
Select Access Control (IAM)
Select Check access
Search for the name of your service principal
Select it - You can now see an overview of the roles of the service principal. In our case, it’s the acr-pull role. You can select this now again and view the permissions associated to this role.

Conclusion

We created a service principal, stored its credentials securely in an Azure Key Vault and assigned an RBAC role to it which will only grant pull permissions to the Azure Container Registry. This ensures, that using this service principal, no new images can’t be published to the ACR. The Azure Container Registry stores our published Bicep 💪 files and makes them ready to deploy, reducing the time it takes to write the Infrastructure as Code significantly.

Stay tuned for the next part of this series, where I’ll guide you through using the same concept but instead of a service principal with a Managed Identity (and why I prefer this even more).

Questions? Let me know!

How to use Azure Container registry to standardize deployments using Bicep across your organization

Thu, 29 Aug 2024 08:26:34 +0000

This post is part of a series

How to deploy Azure LogAnalytics Workspace and link Application Insights to it
📍 you are here - How to use Azure Container registry to standardize deployments using Bicep across your organization
How to secure access to an Azure Container Registry with RBAC
How to secure access to an Azure Container Registry with a Managed Identity and RBAC
How to utilize the Azure Container Registry in your Azure DevOps pipeline - to be published soon

I like to deploy my Azure resources using Bicep - If you never heard about it, I blogged a while ago on how to get started with Bicep - please catch up first!

You might now know, that I am a big fan of infrastructure as code

no more manual clickety-clackety in the Azure portal
it’s just less prone to human error
our deployment files can be logged into source control

I did not realize that many fellow developers still copy/paste code from their previous Bicep files to their current files. Or, even worse, they need to ask other developers in the organization how they use to deploy a certain resource. Infrastructure as Code is good, but wouldn’t it be better if we had a centralized repository across our organization with ready-to-use deployment files?

Azure Container Registry to the rescue!

What is Azure Container Registry?

Azure Container Registry (ACR) is a powerful tool for managing Docker container images, and it comes with several practical benefits:

ACR works effortlessly with other Azure services like Azure DevOps (more in this in a later part of this series). This makes it easier to set up continuous integration and deployment (CI/CD) pipelines
ACR provides a private, secure registry for your container images - You can control access with Microsoft Entra Id
It supports both Linux and Windows containers

Using ACR for our Bicep files will help with managing, versioning, and deploying our IaC as efficiently as possible. (And who wouldn’t want to spend less time on deployments 🤭)

How to create an Azure Container Registry

⚠️ If you don’t already have Docker installed, please go ahead and do this! If you are unsure, you can verify the installation in your terminal with

docker --version, ot should return something like this: Docker version 27.1.1, build 6312585 - if your version number is significantly lower, an update can’t hurt!

Once this is done, in your terminal using Azure CLI

# Set variables
$ACR_NAME="building-blocks"
$RESOURCE_GROUP="building-blocks-rg"
$LOCATION="westeurope"
# Create the ACR
az acr create --name $ACR_NAME --resource-group $RESOURCE_GROUP --location $LOCATION --sku Basic

(You can choose a name and a location to your liking!)

Build and publish your Bicep modules to the ACR

We will use the bicep files that we created in the last blog post of this series - if you did not follow that one, please do so now:How to deploy Azure LogAnalytics Workspace and link Application Insights to it and publish them to the ACR.

In your terminal using Azure CLI:

# Log in to the ACR
az acr login --name $ACR_NAME
# Publish the Log Analytics workspace module
bicep publish --file ./loganalyticsworkspace.bicep --target br:$ACR_NAME.azurecr.io/bicep/modules/loganalyticsworkspace:1.0.0
# Publish the Application Insights module
bicep publish --file ./appinsights.bicep --target br:$ACR_NAME.azurecr.io/bicep/modules/appinsights:1.0.0

If you gave your modules names in camelCase, you will get an error - only lower case letters are allows –> ask me how I know 🙄

Update your `main` Bicep File

As a last step, we will update our main Bicep file:

param location string = resourceGroup().location
param logAnalyticsWorkspaceName string
param appInsightsName string
param applicationType string = 'web'

// Link the Log Analytics workspace module from ACR
module logAnalytics 'br:<yourACRName>.azurecr.io/bicep/modules/loganalyticsworkspace:1.0.0' = {
 name: 'logAnalyticsDeployment'
 params: {
 location: location
 logAnalyticsWorkspaceName: logAnalyticsWorkspaceName
 }
}

// Link the Application Insights module from ACR
module appInsights 'br:<yourACRName>.azurecr.io/bicep/modules/appinsights:1.0.0' = {
 name: 'appInsightsDeployment'
 params: {
 location: location
 appInsightsName: appInsightsName
 applicationType: applicationType
 logAnalyticsWorkspaceId: logAnalytics.outputs.logAnalyticsWorkspaceId
 }
}

Verify that the modules got published

Now we want to see that things worked, right? Easy enough, you can run az acr repository list --name $ACR_NAME --output table, which will return

Conclusion

With ACR, you can now setup templates on how you want to deploy resources across the organization. This is especially helpful if you have resources with lots of properties like VMs :-). In the next blog post, I will cover how to utilize this approach in in Azure DevOps- Stay tuned!

How to use Bicep to deploy Azure LogAnalytics Workspace and link Application Insights to it

Wed, 28 Aug 2024 08:26:34 +0000

This post is part of a series

📍 you are here - How to use Bicep to deploy Azure LogAnalytics Workspace and link Application Insights to it
How to use Azure Container registry to standardize deployments using Bicep across your organization - to be published soon
How to utilize the Azure Container Registry in your Azure DevOps pipeline - to be published soon

I like to deploy my Azure resources using Bicep - If you never heard about it, I blogged a while ago on how to get started with Bicep - please catch up first if you are not yet familiar with Bicep!

I strongly believe that we can’t meaningfully improve what we don’t measure. Especially though when it comes to improving apps, user feedback alone is sometimes not as reliable as we wanted it to be. This is why I like to monitor performance and track user behavior with Azure Application Insights.

Azure Application Insights

Application Insights is a tool in Azure that helps you keep an eye on your app’s performance and user activity. It tracks things like response times, errors, and failures so you can spot problems before users raise lots of tickets. You can get alerts, if something is off and of course as it is an Azure service, it works well with all kin of other Azure services.

For the longest time, Application Insights could store its data independently, but a couple of months ago Microsoft changed this and Application Insights now requires you to use a Log Analytics Workspace as the backend for storing telemetry data. This raises obviously the question: What is a Log Analytics workspace?

Azure Log Analytics Workspace

An Azure Log Analytics Workspace is like a central hub where you collect and analyze log data from various sources, including your Power Apps and Azure services.

When you use Application Insights to monitor your app’s performance, connecting it to a Log Analytics Workspace supercharges your capabilities:

It lets you run advanced queries to dig into your data and uncover insights that basic Application Insights might miss
If you’re tracking multiple apps or resources, a Log Analytics Workspace pulls all the data together in one place, making it easier to spot patterns and issues

How do we create now the Log Analytics Workspace and Application Insights?

Please make sure, that you installed the Bicep tools

We will work through this in modules. If you are not familiar with this approach yet, using modules in Bicep is all about making your infrastructure code more organized and reusable. Instead of having one big, messy file, you can break things down into smaller, more focused pieces. For this deployment, we will need 3 files. 1 for the Log Analytics Workspace, 1 for the Application Insights and 1 main, that will call the other ones. Let’s get started!

Create a new bicep file, name it loganalyticsworkspace.bicep

param location string
param logAnalyticsWorkspaceName string

resource logAnalyticsWorkspace 'Microsoft.OperationalInsights/workspaces@2020-08-01' = {
 name: logAnalyticsWorkspaceName
 location: location
 properties: {
 sku: {
 name: 'PerGB2018'
 }
 retentionInDays: 30
 }
}

Create a new bicep file, name it appinsights.bicep

param location string
param appInsightsName string
param applicationType string = 'web'
param logAnalyticsWorkspaceId string

resource appInsights 'Microsoft.Insights/components@2020-02-02' = {
 name: appInsightsName
 location: location
 kind: applicationType
 properties: {
 Application_Type: applicationType
 WorkspaceResourceId: logAnalyticsWorkspaceId
 }
}

Create a new Bicep file, name in main.bicep

param location string = resourceGroup().location
param logAnalyticsWorkspaceName string
param appInsightsName string
param applicationType string = 'web'

// Deploy Log Analytics workspace
module logAnalytics 'logAnalyticsWorkspace.bicep' = {
 name: 'logAnalyticsDeployment'
 params: {
 location: location
 logAnalyticsWorkspaceName: logAnalyticsWorkspaceName
 }
}

// Deploy Application Insights and link to Log Analytics workspace
module appInsights 'appInsights.bicep' = {
 name: 'appInsightsDeployment'
 params: {
 location: location
 appInsightsName: appInsightsName
 applicationType: applicationType
 logAnalyticsWorkspaceId: logAnalytics.outputs.logAnalyticsWorkspaceId
 }
}

4. Now deploy this using Azure CLI

```azurecli
# Set variables
$RESOURCE_GROUP="yourResourceGroupName"
$LOCATION="yourLocation"
$LOG_ANALYTICS_WORKSPACE_NAME="yourLogAnalyticsWorkspaceName"
$APP_INSIGHTS_NAME="yourAppInsightsName"

# Create resource group if it doesn't exist
az group create --name $RESOURCE_GROUP --location $LOCATION

# Deploy the main Bicep file
az deployment group create \
 --resource-group $RESOURCE_GROUP \
 --template-file main.bicep \
 --parameters logAnalyticsWorkspaceName=$LOG_ANALYTICS_WORKSPACE_NAME appInsightsName=$APP_INSIGHTS_NAME location=$LOCATION

💡 please make sure that you put actual values into the placeholders

As a result, we can now see

that the deployment worked like a charm! We can even see, that in fact, we have 4 deployments - One of them being Smart detection - Failure Anomalies, that gets automatically deployed. The other 3 are exactly the files that we created!

Bonus for Power Apps people

You can now link your Application Insight Instrumentation Key to a Canvas app an track its performance! OPen your app in EDIT mode, open the APP object and find the Instrumentation Key property on the right pane:

Conclusion

Bicep modules make it very easy to deploy Azure resources - If you’d like to take that one or two levels up, then stay tuned for next parts of this series… Where we cover how to utilize a Docker container to store our Bicep files org wide, and how to use this then in automated Azure DevOps pipeline!

How to get from Dev? Ooops! 🤭 to proper (Azure) DevOps for Power Platform

Mon, 26 Aug 2024 08:26:34 +0000

Watch out - this is part 2 of a series around very good practices in Power Platform

Part 1: Yolo! Let’s deploy Friday?!
📍 You are here –> Part 2: How to get from Dev? Ooops! 🤭 to proper (Azure) DevOps for Power Platform
Part 3: More options in Azure DevOps to manage Power Platform: to be published soon
Part 4: How to monitor Power Platform solutions with Azure Application Insights : to be published soon
Part 5: How to test Power Platform solutions : to be published soon

Why would we care?

There are Power Platform solutions, that are purely meant to be for personal productivity. They only impact the user who built them and it’s ok (for me) to have them as an unmanaged solution in the default environment.

For solutions though, that impact more people or that even drive mission-critical processes, it’s a good idea to

develop them in a different environment than they are used in
log the changes into a source control system
publish the solution as a managed solution for users
automate this process

If we don’t do that, it leads to solutions being subjects to change for end-users all the time - so that they can’t rely on a feature to be tested and working as planned. It also means that developers can’t revert/undo changes and it eventually leads to lots of manual and chaotic ad-hoc work, which puts unneccesary stress on admins and developers:

We operate at open heart when developing solutions while users keep using them
We can’t roll back to previous versions
Code only exists as opaque zip files in an environment

How do we care?

Basics

Let’s first cover some basics so that everyone is on the same page: All Power Platform components are packaged and distributed across environments using solutions There are 2 types of solutions, unmanaged and managed solutions. Unmanaged solutions are a collection of references to components, there are no restrictions on what can be added, removed, or modified, and they are recommended only during development of the solution. Managed solution’s components can’t be added or removed or modified. They are recommended when a solution is not actively being customized. Source control should be your source of truth for storing and collaborating on your components.

How do we do this? There are several options:

Power Platform Pipelines (built-in, super easy to use, super limited as well.)
GitHub actions
Power Platform Build Tools for Azure DevOps

I will explain how this works for Azure DevOps, as I use this in nearly all my projects at my customers.

What is Azure DevOps Build Tools for Power Platform

Azure DevOps Pipelines automatically build code projects and ship them to any target
They support both GitHub and Azure repos (but there is no explicit value for me to store the codein GitHub when I use Azure DevOps)
Azure DevOps Build Tools for Power Platform are a collection of build and release tasks related to Power Platform

Prerequisites / little bit of prep work

As we do not want to develop the solution in the same environment as we want users to use, we’d need at least 2 environments.

I’m a big fan of a 4 environment setup

Overview of environments

DEV - only for development purposes, only developers and maintainers have access to it
BUILD - only used to store the exported unmanaged solution and export it as managed solution (this separates the solution from the solution that is currently and ongoing developed in DEV). I want a separate (and new!) environment to build the solutions so that no Gremlins (coined by J. Rapp) could interfere (connection references, environment variables, etc.)
TEST - only for User Acceptance Testing - A subset of endusers can test functionality of this release.
PROD - production use of apps in the organization

💡 Obviously, if there is a requirement for a new environment in the organization, it’s a good idea to then have this set of environments.

Process of building and releasing versions

Every new feature, all bug fixes are implemented in DEV. Once the release passed the technical tests in DEV, it is build in BUILD and then finally released to TEST, where end users can try out and test the release. If they approve it, the release gets published to PROD. If they don’t approve it, development starts again in DEV and bug fixes/features get implemented in the next sprint.

Setup instructions

You will obviously need to have an Azure DevOps organization, and within it a new project. In this project

Create a repository to hold your code
Optional, but a good idea: Clone this repo so you can work locally in VS Code
Optional, but also a good idea: invite co-workers to the project
Open Project Settings (lower left corner) –> Repositories –> Security and select Contribute permissions for both (!)
- Project Collection Service Accounts permissions
- Build Service permissions

Create environments

As a first step, we need to ensure that we have all environments in place:

Open aka.ms/ppac
Create environments for DEV, BUILD, TEST, PROD - make sure all of them have a Dataverse database

Authentication

To authenticate in Azure DevOps against actions in Dataverse, you will need to

Let’s get our hands dirty.

Create an app registration

You can either create the app registration with a single line command in CLI for Microsoft 365. I posted a detailed blog post here.

m365 aad app add --name 'myApp001' --withSecret

or create it in the UI:

Open portal.azure.com
Select Microsoft Entra ID
Select App registrations –> New app registration
Give it a name, select Register
Select Certificates and secrets, create a secret, take note of it. (No I mean for real - you will not be able to se the value again if you navigate away.)
Also copy the values of the App id and Tenant id - we need them later.

💡 If you think that you should grant API permissions for Dynamics CRM -> user_impersonation, please don’t be fooled. This is not necessary, as access to Dataverse exclusively handled by Security Roles. You can read more about it in this blog post:Why your Power Platform service principal doesn’t need a Dynamics user_impersonation scope

Create an Application user

Now we need to make sure that we create an Application user in all of our 4 environments.

Open aka.ms/ppac
Select your environment
Select Settings
Select Application users under Users & permissions
Select new app user
Select add an app
Select the app registration from Microsoft Entra Id
Select the business unit
Select the pen icon next to Security roles and add the System Administrator role
Select Save

💡Remember to do this for all environments!

Create Service connections in Azure DevOps

To be able to use the Power Platform Build Tools in Azure DevOps, we first need to install them. You can find the download here

Return to Azure DevOps, select Project settings –> Pipelines –> Service connections
Select new service Connection
Select Power Platform
Select Application Id and secret as authentication method
Obtain the Instance URL from your DEV environment ( Open make.powerapps.com, Select the DEV environment, Select the gear icon ⚙️ in the top right corner, Select Settings, copy the Instance URL)
Paste this value to Server URL
Paste Tenant id, App id, and App secret from your app registration into the respective fields
Save the connection under name DEV Service Principal
Repeat this steps for BUILD, TEST, and PROD

Create Build pipeline 1 - Export from DEV

This Build Pipelines objective is to export a solution from DEV into source control (Azure DevOps repos)

It’s a good practice to write your pipelines in YAML - This way you can also log the code that describes your pipeline into source control. Here is the snippet:

Please note that

I have a variable called SolutionName so that I can reuse this pipeline for any other Power Platform solution
I like to have my zip file in the solution folder and the unpacked files in the sourcecode folder

pool:
 name: Azure Pipelines
#Your build pipeline references the ‘SolutionName’ variable, which you’ve selected to be settable at queue time. Create or edit the build pipeline for this YAML file, define the variable on the Variables tab, and then select the option to make it settable at queue time. See https://go.microsoft.com/fwlink/?linkid=865971

steps:
- task: microsoft-IsvExpTools.PowerPlatform-BuildTools.tool-installer.PowerPlatformToolInstaller@2
 displayName: 'Power Platform Tool Installer '

- task: microsoft-IsvExpTools.PowerPlatform-BuildTools.export-solution.PowerPlatformExportSolution@2
 displayName: 'Power Platform Export Solution - unmanaged'
 inputs:
 authenticationType: PowerPlatformSPN
 PowerPlatformSPN: 'DEV Service Principal'
 SolutionName: '$(SolutionName)'
 SolutionOutputFile: 'solution/$(SolutionName).zip'

- task: microsoft-IsvExpTools.PowerPlatform-BuildTools.unpack-solution.PowerPlatformUnpackSolution@2
 displayName: 'Power Platform Unpack Solution '
 inputs:
 SolutionInputFile: 'solution/$(SolutionName).zip'
 SolutionTargetFolder: '$(Build.SourcesDirectory)\sourcecode'
 ProcessCanvasApps: true

- script: |
 echo commit all changes
 git config user.email "<my email>
 git config user.name "<my name>"
 git checkout -B main
 git add --all
 git commit -m "adds source code files from DEV"
 git push --set-upstream origin main
 displayName: 'Command Line Script'

If you prefer to build the pipeline in a visual editor (and later on copy/paste the yaml), this is how it works: First, enable classic editor in the projects settings.Then,

Select Pipelines –> New Pipeline –> Use the Classic Editor
Select the Source as Azure Repos Git, select your Project, Repository and Branch and select continue
Select Start with empty job
Select Agent Job 1 and check Allow Scripts to access OAuth token
Add task Power Platform Tool Installer
Add task Power Platform Export Solution
As Service Connection select Dev Service Principal
Provide the solution name (not the displayName) and the folder for the output - select the … menu for that. You can also use variable for that.
Uncheck the Export as Managed solution checkmark
Add task Power Platform Unpack solution
Specify Input file (its the output file location from previous task)
Specify target folder to output th unpacked files (can sit at the root of the project - use the … menu)
Add a task Command Line script, and paste the below script


echo commit all changes
git config user.email “<your git email>”
git config user.name "<your git user name>"
git checkout -B main
git add --all
git commit -m "code commit"
git push --set-upstream origin main

Save and queue the pipeline and wait for it to run successfully

Create Build pipeline 2 - Build Managed Solution

Now onto building pipeline 2

Objective here is to deploy the unmanaged solution to our BUILD environment, so that we can still continue to modify code in DEV.

Here is the yaml view:

pool:
 name: Azure Pipelines
variables:
 SolutionName: '$(SolutionName)'

steps:
- task: microsoft-IsvExpTools.PowerPlatform-BuildTools.tool-installer.PowerPlatformToolInstaller@2
 displayName: 'Power Platform Tool Installer '

- task: microsoft-IsvExpTools.PowerPlatform-BuildTools.pack-solution.PowerPlatformPackSolution@2
 displayName: 'Power Platform Pack Solution '
 inputs:
 SolutionSourceFolder: sourcecode
 SolutionOutputFile: '$(Build.ArtifactStagingDirectory)\$(SolutionName).zip'

- task: microsoft-IsvExpTools.PowerPlatform-BuildTools.import-solution.PowerPlatformImportSolution@2
 displayName: 'Power Platform Import Solution '
 inputs:
 authenticationType: PowerPlatformSPN
 PowerPlatformSPN: 'BUILD Service Principal'
 SolutionInputFile: '$(Build.ArtifactStagingDirectory)\$(SolutionName).zip'

- task: microsoft-IsvExpTools.PowerPlatform-BuildTools.export-solution.PowerPlatformExportSolution@2
 displayName: 'Power Platform Export Solution - managed'
 inputs:
 authenticationType: PowerPlatformSPN
 PowerPlatformSPN: 'BUILD Service Principal'
 SolutionName: '$(SolutionName)'
 SolutionOutputFile: '$(Build.ArtifactStagingDirectory)/$(SolutionName)_managed.zip'
 Managed: true
 OverwriteLocalSolution: false

- task: PublishBuildArtifacts@1
 displayName: 'Publish Artifact: drop'
 inputs:
 PathtoPublish: '$(Build.ArtifactStagingDirectory)\'

For the classic editor, use the following

Now onto building pipeline 2

Add tasks
- Power Platform Tool Installer
- Power Platform Pack Solution
- Power Platform Import Solution
- Power Platform Export Solution
- Publish Artifact drop

Power Platform Pack Solution

This task will pack the unpacked files that are currently sitting in DEV as an unmanaged solution:

Power Platform Import Solution

This task will now import the unmanaged solution into our BUILD environment.

Power Platform Export Solution

This task exports the solution as a managed solution:

Publish Artifact Drop

As a last step, we will now publish the build artifacts

Release pipeline to TEST

Now that we have our managed solution in the BUILD environment, we will want to release it to TEST or to PROD (depends on requirements of User Acceptance Testing)

Under Pipelines, select Releases
Under Artifacts, select your project and the source (its the Build pipeline 2 - Build Managed Solution)

For Stage 1, add 2 tasks
- Power Platform Tool Installer
- Power Platform Import Solution

Create a Release
Deploy the Release

Release pipeline to PROD

Create another Release pipeline for PROD

Process of CI/CD

The process of Continuos Improvement/Continuos Deployment (CI/CD) describes how we can now iterate in a secure way to improve our app, while making sure that users are not affected by changes happening in DEV, have the chance to exactly test in TEST what they will get in PROD and developers can feel at ease as all code is stored in source control and commits can be easily tracked.

For our Build pipeline 2 - Build Managed Solution we can turn on a setting enable continuos integration which means, that every time, we push code to our main branch this job runs and builds a Managed solution in BUILD.

We do push code to our main branch by letting our Build pipeline 1 - Export from DEV run 💡 - which we trigger manually in Azure Devops.

For the Release pipeline, there is a similar setting:

Once it is enabled, it triggers automatically, if a new Build is available, aka when our Build pipeline 2 - Build Managed Solution ran successfully. This means, that with these settings being switched on, we start a chain reaction every time, we run Build pipeline 1 - Export from DEV - and it results in a new release of a managed solution in TEST.

Users can now do the user acceptance training, log experienced issues or change requests for the next release and then we can manually trigger the Release to PROD pipeline so that we export the solution to the PROD environment. In case of severe issues with the release, which only get discovered during user acceptance testing, release to PROD will be deferred, changes to the app are being addressed in DEV, and then the pipelines are triggered again manually to run the entire process again.

Conclusion

With this basic setup, we solve the issues described at the beginning of the post - and deployments now don’t take up human time anymore - as noone needs to manually import and export zip files. Also we safely separated developing solutions from using them and took care that the solution in the PROD environment is a managed one.

From here, you can now expand your pipeline. I will cover some examples in one of my next blog posts - stay tuned!

Yolo! Let's deploy Friday?!

Fri, 23 Aug 2024 09:49:21 +0000

We do not deploy on Fridays, AmIRite?

Ah, the infamous Friday Freeze – a term that became somewhat of running joke among developers. The idea is simple: Don’t deploy on Fridays. Why? Because if something goes wrong, your weekend plans might just go up in smoke as you scramble to fix the emergency. So instead of putting energy and effort into developing and fostering a deployment process we can trust, we focus on avoiding potential disasters. Sounds like a stressful environment if you ask me.

It’s not about Friday. It’s about fear.

We don’t deploy on fridays, if we don’t trust our software and/or our process. So, what if, instead of hiding behind programmer-memes and perpetuating the false narrative of No friday deploys we fix the underlying issue and deploy software, that is proven and tested and deployed in an automated manner?

I know, strange thinking here 🤭

But let’s be real for a moment: Is the Friday Freeze really a good practice? Spoiler alert: It is not. In fact, it can be quite counterproductive.

Disadvantages of Friday Freeze

First off, avoiding deployments on Fridays will inevitably create a bottleneck. If everyone is tries to deploy their changes earlier in the week, it can lead to rushed and poorly (if even) tested deployments. This rush can actually increase the likelihood of errors (both in a broken software and as in impacting other systems), which is exactly what we’re trying to avoid in the first place. Plus, if something does go wrong mid-week, it can still spill over into the weekend. So, the Friday Freeze doesn’t really save us from weekend work; it just shifts the risk to other days.

And then there’s the YOLO-deploy. You know, the “You Only Live Once” approach where you throw caution to the wind and deploy without giving any f*cks. (While there are days, where I seriously run out of all the f *cks I could give, it’s still not exactly the best strategy for maintaining a stable production environment.)YOLO-deploys can lead to unexpected issues and lots of firefighting. (And firefighting during the weekend means that I don’t get the rest I need 🙄).

Having developers literally throw their software over a fence and then keep fingers cross to hope for the best has never been a valid approach, and still I hear lots of things at customers that make me ~~scratch my head~~ wanna cry:

Deployments? I thought this is low-code! We just right-click and publish.

Or even:

Testing? Our end users will mention if something doesn’t work 🤞

While these beliefs might seem convenient, they are far from good practice.

Just because it’s low-code, doesn’t mean we can skip proper deployment habits. Low-code platforms like Power Platform still require structured deployment pipelines to ensure stability and consistency. The infamous argument: Yeah we only do this for small changes! - Trust me - there are in fact no small changes, so please do yourself and your team a favor and don’t even think about publishing what you deem a small change without pushing the change through the pipeline.

Relying on end users to catch issues? That’s a recipe for disaster. End users are great at providing feedback, but they shouldn’t be your primary line of defense. Proper testing, both automated and manual, is crucial to catch issues before they reach production. Automated tests help ensure that your application works as expected. But even if you covered your bases in terms of automated tests: Manual exploratory testing is also important to catch those unknown unknowns that automated tests might miss.

So, shall we revisit how we think about deployments instead of a rigorous Don’t deploy on Fridays or anyday YOLO deploys? I think it’s about time to do so! Here are a few tips:

Automated Testing - More is more!

Automated testing is your best friend when it comes to catching issues early. Think of it as your safety net. By implementing comprehensive automated tests, you can ensure that your code is functioning as expected before it even hits production. This includes

unit tests, which check individual components
integration tests, which ensure that different parts of your application work together
and end-to-end tests, which simulate real user scenarios
performance validation, which measures how speedy operations are being completed
security tests
accessibility tests

The more you test, the more confident you can be in your deployment - regardless of the day of the week!

Continuous Integration and Continuous Deployment (CI/CD)

CI/CD pipelines are the backbone of deployment practices. By adopting CI/CD, you automate the deployment process, ensuring that deployments are consistent and repeatable. This reduces the chance of human error (and yet again: We ALL make mistakes!) and allows you to deploy changes more frequently and reliably. There are lots of options to do this properly in Power Platform, and I’ll cover this topic in the next part of this series. Stay tuned!

Monitoring and Alerts

Setting up robust monitoring and alerting systems is crucial for maintaining the health of your application post-deployment. These systems make sure that you are the first to know if something went wrong - instead of your users noticing it and calling the emergency hotline (which seems to be your mobile on a weekend). I’ll blog about how to monitor your Power Platform solutions in another post of this series.

Rollback Plan

Always have a rollback plan in place. If something does go wrong (and it will!), you should be able to revert to the previous stable state quickly and efficiently. If you need to figure out how to roll back only when you need to, you will loose time (and get some extra grey hair).

Conclusion

Yes, deploy (also) on Fridays! Don’t fear the weekday, but fear non-tested software and a poor deployment process. If you feel like “Yeah, we should probably invest into creating or solidifying our CI/CD process BUT WE JUST DON’T HAVE TIME” - then sorry to break it to you, but you are confusing cause and effect. Having even a basic testing routine and pipeline will not only make sure, that you will more often smaller changes (which reduces likelihood of BIG things to break), but also reduce the time you need to spend on every single deployment while ensuring easy revertability. You know, just in case something goes wrong :-)

This post is the first part of a series about good development and deployment practices. Stay tuned for the next parts where I focus on

How to use Azure DevOps to deploy Power Platform projects
How to test Power Platform solutions
How to monitor Power Platform solutions with Azure Application Insights

Let me know if you have questions :-)

How to upload files to SharePoint for Dataverse integration in a Power Apps canvas app

Tue, 09 Jul 2024 08:29:58 +0000

Use Case

Recently, someone asked me if it was possible to utilize the SharePoint integration in Dataverse not only from a model-driven app, but also from a canvas app. Challenge accepted!

Tl;dr: yes, it is possible and it’s easier than you might think!

Some prep work

First, we will need to do some prep work.

Setup SharePoint integration in Dataverse - here is a good blog post by Matthew Devaney that will guide you
Make sure that the SharePoint folders that get created, do not append the record name of the Dataverse record with some GUID (Microsoft does that so that there are no duplicates, if you for example name the record like a customer and then have 5 customers with name Miller.) You can do this with an amazing tool by Sean McNellis, Shaun Wilkinson describes how to do this.
We will need the SiteId and DriveId of our SharePoint library. You can get those using Graph Explorer

The canvas app

At a minimum, you will need to have 3 things

a connector, that does the heavy lifting calling the right endpoint in the Graph API to upload a file to a specific folder - we will use the Office 365 Groups connector
an attachment control (you get this from a form, connect this to a random SharePoint list, cut out the DatacardValue control, rename to Attachments and delete the rest of the form)
a button that will take care of the action.

I also added a table/gallery so that I can choose the record to which I want to associate a file.

It looks like this:

Table/Gallery

Add the Dataverse table to your app and connect your table/gallery to it
Add the Office 365 Groups connector
In the OnSelect of the table, put


Set(varDriveId, "<DriveId goes in here>");
Set(varSiteId, "<SiteID goes in here>");
Set(varFolder, Table1.Selected.Name)

Button

Add a button
Put in the OnSelect


ForAll(
Attachments.Attachments,
Office365Groups.HttpRequest(
"https://graph.microsoft.com/v1.0/sites/" & varSiteId & "/drives/" & varDriveId & "/root:/" & varFolder & "/" & ThisRecord.Name & ":/content",
"PUT",
ThisRecord.Value
)
);
Reset(Attachments);

This will upload all your files that you select with the Attachments control to a folder that has the same Name like the associated record that we selected in the table/gallery. If the folder does not exist yet, it will be created, if it already exists, then the file will be only uploaded into the folder.

As a result, regardless if we use the canvas app or the model-driven app to upload files, they all get associated with the correct record in Dataverse.

If you’d like to know how to display previews from files on SharePoint in the canvas app, here is a neat blog post by Diana Birkelbach

Conclusion

Canvas app can work nicely in addition to a model driven app with SharePoint integration, powered by the Office 365 Groups connector. Let me know what you think!

How to build a deskbooking tool with Microsoft Planner and Power Automate

Wed, 03 Jul 2024 06:49:31 +0000

Use Case

Recently, a customer asked if it was possible to low code build a desk booking tool without using Power Apps.

Tl;dr: yes, it is! We will leverage the UI of Microsoft Planner and use Power Automate to do the heavy lifting. Each bucket in Planner represents a day where desks are bookable, each task in Planner represents a room in which desks are present.

Features

Planner Rooms starts with 21 buckets for each day in the next three weeks
Each bucket is initially filled from a template bucket in a Rooms Template plan. It consists of all tasks which represent the rooms
- the description shows information about the room
- the checklist shows who already booked a desk on this day in the room
A new bucket gets created each day
The oldest bucket (which now represents the day before the current day) is archived to an Rooms Archive plan.

How to build this

Planner

We need to create three plans:

Rooms Template
Rooms
Rooms Archive

Rooms Template

Create a bucket
Create a task for every room with a description
For each desk, create a checklist item and put a placeholder in like “Type in your name here”

Rooms

For now, leave empty, we will deal with this a bit later.

Rooms Archive

For now, leave empty.

Power Automate flow to initially fill the Rooms plan

To initially fill the Rooms with 21 buckets (which represent the next 21 days) we will employ a Power Automate flow.

Trigger: Manual trigger (it only needs to run once)
Planner: List tasks from the Room Template plan
Initialize a variable currentDay (string)
in a Do Until (Currentday eq FormatDateTime(addDays(utcNow(), 21), 'D'))
- Set the currentDay variable to FormatDateTime(addDays(utcNow(), 21), 'D')
- Planner: Create a new task with the Name of the currentDay variable
- Add an Apply to each
  - Planner: Get task details from the Rooms template
  - Planner: Create a task in the Rooms plan with the title bucket id we already obtained
  - Planner: Update task details - for the description

Now run the flow and see that your Rooms plan automagically gets populated with 21 buckets containing all the tasks that represent the rooms. You can turn off the flow now, as we don’t need to run it anymore.

Power Automate flow to take care of a new bucket to be created every single day

First, some visual representation of our flow:

As we want this to run every day, we will start with a Recurrence and let it run for example at 6am.
We will now initialize two variables:
1. yesterday of type string with a Value: formatDateTime(addDays(utcNow(), -1), 'D')
2. day 22 of type string with Value: formatDateTime(addDays(utcNow(), 22), 'D')
In a Scope (makes it look neat and tidy):
1. Planner - Create a bucket for the new day. Name: our day 22 variable, Group Id and Plan Id need to be the Rooms plan.
2. Planner - List tasks. Group Id and PlanId need to be the RoomsTemplate plan
3. Apply to each
  1. Planner: Get task details
  2. Planner: Create a task (Preview)
  3. Planner: Update task details This will create a new bucket for the new day and get the task from our template. We will then loop through all of the tasks of the template and re-create them in the new bucket including description and checklist
Let’s create the next Scope for archiving the oldest bucket (yesterday)
1. Planner - List buckets in Rooms
2. Filter array - to get yesterday’s bucket value Name needs to equal our yesterday variable
3. Use a Compose action to select the id
4. Planner: List tasks Rooms
5. Planner: Create bucket with Name of the yesterday variable in RoomsArchive plan
6. Apply to each
  1. condition if items('Apply_to_Each)?['bucketid'] equals the id we have in our Compose action
    1. yes:
      1. Planner: Create a task in Archive
      2. Planner: Get task details from room
      3. Apply to each
        
        Planner: Checklist: Update task details from Rooms to Archive
  2. no: leave empty
7. outside (!) of the 2nd (!) but inside of the first loop in this scope: Planner: Delete a task

This scope takes care of first recreating all the tasks in the RoomsArchive plan and then deletes the tasks in yesterday’s bucket in the Rooms plan.

We will now create the last scope - which deletes yesterday’s bucket. Unfortunately, there is no action in the Planner connector that would allow us to delete a bucket - so we need to handle this ourselves. We will leverage an HTTP request against the Microsoft Graph API. Following the docs, we need to hit DELETE /planner/tasks/{id}. To authenticate against Graph API, we need to perform an app registration in Entra ID. If you don’t know how this works, you can look this up here if you prefer a terminal experience or here if you like GUIs more.

So please first go ahead and register your app in Entra ID, note your tenant id, app id and app secret. For permissions, we will use Tasks.ReadWrite.All In this scope

Apply to each
condition if the bucket name equals our yesterday variable
1. yes:
  1. Apply to each - Body of our Filter array
  2. HTTP request to https://graph.microsoft.com/v1.0/planner/buckets/@{items('Apply_to_each_-_check_to_only_get_yesterday''s_bucket')?['id']}
  3. Headers: If-Match: "@items('Apply_to_each_2')['@odata.etag']"
  4. Fill in the values for tenant id, app id and app secret, audience is https://graph.microsoft.com.

This will delete the empty bucket.

Here is the full flow:

Conclusion

We now built with 2 quite simple flows a desk booking tool - without the need to build our own UI and in a real low-code manner :-)

The past booked rooms get archived for traceability reasons (and of course we could set up another flow that would delete those after after a while as well, every day a new set of rooms gets automatically created and everyone can book their rooms up to 3 weeks in advance. Pretty neat, right? Let me know what you think!

How to organize your homeoffice with NFC tags and Apple

Thu, 29 Feb 2024 07:34:11 +0000

tl;dr

With NFC tags and an iPhone you can quickly build a nice system to organize and find all your cables, adapters and more!

NFC tags

What is an NFC tag?

An NFC tag (Near field communications) tag is a little sticker that has a microchip in it, which you can program to your needs. It will communicate with other NFC enabled devices, such as your iPhone. You can get those stickers very cheap, I bought these one here.

Create an organization system

Use case

I don’t know about all of you…but personally, I have a lot of boxes with too many cables in them. I don’t want to throw them away, because I trust that I will need all of them at some point.

What I want:

💫 I want to be able to scan an NFC tag on the outside of my box so that a list of the contents pops up on my phone.

💫 Also I want to be able to add items - but with a little help of ~~my friends~~ AI.

💫 Last but not least I want to be able to search an item across all boxes and it shall return the correct box number for me.

Prep work

I put an NFC tag on each of my boxes and write a number on it.
I take my iPhone, open the Notes app and create a folder Boxes in it.
For each and every box, I create a new note in that Boxes folder and list all the items that are in that particular box. The title of each box should match the number of the NFC tag.
Optionally, I take a photo looking inside the box and save it in the note as well.

Create the Shortcut

If I scan a code, my phone shall open a menu from which I can choose

Show me what is in the box I scanned (without me needing to open Pandora’s box)
Let me add an item
Let me search for an item as I don’t know in which box I will find it

So let’s get our hands dirty!

How can we trigger an action?

If you own an iPhone, its quite easy. In the pre-installed app on an iPhone, find the Shortcuts app.

Open it
Select Automation
Select the +
Scroll down and find NFC
Select NFC
Select Scan
Scan the NFC tag (just hold the upper part of your phone against ist)
Type in a name or your NFC tag
Select Run immediately instead of Run after confirmation
Select Next
Select New Blank Automation

How do we define the actions?

As described, I first want to have a menu

Add a Choose from menu action and add
- 👀 View contents
- ➕ Add item
- 🔍 Find item
to the menu
That will automatically create a switch/case for you so that for each option, you can define the actions, that shall take place.

When running the shortcut, it will look like this:

For 👀 View Contents you want to add an action from the app Notes, more specifically, you want to open a specific note, the one that you asociated with this NFC tag, as every box has its own note. This means, once you scan the box, and select 👀 View Content it will open up the note that lists the content of that box and shows a picture whats inside the box.
For ➕ Add item you will not want to manually type in what you add to the box. At least I didn’t want that but took the opportunity to include some nice AI feature in this little home organizing solution.

To do this, download Toolbox Pro for Shortcuts from the App store, which gives you access to some more actions in Shortcuts. For this feature, we will use the Recognize objects in Photo action.

Now in our Shortcut, we need to insert a Take a photo with camera, then insert the Recognize objects in Photo action, and will then use the Notes action Append to Note which means that we will add whatever the AI detected in the photo we took, a a text to the note.

For 🔍 Find item, we want to first bring up a Ask for Text action which prompts us What are your looking for?, then we add a Find Notes where Name contains Provided Input, before we open the note that it found so that we know which box we need to open. This is how our entire Shortcut automation looks like:

💡Now you repeat this for all the boxes :-)

As a result, when you scan one of your boxes, you will be prompted with the menu so that you can decide whether you want to (virtually) look inside the box (which will then open the correct note for you which lists all contents), or if you want to add an item via AI by taking a picture with your phone or if you want to type in an item so that it will tell you in which box you can find it.

More ideas

Pretty cool? Let’s have more ideas what to do with NFC tags and an iPhone!

Build your own water tracker

I track my water intake and placed one NFC sticker at the water station in my kitchen. So whenever I fill my glass again, I scan the NFC tag.

What happens:

I log a sample to the Apple Health app (water, 250ml)
I display a notification so that I know that this worked

Get into deep focus work

I am easily distracted and deep focus work is as necessary as hard to get into for me. Two things though are helpful:

Background noise (I use the built in ones by Apple - yes, that’s an accessiblity feature)
Putting my phone on Do not disturb

So why not make a Focus NFC tag that does exactly that?

I hope you got some inspo on what to build - let me know if you have questions!

How to use Azure OpenAI with data in your SharePoint libraries

Mon, 23 Oct 2023 07:34:11 +0000

tl;dr

We can index documents from a SharePoint library with Azure Cognitive Search and then use an Azure OpenAI model to query the data. Using a custom connector, we can bring this power into Power Apps.

Prerequisites

Have documents (*.docx, *.pdf) in a SharePoint library
Azure Cognitive Search service (Basic or Standard tier)

Preparations

Note down the URL of the Site your library lives in
Note down the URL and the Admin Key of your Azure Cognitive Search Service
Turn on System-Assigned Managed Identity in your Azure Cognitive Search Service
Create an Entra Id app registration with the following parameters:
- single tenant
- Microsoft Graph API delegated permissions (don’t forget to grant admin consent) for
  - Files.Read.All
  - Sites.Read.All
- Mobile and desktop applications
  - enable https://login.microsoftonline.com/common/oauth2/nativeclient 💡Note down the App Id.

Connect your SharePoint library with Azure Cognitive Search

Create a Data Source with the Azure Cognitive Search Preview REST API

We will hop over to Postman to create a new data source for Azure Cognitive search using the REST API (it is still in preview.)

POST to https://<name-of-your Azure Cognitive Search service>.search.windows.net/datasources?api-version=2023-07-01-Preview
Params:
- api-version: 2023-07-01-Preview
Headers:
- Content-Type: application/json
- api-key: <the Admin key of your Azure Cognitive Search Service>
Body (Json):

{
 "name": "sharepoint-datasource",
 "type": "sharepoint",
 "credentials": {
 "connectionString": "SharePointOnlineEndpoint=<your SharePoint Site URL>;ApplicationId=<your App Id>"
 },
 "container": {
 "name": "defaultSiteLibrary",
 "query": null
 }
}

This will return a 201 response, indicating that your datasource was created. You can check this in the Azure portal

Create your Index

Let’s now leverage metadata of your document to enhance your search experience. This as well is done by using the REST API. We will again do this in Postman:

POST to https://<name-of-your Azure Cognitive Search service>.search.windows.net/indexes?api-version=2023-07-01-Preview
Params:
- api-version: 2023-07-01-Preview
Headers:
- Content-Type: application/json
- api-key: <the Admin key of your Azure Cognitive Search Service>
Body (Json):

{
 "name" : "sharepoint-index",
 "fields": [
 { "name": "id", "type": "Edm.String", "key": true, "searchable": false },
 { "name": "metadata_spo_item_name", "type": "Edm.String", "key": false, "searchable": true, "filterable": false, "sortable": false, "facetable": false },
 { "name": "metadata_spo_item_path", "type": "Edm.String", "key": false, "searchable": false, "filterable": false, "sortable": false, "facetable": false },
 { "name": "metadata_spo_item_content_type", "type": "Edm.String", "key": false, "searchable": false, "filterable": true, "sortable": false, "facetable": true },
 { "name": "metadata_spo_item_last_modified", "type": "Edm.DateTimeOffset", "key": false, "searchable": false, "filterable": false, "sortable": true, "facetable": false },
 { "name": "metadata_spo_item_size", "type": "Edm.Int64", "key": false, "searchable": false, "filterable": false, "sortable": false, "facetable": false },
 { "name": "content", "type": "Edm.String", "searchable": true, "filterable": false, "sortable": false, "facetable": false }
 ]
}

Also this will return a 201.

Create your indexer

Additionally to that index, we want to create an indexer. It will later automate the indexing process from your SharePoint library to the Azure Cognitive Search service.

Once again, we do this in Postman. This is a two-step process as we first need to POST a Create an indexer request - which will run and run and run as it is waiting for us to log in. So we will run a second call, which to GET the indexer status. This will return a devicecode with which we can can sign in - Once we did that we can see that the call returns a 200. After that, the POST will succeed and return a 201 as well.

So let’s do this together:

Create an indexer request

POST to https://<name-of-your Azure Cognitive Search service>.search.windows.net/indexers?api-version=2023-07-01-Preview
Params:
- api-version: 2023-07-01-Preview
Headers:
- Content-Type: application/json
- api-key: <the Admin key of your Azure Cognitive Search Service>
Body (Json):

{
 "name" : "sharepoint-indexer",
 "dataSourceName" : "sharepoint-datasource",
 "targetIndexName" : "sharepoint-index",
 "parameters": {
 "batchSize": null,
 "maxFailedItems": null,
 "maxFailedItemsPerBatch": null,
 "base64EncodeKeys": null,
 "configuration": {
 "indexedFileNameExtensions" : ".pdf, .docx",
 "excludedFileNameExtensions" : ".png, .jpg",
 "dataToExtract": "contentAndMetadata"
 }
 },
 "schedule" : { },
 "fieldMappings" : [
 {
 "sourceFieldName" : "metadata_spo_site_library_item_id",
 "targetFieldName" : "id",
 "mappingFunction" : {
 "name" : "base64Encode"
 }
 }
 ]
}

Once you post this, it will - as explained, wait for you to log in.

Get indexer status

GET to https://<name-of-your Azure Cognitive Search service>.search.windows.net/indexers/sharepoint-indexer/status?api-version=2023-07-01-Preview
Params:
- api-version: 2023-07-01-Preview
Headers:
- Content-Type: application/json
- api-key: <the Admin key of your Azure Cognitive Search Service>

No body needed :-)

This will return a response that contains an errormessage:

{

 "errorMessage": "To sign in, use a web browser to open the page https://microsoft.com/devicelogin and enter the code LFXXXXXP to authenticate.\r\nTo sign in, use a web browser to open the page https://microsoft.com/devicelogin and enter the code LFXXXXXP to authenticate.",
}

Copy the code and open the link, then paste the code into the devicelogin popup. Once you are logged in, you can close that browser tab again.

Check now in the Azure portal that you do not only have an index, but also an indexer and documents indexed.

Test your app in the Playground

The Azure OpenAI playground is a fabulous way to test and try out - so let’s do this

In the Playground, create a new deployment
Select Add your data and then Add a data source
Select the Azure Cognitive Search service, your Subscription its running in, and the index we just created. All of these will automagically 🪄 appear in the respective dropdown fields.
Now proceed with the index data field mapping - where you select all fields to be content
Save and close

You can now chat against your documents and ask the bot questions about it. By check/uncheck of the Limit responses to your data content you can determin whether you want the bot only to consider content from your documents or not.

You can now deploy this as a web app - Or you can walk with me some more steps and have that power in Power Apps or Power Automate

Make the magic happen in Power Apps

To connect to this API from a Power Apps, we will need to create a custom connector.

Following the Custom Connector wizard at make.powerapps.com:

General
- Host: <name-of-your-openai-service>.openai.azure.com
- Base URL: /openai/deployments/<name-of-your-deployment>

Security:
- Authentication type: API Key
- Parameter-label: api-key
- Parameter name: api-key
- Parameter location: Header

Definition
- General:
  - Summary: ChatCompletion
  - Description: ChatCompletion
  - Operation ID: ChatCompletion
- Request URL: https://<name-of-your-openai-service>.openai.azure.com/openai/deployments/<name-of-your-deployment>/chat/completions
- Body:

 {
 "dataSources": [
 {
 "type": "AzureCognitiveSearch",
 "parameters": {
 "endpoint": "https://<name-of-your-Azure-Cognitive-Search-service>.search.windows.net",
 "key": "<your Azure Cognitive Search service Admin key>",
 "indexName": "sharepoint-index",
 "semanticConfiguration": "",
 "queryType": "simple",
 "fieldsMapping": null,
 "inScope": true,
 "roleInformation": "you are an AI assistant that helps people find information"
 }
 }
 ],
 "messages": [
 {
 "role": "user",
 "content": "What is the answer to life, universe, and everything?"
 }
 ],
 "deployment": "<name-of-your-deployment>",
 "temperature": 0,
 "top_p": 1,
 "max_tokens": 800,
 "stop": null,
 "stream": false
 }

Test
- Connection:
  - Create a new Connection, provide the API for your Azure Open Ai service as api-key.
- Run your action, it should return a 200 response code and show a response to your question. Please note that with the inScope property you can limit the responses to just your documents.

You can now use this connector in either Power Apps or Power Automate.

What will you build with it?

How to add and remove owners from a Power Automate flow with CLI Microsoft 365

Mon, 13 Mar 2023 07:06:11 +0000

tl;dr

Using CLI Microsoft 365 you can easily add and remove owners of a flow.

Use Case

Let’s say, someone in your organization created a super cool Power Automate flow, but over time, this flow needs to be adjusted. Unfortunately, this super cool person is either on a long leave, doesn’t feel responsible anymore for that super cool flow after a nice promotion or left the organization. Too bad, that they were the only owner of that flow!

How to solve this

Power Automate

Of course there are many paths that lead to Rome: You could create a Power Automate flow to remove/add owners

which comes with the disadvantage, that you now need to manage this flow as well.

CLI for Microsoft 365

There is some really cool way though to manage owners of Power Automate flows: CLI Microsoft 365! I blogged about this awesome tool already quite a lot:

In their latest release v6.4.0.(beta) they introduced 3 new commands for Power Automate:

flow owner add
flow owner list
flow owner remove

which massively help with those typical Ooops we locked ourselves out of this crucial flow situations.

To benefit from these new commands, you need to first install the beta version with npm i -g @pnp/cli-microsoft365@next. After that is completed, have a look at the docs to see which information you will need to provide to add or remove an owner:

environmentName
flowName

To get these, we can again leverage the Power of CLI for Microsoft 365 with the command: m365 flow environment list -o text - which gives us a nice uncluttered overview on the environments:

Now let’s list the flows with

m365 flow list --environmentName Default-b469xxxx-xxxx-xxxx-xxxx-xxxxxxxxxxx --asAdmin -o text so that we get the flowName

With these 2 properties environmentName and flowName we will now feed the m365 flow owner add or m365 flow owner remove command:

m365 flow owner add -e Default-b469xxxx-xxxx-xxxx-xxxx-xxxxxxxxxxx -f xxxxxxxx-xxxx-xxxx-xxxx-f7621ad284de --userName "alexw@myDomain.onmicrosoft.com" --roleName CanEdit --asAdmin

and/or

m365 flow owner remove --userName adelev@myDomain.onmicrosoft.com -e Default-b469xxxx-xxxx-xxxx-xxxx-xxxxxxxxxxx -f Default-b469xxxx-xxxx-xxxx-xxxx-xxxxxxxxxxx --asAdmin

you can check the result with

m365 flow owner list --environmentName Default-b469e370-d6a6-45b5-928e-856ae0307a6d -f e6a2fbef-910a-4d53-ae8b-f7621ad284de --asAdmin -o text

or - if you assigned yourself as a new owner - even see it in the UI at make.powerautomate.com:

Some thoughts on governance

Well, some admonishing index finger ideas:

Please ensure proper governance for Power Platform - mission critical processes shouldn’t run in the context of a user who can always leave the organization. At least make sure, you have a 2nd owner to those flows - with CLI Microsoft 365, you can even automate this.

What’s next?

Well, as I love how CLI MIcrosoft 365 also enables us to manage Power Platform as well, I would be super interested in adding/removing owners from Power Apps as well?

Get started with CLI Microsoft 365 for Power Platform people

Mon, 19 Dec 2022 10:32:48 +0000

tl;dr

CLI for Microsoft 365 is an amazing tool to manage your Microsoft 365 tenant and SPFx projects. But did you know, that also people working with Power Platform can massively benefit from using it?

To convince you, I chose a use case, that will probably relate to lots of people, but please be aware, that CLI for Microsoft can do so much more!

Use case: App registrations in Azure Active Directory

Very often when working with Power Automate or Power Apps, we want to leverage the power of Microsoft Graph API. To do so, we need to authenticate against Graph using Azure Active Directory (Azure AD) and register an application in the Azure portal at portal.azure.com. Depending on permissions, redirect URI, secret etc. we need to perform several steps and take note of certain outputs. Wouldn’t it be nice if the entire app registration process was rather a one line command that automatically outputs the values we need?

After installing CLI Microsoft 365 and logging in, all we need to do is

m365 aad app add `
--name 'myApp001' `
--redirectUris 'https://global.consent.azure-apim.net/redirect' `
--platform web `
--withSecret `
--apisDelegated 'https://graph.microsoft.com/People.Read.All' `
--grantAdminConsent `

What this does is registering an application with the following parameters:

Displayname of the app is myApp001
Redirect URI is https://global.consent.azure-apim.net/redirect that is what you need for custom connectors in Power Platform
It does create a secret (and will output it)
It has delegated permissions for People.Read.All on Graph API
Admin consent is already granted

If we run this command (and we can do this as one-line as well without the backticks ` at the end of each line)

m365 aad app add --name 'myApp001' --redirectUris 'https://global.consent.azure-apim.net/redirect' --platform web --withSecret --apisDelegated 'https://graph.microsoft.com/People.Read.All' --grantAdminConsent

we get the following output:

{
 "appId": "164298a8-504c-4234-a43a-XXXXXXXXXXXX",
 "objectId": "02b7577e-4d6b-478a-b34c-XXXXXXXXXXXX",
 "tenantId": "b469e370-d6a6-45b5-928e-XXXXXXXXXXXX",
 "secrets": [
 {
 "displayName": "Default",
 "value": "XXXXX~5FUlgaKtYEAJ-XXXXX~DWsnj6yerYATXXX"
 }
 ]
}

which means, that we can use appId and the value of the secret in our custom connector or in the HTTP action of our Power Automate flow.

Get started with CLI for Microsoft 365

If you now want to try this out as well, you need to follow these steps:

Install node.js With node.js comes npm and we will install CLI for Microsoft 365 with npm. If you don’t have npm or node.js installed:
- Open node.js
- Select 18.12.1 LTS
- Install node.js
Install CLI for Microsoft 365
- Open a terminal of your choice, I use the built-in terminal of Visual Studio Code
- Type npm i -g @pnp/cli-microsoft365 to install CLI for Microsoft 365 globally
Login
- To login, type m365 login
- You will see a message like this: "To sign in, use a web browser to open the page https://microsoft.com/devicelogin and enter the code BAVUYWLZ3 to authenticate." - Do exactly that. Copy that code, open the URL and paste the code.
- Select Next

Now log into the tenant you want to connect with using your username and password (+ optional MFA)

You can close the https://login.microsoftonline.com/common/oauth2/deviceauth page again

💡 Until you type m365 logout, you will stay logged in.

Try out to register an app

Now lets see if that worked! Register your own application and validate in the Azure portal.

Tell people on twitter about it - https://twitter.com/intent/tweet?text=I%20used%20%23CLIMicrosoft365%20to%20register%20an%20app%20in%20%23AzureAD%20and%20it%20worked%20like%20a%20charm%21%20-%20%0D%0A%0D%0ARead%20%40LuiseFreese%20s%20blog%20post%20about%20it%20here%3A+https%3A%2F%2Fm365princess.com%2Fblogs%2Fcli-microsoft-365-power-platform

Feedback and what’s next?

If you liked this experience, maybe you want to dip your toes even a bit further into CLI for Microsoft 365 - here is why you should absolutely consider that:

it’s open-source and we are all here to learn
it’s an amazing project with the most awesome contributors
it has a lot of super-helpful commands around Power Apps, Power Automate, and more in Power Platform - more to come! Any ideas?

Let me know on twitter :-)

Intro to custom functions in Power Apps

Mon, 12 Dec 2022 09:33:44 +0000

tl;dr

Custom functions are a great way to make code reusable in Power Apps. By also leveraging Power Apps component libraries we can use the same code across apps in the environment.

Once there was a time…

when we all started with Power Apps and realized, that all logic in the app is done by calling pre-built functions like CountRows(Inventory). With increased complexity of our apps, we sometimes combined and nested these functions and did some pretty cumbersome calculations in order to get the job done - unfortunately over and over again.

DRY

In traditional programming there is a rule called DRY which stands for Don’t repeat yourself. It means, that you should never have to maintain the same code snippets in several places… You update 5 and forget the 6th instance. This leads to nightmares when developing, maintaining, debugging.

To tackle this in traditional languages, we first define a function and then call it where needed, so that we have a single source of truth. This reduces debugging time and increases developer productivity.

Now what if we could do the very same thing in Power Apps? Instead of copy-pasting code snippets in one app or even across apps ("oh wait, I already solved tis problem in another app"), we could create a parameterized function in a central repository, that we could call from any app.

How to create a custom function

Custom functions are custom properties of components, instead of providing a consistent look & feel of UI elements, they allow makers to reuse code snippets. As all components, they should be stored in component libraries. A component library is a special type of canvas app with the purpose to hold your components in one place, again following the principle of DRY.

Create a component library

Open make.powerapps.com
Make sure that you are in the environment you want to use the components/custom functions in
Select Apps
Select Component libraries
Select New component library
Type a name like Custom functions
Select Create

Enable enhanced component properties

As this feature is not GA’ed yet, we need to enable it in the experimental feature section in settings:

Select Settings
Select Upcoming features
Select Experimental
Type the first letters of components into the search bar
Switch the toggle of Enhanced component properties to true
Close the settings again

Create a dateFunctions component

Select Components
Rename Component1 to something like dateFunctions
Resize the component to Width and Height: 0 - we don’t need ANY UI for this

We will group all functions, that are related to dates in this component.

Create a new custom property (that is our function!)

Select New custom property
Type getQuarter as DisplayName
Set Property type to Output - as we want to output a value
Set the Data Type to Number - as we want to return a number (it shall be either 1,2,3, or 4 for the 4 quarters in a year)
Select New parameter
Type myDate as Parameter Name
Select Date & Time as Parameter Type (as we will be providing a date)
Check the Required checkbox.
Select Create

If you can’t see the New parameter link, go back to Enable enhanced component properties and follow instructions :-)

Now let’s add some code to our new function. You will notice your newly created property getQuarter in the dropdown menu:

Put the following code:

If(
Month(myDate) <= 3,
1,
Month(myDate) >= 4 && Month(myDate) <= 6,
2,
Month(myDate) >= 7 && Month(myDate) < 9,
3,
Month(myDate) >= 10,
4
)

As you can see, this function takes myDate, which needs to be of type Date and time as an input and outputs the respecting quarter as a number.

Try out your component

In this component library, you also have screens, but they are only there to test your components, not to be used as apps.

Select Screens
Select + Insert
Under Custom select dateFunctions - by this you add the component the screen
Insert a datepicker control DatePicker1
Insert a textlabel
Set the Text property of the label to dateFunctions_1.getQuarter(DatePicker1.SelectedDate)
If you now change the value of the datepicker, you will see different values in the textlabel - showing the quarter of the date.

Please note the _1 in the component instance 💡

Please publish your component library to make it available in the environment.

The beautiful thing about that is, that you can now consume this function in any app - while the component itself will live and be edited only in the component library. This means that we have our single source of truth and that we enable more people to use code-snippets.

Consume your component in another app

Let’s now consume our brand new function in a canvas app in the same environment. Either open an existing app or create a new one.

Select + Insert
Select Get more components
After your component got imported, you should see this message:
Now add the component to a screen by selecting dateFunctions under Library components
Now use the component in your app like you tried before in the component library.

Feedback and whats next?

You can now add more custom properties to your dateFunctions component, for other code snippets that you would like to reuse across apps.To do that, create a new custom property and define its parameters. To make it easier for you, you can kickstart your own custom functions component library with my open-source component library:

custom functions repo

Let me know what you think on twitter :-)

How to add Azure AD directory extensions

Fri, 09 Dec 2022 17:31:01 +0000

tl;dr

If you want a a queryable extension experience for objects in Azure AD, you can achieve that by first creating the extension definition and then associate that new extension to an object. You can now GET and PATCH the new extension via your applications ins the same tenant and even expose the new extension with a custom connector to Power Platform.

Use case

I wanted to build a Microsoft Graph toolkit lookalike person card, but noticed, that there is an attribute missing, that I’d love to include: pronouns. Turned out, that even in 2022, pronouns are not available by default in the user object in Azure Active Directory and my aim was to not just have pronouns of some people in one application, but expose the pronouns to any application in the tenant.

Create a directory extension definition

To create a directory extension definition, we need to send a POST request to https://graph.microsoft.com/v1.0/applications/<app object id>/extensionProperties, which means, that we need to register an app for that.

Register an application in Azure AD

You can register an app either in the Azure Portal or with this one-line-command in CLI for Microsoft 365:

m365 aad app add --name 'GraphConnector-App' --withSecret --apisApplication 'https://graph.microsoft.com/Directory.ReadWrite.All' --grantAdminConsent

Use Graph Explorer to create the extension

Now we can log ino Graph Explorer and do a POST to

https://graph.microsoft.com/v1.0/applications/<app object id>/extensionProperties

while replacing the <app object id> (not the app id!) with your app object id.

The body of the request is:

{
 "name": "pronouns",
 "dataType": "String",
 "targetObjects": [
 "User"
 ]
}

This means, that we want to create an extension called pronouns and associate this with the user object.

As a response, we will get something like

{
 "@odata.context": "https://graph.microsoft.com/v1.0/$metadata#applications('4e3dbc8f-ca32-41b4-825a-346215d7d20f')/extensionProperties/$entity",
 "id": "53645e93-9bad-4cfa-938c-eebaaa84d89f",
 "deletedDateTime": null,
 "appDisplayName": "GraphConnector",
 "dataType": "String",
 "isSyncedFromOnPremises": false,
 "name": "extension_8ceab131804c47278376509101e201c3_userPronouns",
 "targetObjects": [
 "User"
 ]
}

You can see, that we have a new property name with a value extension_8ceab131804c47278376509101e201c3_userPronouns

This new property can now be used from any application in your tenant

This value always follows the pattern extension_{appId-without-hyphens}_{extensionProperty-name}

Make a note of this value somewhere.

Patch a user with the new property

Now we can use a PATCH to https://graph.microsoft.com/v1.0/users/{userId}

with a body

{"extension_8ceab131804c47278376509101e201c3_userPronouns": "she/they"}

Check if the new property is in place

Of course we want to check if it worked, so we will do a GET to https://graph.microsoft.com/v1.0/users/{userId}?$select=displayName, extension_8ceab131804c47278376509101e201c3_userPronouns

It is required to select the new property in the GET request, otherwise it won’t be returned.

Create a custom connector for Power Platform

Now that we created the extension and know how to patch and get data, we can build a custom connector so we can expose the functionality in Power Platform.

GET request

You can follow steps create the custom connector, but instead of adding a GetPeople action, add a GetUsers action:

Select Definition
Select New action
Type in GetUsers as Summary, Description, and Operation ID
Under Request, select Import from sample
Select GET as Verb
Type https://graph.microsoft.com/v1.0/users/{userid}$select=displayName, extension_8ceab131804c47278376509101e201c3_userPronouns as URL (remember, it’s the same URL we used in Graph explorer, please replace the extension property)
Select Import
Under Response, select Add default response
Paste in the response you got from Graph Explorer in the Body field
Select Import
Select Update Connector
Select Test
Select New Connection
Select Create - you will annoyingly be redirected to the connections overview - go back to your custom connector
Select Test operation - you should receive a HTTP response 200
Select Close

PATCH request

For the PATCH request, add another action to your custom connector:

Select Definition
Select New action
Type in PatchPronouns as Summary, Description, and Operation ID
Under Request, select Import from sample
Select PATCH as Verb
Type https://graph.microsoft.com/v1.0/users/{userid} as URL (remember, it’s the same URL we used in Graph explorer, please replace the extension property )
Type in the Body

{
"extension_8ceab131804c47278376509101e201c3_userPronouns": "she/they"
}

Select Import
Under Response, select Add default response
Paste in the response you got from Graph Explorer in the Body field
Select Import
Select Update Connector
Select Test
Select New Connection
Select Create - you will annoyingly be redirected to the connections overview - go back to your custom connector
Select Test operation - you should receive a HTTP response 204
Select Close

We can then set the Text of a text label to

GraphConnector.GetUser(<userId>,{'$select':"displayName, extension_8ceab131804c47278376509101e201c3_userPronouns"}).extension_8ceab131804c47278376509101e201c3_userPronouns to display the pronouns of a certain user and set the OnSelect of a button to

GraphConnector.PatchPronouns(<userId>,{extension_8ceab131804c47278376509101e201c3_userPronouns:"she/they")

Back to my app idea…

Following my idea to re-create Microsoft Graph toolkit components as Power Apps canvas components I did a more inclusive person card component - with pronouns.

Feedback and whats’s next

What do you think? Which custom fields would you like to expose? Let me know on twitter. I will blog about how to create the component (and open-source it) in the next post.

Microsoft Graph toolkit people-picker lookalike for Power Apps

Mon, 05 Dec 2022 14:54:59 +0000

tl:dr

Microsoft Graph toolkit is a collection of reusable components for accessing and working with Microsoft Graph API - However, we can’t use them in Power Apps, which is why I started to build a Microsoft Graph toolkit (MGT) lookalike component library for Power Apps. The people-picker component looks like this in action:

People-Picker

The MGT people picker is one of the most powerful components - it connects directly to your Azure Active Directory and shows your co-workers, which you can then select from. To make this work in a Power Apps canvas app, we need a few things:

Power Platform custom connector to Microsoft Graph API

requires an app registration in Azure Active Directory
makes this approach reusable

UI in Power Apps

works best as a component as you will want to re-use this
shall adapt to different themes in Teams

Power Platform Custom Connector

Understand the /me/people endpoint

Let’s first understand what our custom connector will do. We will want to leverage the https://graph.microsoft.com/v1.0/me/people endpoint in our people picker to display people we work with - if you are unfamiliar with this, you can try out this query in Microsoft Graph explorer. To execute this, Graph Explorer needs permission for People.Read or People.Read.All.

It will return an object also containing an array with users, following this schema

{
 "@odata.context": "https://graph.microsoft.com/v1.0/$metadata#users('2607b77e-22c4-4081-b278-a9516da4accd')/people",
 "@odata.nextLink": "https://graph.microsoft.com/v1.0/me/people?$skip=0",
 "value": [
 {
 "id": "7af3431f-ee68-4559-a1ca-17dc7bfcc269",
 "displayName": "Alex Wilber",
 "givenName": "Alex",
 "surname": "Wilber",
 "birthday": null,
 "personNotes": null,
 "isFavorite": false,
 "jobTitle": "Marketing Assistant",
 "companyName": null,
 "yomiCompany": null,
 "department": "Marketing",
 "officeLocation": "131/1104",
 "profession": null,
 "userPrincipalName": "AlexW@hscluise.onmicrosoft.com",
 "imAddress": "sip:alexw@hscluise.onmicrosoft.com",
 "scoredEmailAddresses": [
 {
 "address": "AlexW@hscluise.onmicrosoft.com",
 "relevanceScore": 1111,
 "selectionLikelihood": "notSpecified"
 }
 ],
 "phones": [
 {
 "type": "business",
 "number": "+1 858 555 0110"
 }
 ],
 "personType": {
 "class": "Person",
 "subclass": "OrganizationUser"
 }
 },
 {...}
 ]
}

App registration

As our connector will need to authenticate, we will register an application in Azure Active Directory (AAD) as our identity provider. This means, that we will let AAD generate a username/password combination (client id and client secret) and equip that with permissions needed to call /me/people endpoint: People.Read or People.Read.All.

To do that, you can either

Open portal.azure.com
Select Azure Active Directory
Select Add, then App registration
Enter a name for your app - choose something like GraphConnector-App
Select Accounts in this organizational directory only
Select Register
Select Overview and copy Directory (tenant) ID and Application (client) ID - we will need these later
Select Certificates & secrets
Select New client secret
Select Add
Save the value of this secret somewhere - we will need this later
Select Permissions
Select Microsoft Graph
Select Delegated permissions
Select People.Read or People.Read.All
Select Add permissions
Select Grant admin consent for
Select Yes

or if you use CLI for Microsoft 365 you can register your app including permissions, granting admin consent and generating a secret with this command:

m365 aad app add --name 'GraphConnector-App' --redirectUris 'https://global.consent.azure-apim.net/redirect' --platform web --withSecret --apisDelegated 'https://graph.microsoft.com/People.Read.All' --grantAdminConsent

This will output something like this:

{
 "appId": "XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX",
 "objectId": "XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX",
 "tenantId": "XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX",
 "secrets": [
 {
 "displayName": "Default",
 "value": "XXXXX~-XXXXXXXXXXXXXXXXXXXX_XXXXXXXXXXX"
 }
 ]
}

Save the value of appId and secretsomewhere.

Create the custom connector

Open make.powerapps.com
Select Dataverse
Select Custom Connectors
Select New custom connector
Select Create from blank
Type in a name like GraphConnector
Select Continue
Type in graph.microsoft.com as Host

Select Security
Choose OAuth 2.0 as Authentication type
Choose Azure Active Directory as Identity Provider
Paste your appId from Azure AD app registration as Client Id
Paste your client secret from Azure AD app registration as Client secret
Notice that Login URL is already set to https://login.windows.net - don’t change
Notice that Tenant Id is set to Common - don’t touch this
Type in https://graph.microsoft.com as Resource URL
Notice that Enable on behalf of login is set to false - don’t change
Type in People.Read.All as Scope
Select Create connector

Add a GetPeople action

Now that we have a custom connector, we want to add at least one action to it.

Select Definition
Select New action
Type in GetPeople as Summary, Description, and Operation ID
Under Request, select Import from sample
Select GET as Verb
Type https://graph.microsoft.com/v1.0/me/people as URL (remember, it’s the same URL we used in Graph explorer)
Select Import
Under Response, select Add default response
Paste in the response you got from Graph Explorer in the Body field
Select Import
Select Update Connector
Select Test
Select New Connection
Select Create - you will annoyingly be redirected to the connections overview - go back to your custom connector
Select Test operation - you should receive a HTTP response 200
Select Close

UI in Power Apps

Now that we have the connector working, let’s

create a Power Apps canvas app using a theme that reflects default, dark, high-contrast mode in Microsoft Teams
create a reusable canvas component as the people-picker

For all lovers of dark-mode: here is a little motivation to keep reading this post. This is what the people-picker will look like in dark mode in Microsoft Teams:

Create an app

Create a new app
Save it locally
Unpackage the app via Power Platform CLI
Select the themes.json file
Replace its content by FluentUI for Teams theme
Package the app again via Power Platform CLI
Open the app from within Power Apps Studio
Add a Dropdown control drp_theme
Set its Items property to ["default", "dark", "high-contrast"]
Set the OnChange of the dropdown and the OnStart property of the App to the content of this file

Now you have an app that reflects the 3 themes of Microsoft Teams. It will automatically adjust to the theme that is used in the Teams client. For development and test purposes, you can use the dropdown to switch to another theme.

Add the custom connector

Now add the custom connector on the Data tab to your app. Once you did that, select the OnVisible of a screen and create a collection that contains people you work with:

ClearCollect(
colPeople,
Filter('GraphConnector'.GetPeople().value, personType.subclass = "OrganizationUser")
);

Add the Office 365 Users connector

Add this built-in connector to easily retrieve Profile pictures of people

Create a canvas component

Create a new component cmp_MGT_PeoplePicker
Enable Access app scope

Let’s now understand what the people-picker is built:

We will deal with two collections:

colPeople - which contains the people our custom connector returns
colAttendees - which contains only people that a user selected from the colPeople

Both collections will be reflected in two galleries - gal_People and gal_Attendees
Both collections work exclusively, this means, that a user, who is in colPeople, can’t be in colAttendees and the other way around, as it wouldn’t make any sense to select a person twice
A textinput control allows a user to type in a name they want to add
A Chevron down icon allows a user to expand the entire colPeople
A X icon allows a user to delete all items from the colAttendees collection

1 - textinput which filters the galPeople
2 - x icon which resets the textinput
3 - gal_People
4 - gal_Attendees
5 - Chevron down to expand/collapse gal_People

Textinput

Add a TextInput txt_input
Set it’s HintText to "Start typing a name"
Set its Default to ""
Set its OnSelect to If(IsEmpty(Self.Text), Set(isGallery, false), Set(isGallery, true))
Take care of colors:

BorderColor: gblAppStyles.TextInput.BorderColor,
Color: gblAppStyles.Label.Color
Fill: gblAppStyles.TextInput.Fill,
FocusedBorderColor: Self.BorderColor,
HoverBorderColor: gblAppStyles.TextInput.BorderColor,
HoverColor: gblAppStyles.Label.Color,
HoverFill: Self.Fill,
PressedColor: Self.Color
PressedFill: Self.Fill

Rectangle

we will now add a rectangle below the textinput to create that Teams look & feel

Fill: gblAppStyles.ButtonPrimary.BorderColor
Height: 2
Width: txt_input.Width
X: txt_input.X
Y: txt_input.Y+ txt_input.Height

gal_people

Create a blank vertical gallery
Set its Items to Sort(Filter(colPeople,StartsWith(displayName, txt_input.Text )),displayName, Ascending)
Set Height to CountRows(colPeople)*(Self.TemplateHeight+ Self.TemplatePadding)
Set Width to txt_input.Width-txt_input.X*2
Set Visible to isGallery
Add an image to the gallery
Set

X to 10
Y: (Parent.TemplateHeight / 2) - (Self.Height / 2)
Width and Height: 32
Image to If(!IsBlank(ThisItem.userPrincipalName),Office365Users.UserPhoto(ThisItem.userPrincipalName),SampleImage)

Add a textlabel to the gallery

Set Color to gblAppStyles.Label.Color
Set HoverFill to gblAppStyles.TextInput.HoverFill
Set Width to Parent.TemplateWidth and Height to Parent.TemplateHeight
Set Text to ThisItem.displayName
Set the OnSelect to

Collect(
colAttendees,
{
type: "required",
emailAddress: {
name: gal_people.Selected.displayName,
address: gal_people.Selected.userPrincipalName
}
}
);
Remove(
colPeople,
ThisItem
);
Reset(txt_input)

With that, we add people from our colPeople to our colAttendees and remove them from the colPeople. We also reset the textinput.

Chevron down

Add an image and set its Image to

"data:image/svg+xml;utf8, " & EncodeUrl(
"
<svg width='48' height='48' viewBox='0 0 48 48' fill='" & If(
gblThemeHiCo,
"#ffffff",
gblThemeDark,
"#ffffff",
"#252423"
) & "' xmlns='http://www.w3.org/2000/svg'>
<path d='M8.36612 16.1161C7.87796 16.6043 7.87796 17.3957 8.36612 17.8839L23.1161 32.6339C23.6043 33.122 24.3957 33.122 24.8839 32.6339L39.6339 17.8839C40.122 17.3957 40.122 16.6043 39.6339 16.1161C39.1457 15.628 38.3543 15.628 37.8661 16.1161L24 29.9822L10.1339 16.1161C9.64573 15.628 8.85427 15.628 8.36612 16.1161Z' />
</svg>
"
)

This is the Fluent UI chevron down and it will now reflect the different themes.

Set the OnSelect to

Set(isGallery, !isGallery);
If(
CountRows(colPeople) = 0,
ClearCollect(
colPeople,
Filter('GraphConnector'.GetPeople().value, personType.subclass = "OrganizationUser")
)
);

This controls how much we see from the gallery and also refreshes the colPeople when a user expands the gallery

gal_Attendees

We need another gallery to show the selected people

Add a blank vertical gallery
Set

X: 5
Y: txt_input.Y+ txt_input.Height
Items: If(isGallery,FirstN(colAttendees,6),FirstN(colAttendees,3))
WrapCount: If(isGallery,If(CountRows(colAttendees)<4,1,2),1)
Height: If(isGallery,If(CountRows(colAttendees)<4,txt_input.Height*1,If(CountRows(colAttendees)<6,txt_input.Height*2),txt_input.Height*2),40)

This makes sure, that we wrap items dynamically and adjust the Height of the gallery depending on how many items are selected. This still leaves a little problem - as there is not a lot of space where we can display all people in the gal_Attendees and we already limited this to either showing 3 (when collapsed) or 6 (when expanded), we should indicate, that there are more people added.

The ‘more’ pill

Outside of the gallery, add a new button btn_plus

X: 3*(gal_attendees.TemplateWidth)+10
Y: gal_attendees.Y + (gal_attendees.TemplateHeight-Self.Height)/2
Width: 40 and Height: 32
Text: "+" &If(isGallery, CountRows(colAttendees)-6, CountRows(colAttendees)-3)
DisplayMode: View
Radius: 1000
Visible If(isGallery,CountRows(colAttendees)>6,CountRows(colAttendees)>3)

By that, we display this button only if we have more than 3 (collapsed) or more than 6 (expanded) and show the number of items in the collection (minus the items that are already shown)

Now let’s fill the gallery with people we selected from the colPeople:

Add a button btn_pill

Set its Displaymode to View
Fill: gblAppStyles.TextInput.HoverFill
Width: 150 and Height: 32
Radius: 1000

Add an image img_profilePic

Set Image to If(!IsBlank(ThisItem.emailAddress.address),Office365Users.UserPhotoV2(ThisItem.emailAddress.address),SampleImage)
X: btn_pill.X + 5, and Y: btn_pill.Y + (btn_pill.Height - Self.Height)/2
Width: 20, and Height: 20
Visible: CountRows(colAttendees) >0

Add a textlabel lbl_displayName

Set Text: ThisItem.emailAddress.name
X: img_profilePicture.X + img_profilePic.Width
Width: btn_pill.Width - img_profilePicture.Width - icn_close.Width-20 and Height: 20
Set: Visible: CountRows(colAttendees) >0

Add an icon icn_close

X: btn_pill.X + btn_pill.Width-Self.Width-10 and Y: btn_pill.Y + (btn_pill.Height - Self.Height)/2
Width and Height: 12
Onselect

Remove(colAttendees,ThisItem);Collect(colPeople,{userPrincipalName:ThisItem.emailAddress.address,displayName:ThisItem.emailAddress.name})

With this we allow users to remove a person from the colAttendees and add them again to the colPeople.

The X icon

Now let’s add an X icon icon_removeAttendees so that a user can remove all people at once from the colAttendees and start all over again

OnSelect: Clear(colAttendees);ClearCollect(colPeople,'ProductivityHub-Connector'.GetMyPeople().value);Reset(txt_input)
X: gal_attendees.X +gal_attendees.Width-20
Y: txt_input.Y+ (txt_input.Height - Self.Height)/2
Height and Width: 16

Some more context

This component is part of an app - here is the real world use case: Finding meeting times for multiple colleagues.

This app is inspired by Waldek Mastykarz who created a similar app with Microsoft Graph toolkit. You can find his blogpost here.

Get the people-picker

You followed through but would just love to get this component? Don’t fret, I got you covered. Its the first component of an entire library (so this will be updated) and you get it here on GitHub

Please follow the steps under Create an app so that you get the themes working in your app.

Import the component

Import the component library into your environment
In your app, select the + icon on the left bar
Select get more components
Choose the MGT components
Select cmp_MGT_pp
Select Import

Add the component to your app

Select the + icon on the left bar
Expand the section Library components
Select the cmp_MGT_pp

This adds the component to the screen - but it looks ugly and full of bugs - let’s fix the colors

Right-click on the component
Select Edit component - you will be prompted with a dialogue that you need to create a local copy -
Select Create a copy

Select Components on the left menu
Select your new component
Switch the Access app scope toggle to off and then to on again (yes, I know 🙄)
Select Screens on the left menu
Select + icon onm the left bar
⚠️ Resist the urge to expand the Library components section - remember? We created a copy, which sits right in our app 💡
Expand Custom - you will find your copy there
Select it - it will be added to your screen
Either expand/collapse the galPeople by clicking on the Chevron or navigate from the screen and to it again so that the galPeople gets populated with the colPeople`

Feedback & What’s next

What do you think? Is this people-picker helpful? Which other Microsoft Graph toolkit component shall I rebuild next? Let me on on twitter

How to make a auto-height textinput component for Power Apps

Wed, 05 Oct 2022 16:53:24 +0000

Some controls in Power Apps do not have an auto height property, which means that we can’t get the Height of a control to automagically ✨ adjust to its content. Especially for the textinput control, this is a real bummer, as we a user’s input a pretty much unpredictable. On the one hand, we do not want to waste precious screen estate by making the box as big as possible, on the other hand, a too small box will result in an endless scrollbar which is a bad user experience.

Build a component with me

If you follow my blog posts then you might know that I love to componentize everything that I’d like to use again, and an auto-height textinput seems to tick that box as well.

Open make.powerapps.com
Create a new component cmp_textinput
Create a custom input property outsideMargin (Number), 20 - determines the margin around the component
Create a custom output property userText (Text), txt_userInput.Text so that we can pass this value back to our app

Make magic work

Insert a text label lbl_autoHeightHelper and a textinput txt_userInput
Make sure that the textinput sits on top
Set the Mode of the textinput to Multiline
Set the X and Y of the textinput to cmp_textinput.outsideMargin
Set the Width of the textinput to cmp_textinput.Width-2*cmp_textinput.outsideMargin - this makes sure, that when you horizontally resize the component, this also applies to the textinput as well
Set Height of the textinput to Max(42, lbl_autoHeightHelper.Height)
Set the Text of the text label to txt_userInput1.Text
Set X of the text label to txt_userInput1.X and Y to txt_userInput1.Y
Set Width of the text label to txt_userInput1.Width
Set the Height of the text label to cmp_textinput.Height-2*cmp_textinput.outsideMargin
Set the auto height of the text label to true
Set the Color of the text label to Transparent
For the text label, set Font to txt_userinput.Font, FontWeight to txt_userinput.FontWeight, and Size to txt_userinput.Size
Set the Width of the textlabel to txt_userInput.Width and the Height to Max(42, lbl_autoHeightHelper.Height)

Understand the magic

We utilize the auto height property of the text label and hook it to the Height property of the text input. The text label will get exactly the text in the Font, Size, FontWeight of the textinput, but as we set the Color to Transparent, it won’t show up.
For the Width of the text input, we reference the width of the component itself so that we can make the textinput as wide as necessary by adjusting the size of the component instance in an app
The Max(42, lbl_autoHeightHelper.Height) for the Height of the textinput ensures that we always have 42 as a minimum Height and the Height of the text label (which has auto height enabled) as maximum Height

Feedback and what’s next

That’s it!

a little hack to bring auto-height to controls that don’t come with it out of the box. Let me know what you think on twitter.

Maybe you could spot in the screenshot above, that I added some more cool features to my component, such as a trailing icon (delete, error), a label, an asterisk. a helper and an error text, and an indicator of how many characters are still left. This is a sweet sneak preview on a Material design component library that I am building together with my dear friend and partner in crime Robin Rosengrün.

Series: Build Power Apps that don't look like Power Apps - Material Design part 2

Sun, 04 Sep 2022 10:17:47 +0000

For real, your low code apps don’t need to look like as if design wasn’t important. I hear lots of people say, that they suck at design or don’t have an eye for good UX. But a visually appealing UI is not the cherry on the cake but one of the core tasks of everyone who builds apps. Let me guide you step by step how you can improve your design skills - we will be again leveraging Google’s Material Design system. This is part 2 of How to build Power Apps - that don’t like Power Apps. If you didn’t read part 1 yet, this is your chance to catch up :-)

Why do we use Material Design? It’s

goodlooking
well documented
widely used

Also: If we can build Google/Android look-a-like apps with Microsoft Power Apps, we can build everything :-)

This blog post focuses on how to create those beautiful Material Design quilted image lists in Power Apps galleries.

This is the schema that we are aiming for: it consists of 4 types of rows which hold different amount of images in different widths and x positions.

Create a component

Let’s do this properly and create a canvas component cmp_MD_Gallery with the following custom properties:

singleImageWidth: 200
imagePadding: 10

Now let’s take care of how to feed our gallery. Create an additional custom property galleryContent in the component of type Table:

Table(
//row 1, 3 images
{
id: 1,
image: "<link to your image goes here>",
width: cmp_MD_Gallery.singleImageWidth
},
{
id: 2,
image:"<link to your image goes here>",
width: cmp_MD_Gallery.singleImageWidth
},
{
id: 3,
image:"<link to your image goes here>",
width: cmp_MD_Gallery.singleImageWidth
},
// row 2, 2 images (1st 2/3, 2nd 1/3)
{
id: 4,
image: "<link to your image goes here>",
width: 2 * (cmp_MD_Gallery.singleImageWidth) + cmp_MD_Gallery.imagePadding
},
{id: 5},
{
id: 5,
image: "<link to your image goes here>",
width: cmp_MD_Gallery.singleImageWidth
},
//3rd row - 1 image
{
id: 6,
image: "<link to your image goes here>",
width: 3 * (cmp_MD_Gallery.singleImageWidth) + 2 * ( cmp_MD_Gallery.imagePadding)
},
{id: 7},
{id: 8},
//4th row - 2 images (1st 1/3, 2nd 2/3)
{
id: 7,
image: "<link to your image goes here>",
width: cmp_MD_Gallery.singleImageWidth
},
{
id: 8,
image: "<link to your image goes here>",
width: 2 * (cmp_MD_Gallery.singleImageWidth) + cmp_MD_Gallery.imagePadding
},
{id: 9},
//5th row - 3 images
{
id: 9,
image: "<link to your image goes here>",
width: cmp_MD_Gallery.singleImageWidth
},
{
id: 10,
image: "<link to your image goes here>",
width: cmp_MD_Gallery.singleImageWidth
},
{
id: 11,
image: "<link to your image goes here>",
width: cmp_MD_Gallery.singleImageWidth
},
//6th row -rest
{
id: 12,
image: "<link to your image goes here>",
width: cmp_MD_Gallery.singleImageWidth
},
{
id: 13,
image: "<link to your image goes here>",
width: 2 * (cmp_MD_Gallery.singleImageWidth) + cmp_MD_Gallery.imagePadding
}
)

As you notice, we leave some items blank to make room for items that span the width of two items.

Create a gallery

Create a vertical gallery, set its Width to Parent.Width, its Height to 1000, its TemplateSize to 300
Set the the Items to cmp_MD_Gallery.galleryContent
Insert an image into the gallery, set its Height to Parent.TemplateHeight
Set the Image property of the image to ThisItem.image
Set the Width property of the image to ThisItem.width

Create the invisible scrollbar

If you want to create an invisible scrollbar

add a vertical slider on top of the gallery, set its Max to 0 and its Min to -1000, and its Height to Gallery1.Height
Set all its colors to Transparent to make it disappear, but don’t set Visible to false (Users can’t interact with a control that has that setting)
Set the Y of the Image to Slider1.Value - boom, done 🚀

You can set the Width of the slider and the Size of the Handle to the Width of the gallery if users shall use the entire gallery width to scroll or you can limit this and give them a visual cue (a button, circle, etc) so that they know that they can scroll here.

Feedback and what’s next

As you can see, its relatively easy to create an engaging UX in Power Apps. When discussing this with the Math & SVG magician Robin Rosengrün, he found an even more elegant way to calculate widths and x positions of each image, hope he records a video on that soon - #TeamWorkMakesTheDreamWork

Would you try this gallery in your Power Apps? Let me know what you think on twitter.

Next blog post in this series is how to create basic UI elements that you will love.

Series: Build Power Apps that don't look like Power Apps - Material Design part 1

Tue, 23 Aug 2022 12:17:47 +0000

One of my most important goals when developing Power Apps is good design. But for me,

Design is not just pretty looks or some stunning effects, but it is how things work.

This means that a well designed app makes people feel related, understood, comfortable and easily experienced. People will want to use the app again and again.

Looking at the typical look of Power Apps, I don’t feel that these are well-designed in term of increasing usability, being visually appealing, or blending into the context they probably live in. This highly functional look shall convey the message, that people will get something working without putting too much effort into it. And that then leads to that perception, that low-code equals low standards in terms of design.

This is the first part of a little series that illustrates, how we can develop Power Apps, that don’t look like Power Apps. I will use Google’s Material design system to showcase this. If you are looking into some Microsoft Fluent UI guidance - I blogged about good looking apps for Teams here.

Floating Action Button (FAB)

The Floating Action Button (FAB) is a design concept, that we can find in all kinds of mobile apps, for example Twitter mobile app, Outlook mobile app, and mny, many more. We say its floating, as it doesn’t sit in a dedicated navigation area, but floats right on top of most probably scrolling content. Once that FAB is selected, it show some more related buttons that allows users to perform related actions.

How to build a FAB in Power Apps

To make this FAB as flexible and reusable as possible, we will create a canvas component cmp_MD_Fab. Set its Width to 100 and its Height to 380. Our Fab will consist of

Overview

1 button btn_primary with two icons icon_start and icon_close
3 btn_secondary, btn_tertiary, btn_quarternary with 3 corresponding icons icon_secondary, icon_tertiary, icon_quarternary
4 timers timer1, timer2, timer3, timer4

Add these to your component - we will style them in a few.

Custom properties

We will create the following custom properties

timerDuration (Number), defaults to 300, determines the Duration of all timers
button1Fill (Color), defaults to Black, determines Fill of btn_primary
button2Fill (Color), defaults to ColorValue("#4F1FDC"), determines Fill of btn_secondary
button3Fill (Color), defaults to ColorValue("#9964f4"), determines Fill of btn_tertiary
button4Fill (Color), defaults to ColorValue("#BB8cF4"), determines Fill of btn_quarternary
iconStart (Image), defaults to Icon.Add, determines the Icon of icon_Start
iconClose (Image), defaults to Icon.Cancel, determines the Icon of icon_Close
icon2 (Image), defaults to Icon.People, determines the Icon of icon_secondary
icon3 (Image), defaults to Icon.Bookmark, determines the Icon of icon_tertiary
icon4 (Image), defaults to Icon.Crop, determines the Icon of icon_quarternary
iconColor (Color), defaults to White, determines the Color of all icons
button2OnSelect (Behavior, boolean), defaults to true, determines the OnSelect of btn_secondary
button3OnSelect (Behavior, boolean), defaults to true, determines the OnSelect of btn_tertiary
button4OnSelect (Behavior, boolean), defaults to true, determines the OnSelect of btn_quarternary

and assign them as stated above. Example: Select all timers, select the Duration property for them, set it to cmp_MD_FAB.timerDuration. Proceed with all other custom properties like that.

The buttons

We will now take care of the buttons. Select all of them and set their

Width to 56, Height to Self.Width and Radius to Self.Width. - We now have circle buttons!
BorderColor, HoverBorderColor, PressedBorderColor, HoverFill to Self.Fill
Text to ""

Now only select the btn_primary and set its X to (Parent.Width-Self.Width)/2 and its Y to Parent.Height-Self.Height-10. After that is done, select all other buttons and set their X to btn_primary.X.

The Icons

Set Width of all icons to 32 and Height to Self.Width Set X of all icons to btn_primary.X+ (btn_primary.Width-Self.Width)/2 Set Y of btn_secondary to btn_secondary.Y+ (btn_secondary.Height-Self.Height)/2 Set Y of btn_tertiary to btn_tertiary.Y+ (btn_tertiary.Height-Self.Height)/2 Set Y of btn_quarternary to btn_quarternary.Y+ (btn_quarternary.Height-Self.Height)/2

Make sure that all controls sit in the correct order as they overlap:

The Timers

Now we will take care of the logic.

In the OnSelect of the icon_Start we want to extract all buttons and handle which icon appears : Set(start1, true); Set(start4, false); Set(isCloseVisible, true); Set(isStartVisible, false);
In the OnSelect of icon_Close we want to collapse all buttons and handle which icon appears: Set(isCloseVisible, false); Set(isStartVisible, true); Set(start1, false); Set(start2, false); Set(start3, false); Set(start4, true);
Set the Visible of icon_Close to isCloseVisible, the Visible of icon_Start to isStartVisible
Set the Start of timer1 to start1, and the OnTimerEnd of timer1 to Set(start2, true) - which means that at the end of the first timer, we kick off the second timer.
Set the Start of timer2 to start2, and the OnTimerEnd of timer2 to Set(start3, true)
Set the Start of timer3 to start3 - please note that at this point we don’t want to kick off another timer - all buttons are expanded and we only want to collapse them when our user selects the icon_Close.

Let’s now hook the Y property of btn_secondary, btn_tertiary, btn_quarternary to the timers so that the buttons nicely float to their final position:

Set the Y of btn_secondary to If(!start4, btn_primary.Y-100*(timer1.Value/timer1.Duration),btn_primary.Y)
Set the Y of btn_tertiary to If(!start4, btn_primary.Y-200*(timer2.Value/timer2.Duration), btn_primary.Y)
Set the Y of btn_quarternary to If(!start4,btn_primary.Y-300*(timer3.Value/timer3.Duration),btn_primary.Y)

Add your component to a screen and don’t forget to now assign actions to the buttons :-)

Feedback and what’s next?

That’s it!

a few buttons, icons and 4 timers are enough to create some advanced UI that you’d usually not find in a Power Apps. Next blog post is about how to create such beautiful photo galleries, that don’t look like default Power Apps experience. Let me know what you think on twitter.

Next blog post in this series is about how you can create this cool looking gallery with with various image sizes.

Get started with planning your Power Apps components properly

Wed, 17 Aug 2022 09:27:55 +0000

Power Apps components are awesome, still I do not see too many organization using them, which is why I want to give some guidance on how to better plan and build components. Proper planning can save hours or even days of development time and lead to a better result, so it could be worthwhile to dig into how we plan components:

When building components for we usually build something in an app, then realize that this could/should be a component and then rework this as a component. This comes with a lot of going back and forth and is neither the most efficient way nor the most satisfying one.

Also undocumented (and no, some inline comment don’t make proper docs!) components won’t serve the components goal of being reusable so that they reduce time and effort that goes into building UI, but will furthermore increase technical debt.

To improve both developer experience and user satisfaction, here is some guideline to follow along.

💡 Note: I will talk about the person who is making components and component libraries for other makers to use as a maker enabler and about the person using ready to be used components in their apps as makers, while people who will use apps will be called users.

Start with the docs: What is this?

Give your component a meaningful name

If you plan on doing an entire component library or if you see potential to share more than one component with co-workers, its a good idea to stick to a namig convention. This makes it easier for makers to find the right component when building apps.

Describe what your component should do

Give some thoughts to the purpose of the component. Shall it display information, gather data from a user, facilitate how users interact with UI?

Describe the kind of app it is intended to be used for

For which kind of apps is this component intended to be used for, what is its context? Does it run standalone, in SharePoint, in Teams? On which devices will it be used?

Describe use cases this component could serve

A generic popup component could serve to display information, a warning or an error message. It can be used to let users confirm something, give them a guided tour through an app, a process or more, could gather their input and so much more. The more time you spend on exploring what your component could do, the more likely it is, that you build a component that is flexible enough to adjust to maker’s needs.

Take your time to write this down, if you plan on creating more than 1 component but rather a component library, make a habit to start with the docs and make these accessible and discoverable to every maker who could use these components. Trust me, if you commit to work in the open and document your work, you will likely also take more care, as you would need to write down messy workarounds as well.

Design considerations

We will use a popup component as an example, but the process will apply to all kinds of components.

Visual design - how things look

To make a component as reusable and adjustable as possible, its a good idea as a maker enabler to let makers adjust colors and shapes but give them already something that works without needing to change anything.

Colors

A good practice is to layout a color palette for your component or your component library and then stick to this.

If you need a little help with which colors go well together: I use coolors.co palette generator to find those matching colors. To harmonize the look you can use the 60-30-10 rule, which states that about 60% should be a primary color (dominant), 30% should be a secondary color (supporting), and 10% should be an accent color.

Define a palette with these 3 colors, but keep accessibility and color contrast in mind. Also think about hover or pressed events.

Shapes & Sizes

Now think about the shapes and sizes in your components, for example rounded corners, border thickness, width and height of your component. Write these considerations down. Also think about media such as images, icons and more to be consistent.

Look and feel of your component - input properties

Now that you already defined a color palette and got an idea how your component and its parts could look and feel, let’s make this happen.

Define input properties for the colors you want to use: primaryColor, secondaryColor, accentColor
Assign your color palette values to them as default values.

Create also input properties for radius of buttons, standard width or height of controls you use, and more. The goal is to avoid hard coded values as you don’t want to go over the entire component over and over just because someone requests ‘just a tiny change’ 🙃
Write everything down. Seriously.

Functional design - how things work

After working on UI, let’s work on UX and consider how the app works. First think about the logic within the component, then think about how the component interacts with the apps it shall run in.

Behavior properties - make your component interact with the app

For this, we can fire custom events with behavior properties - for example we can close a popup-component by

Add a behavior property onClose (boolean) to our component
Add an X icon to the component
Assign the property to the OnSelect of the X icon
In your component instance, set the OnSelect property of your component to Set(isCmpVisible, false)
In your component instance, set the Visible property of your component to iscmpVisible

As a result, the component will automagically 🦄 disappear, once a user selects that X icon.

💡 Note: If you like behavior properties, you need to first turn on the respecting setting:

Content - display useful information with more input properties

As we will also want to give makers good options to customize the content being displayed in the component:

Define input properties for every text, number, table, or image being displayed, such as

mainButtonContent
labelHeaderContent
labelBodyContent

so that makers can easily adjust these values.

Return values from component to app - Output properties

If users interact with our components and we want to know what they did, we will need to return values from our component to the app. We do this with output properties.

For example, if our component contains a TextInput control and we want to know the Text property of that in our app, we will need to create an output property, hook that to TextInput.Text and then use the Output property in the app to return that value.

Build the component

Now that you defined all the properties to take care of

look and feel of your component
content to be displayed
inner and outer logic in app context

its time to build the component.

Define the components size, preferably relative to the App’s Width and Height
Add the controls you need to your component, define X, Y, Width and Height relative to the component, don’t use hard coded values
Assign the custom input properties for look and feel: colors and shapes
Assign the custom input properties for displaying content: texts, tables, images
Assign the behavior properties to the controls that shall call that property like a function
Assign the output properties to the controls that shall return a value to the app

Use the component

Once you finished the component, add it to your app and try it out.

Make sure that you assign a custom event to each behavior property
Understand the output properties you already defined
Document this :-)

As a last hint: This is how proper docs for a component could look like:

Result

As a result, you can establish this as your standard process to build components, which will also reduce your development time and increase component quality. You will also take advantage of proper documentation, which will make sure that you are not the only one who needs to take care if the component needs an adjustment or if users need a similar component. What do you think? Let me know on twitter :-)

Build a progress button with me (yes it is a component)

Mon, 08 Aug 2022 11:39:48 +0000

tl;dr

You know that feeling when right after hitting that send button you still want to edit something or changed your mind? This progress button allows people to rethink again and change their minds.

Why would we need a progress button?

My proofreading skills improve by at least 200% after I hit a send button. If you feel your users could use a little think again option, this progress button is for you.

Desired goal: Once a user selects the Send request button, the button shall fill in a different color, linear progressing from left to right and display a text like sending... click to cancel. If the user selects that button now again to cancel the action, we want to reset that Fill and Text to the original state.

Build the component

As we want to make this as reusable as possible, we will invest some time to create it as a component.

Set the custom properties

backgroundFill (Color) : ColorValue("#1e6091")
progressFill (Color): ColorValue("#168aad")
textColor (Color): White
progressbuttonHeight (Number): 40
progressbuttonWidth (Number): 200
labelContent (Table):

Table(
{
id: 1,
text: "send request"
},
{
id: 2,
text: "sending... click to cancel"
},
{
id: 3,
text: "sent"
}
)

Now set ths OnReset property of the component to Set(cmp_labelTrack,1);Set(cmp_timerRun,false)

Controls

Add
- 3 buttons btn_background, btn_progress and btn_overlay
- 1 labels lbl_Content
- 1 timer Timer1

to the component

Set all of these to the same Width: cmp_progressButton.progressButtonWidth, Height: cmp_progressButton.progressButtonHeight, X: 5 and Y: 5, so that they overlap. Order them so that the overlay button is on top, the lbl_Content is on top of btn_progress and the btn_progress is on top of the btn_background

We will want to set the initial state of our label in the OnVisible of the screen Reset(cmp_progressButton_3)

Overlay button

This button is the one that contains all the magic:

Set its OnSelect to

Set(cmp_timerRun,!cmp_timerRun);Set(cmp_labelTrack,2);

as we want to start/stop a timer and control which row of our content we want to display in the text label.

Set all Colors of this button to Transparent - we want it to visually disappear. Don’t set the Visible property to false - users can’t interact then with it.
Set the Text property to "" - we don’t need any text in here.

Text label

Set the Text property of the label to LookUp(cmp_progressButton.labelContent,id=cmp_labelTrack, text) - This makes sure OnVisible of the screen (cmp_labelTrack = 1), we display send request, while once our user selected the button (cmp_labelTrack = 2) we display sending... click to cancel. We will later adjust the timer so that the last text sent! is being displayed OnTimerEnd.

Background button

This is the button that looks as if it was the one people click on - but as we have an overlap with the overlay button, it shall just look pretty - I liked it plain and simple and went for Radius: 0.

Set its DisplayMode to View - users won’t interact with it.
Set its Text to ""
Set its Fill to a cmp_progressButton.backgroundFill, make the BorderColor Transparent and let HoverBorderColor, PressedColorBorder = Self.Fill

progress button

This is the button that fill up from left to right once user selects the overlay button

Set its Fill property to cmp_progressButton.progressFill
Make the BorderColor Transparent and let HoverBorderColor, PressedColorBorder = Self.Fill
Set its Text to ""
Set its Width to cmp_progressButton.progressButtonWidth*(Timer.Value/Timer.Duration) - this means that at any given point the Width of the button will be determined by the progression of the running timer
Set HoverFill to btn_background.Fill

Timer

It’s time to take care of the Timer control

AutoStart: cmp_timerRun
OnTimerEnd: Set(cmp_labelTrack, 3);Set(cmp_timerRun, false) - as mentioned above - we now display the third text in the label
Reset !cmp_timerRun
Duration: 2000 (milliseconds)

one more thing…

To make this component fully adjustable, now add two more custom properties to it:

sizeWidth** (Number): btn_background.Width+10
sizeHeight** (Number): btn_background.Height+10

Adjust X and Y of the btn_background to 5.

That’s it!

Feedback and what’s next?

Would you like to include such a button? Please let me know on twitter.

Can you make it pop?

Sat, 06 Aug 2022 15:10:52 +0000

tl;dr

Want to improve your app design and your galleries? Learn how to make your galleries pop out and get this very dynamic look and feel!

There are a few things you can do to make your galleries stand out and to create this rich and visually appealing look.

some basics

Transition

I only recently stumbled upon a property in Power Apps galleries: Transition. It has a default value of None, but can be set to Pop or to Push, which give the illusion that on hover of an item the selected item either pops out or is pushed in. This already looks good on regular text labels, but will be taken to next level if we add some sugar&spice aka buttons and shadows.

Use buttons instead of text labels

Choosing buttons over text labels has some serious advantages:

they can have rounded corners, which means they are very flexible to style
they have properties for HoverFill, PressedFill etc.

💡 Please always set the DisplayMode property of buttons you don’t want users to interact with to View, this is important for accessibility reasons.

If you still prefer text labels, you can add them on top of a button to benefit from the flexible design options.

Using buttons, you can easily create this card look.

Elevate your design

Add a little bit of drop shadow to your cards with an HTMLtext control. I use something like this to create a subtle shadow:

"<div style='
margin: 20px;
width: 219px;
height: 380px;
box-shadow: -6px 6px 14px rgba(25, 25, 25, .2);
border-radius: 15px
'>
</div>"

Shapes and sizes

Play around a bit with shapes and sizes of images- you can also add blobs to your gallery to make it look more dynamic. In my example, I generated a few blobs with blobmaker.app, uploaded them to the app and referred to them in the table that feeds my gallery:

Table(
{
id: 1,
blob: blob2,
fill: ColorValue("#ffffff"),
hoverfill:ColorValue("#f5f5f5"),
title: "ocean",
image: 'image1',
textcolor:Black,
body: "The ocean (also the sea or the world ocean) is the body of salt water that covers approximately 70.8%..."
},
{
id: 2,
blob: blob3,
fill:ColorValue("#FAF0CA"),
hoverfill:ColorValue("#efd157"),
title: "desert",
image: 'image2',
body: "A desert is a barren area of landscape where little precipitation occurs and, consequently... ",
textcolor:Black
},
...
...
{
id: 7,
blob: blob3,
fill:ColorValue("#718F94"),
hoverfill:ColorValue("#2C383A"),
title: "city",
image: 'image7',
body: "A city is a large human settlement. It can be defined as a permanent and densely settled...",
textcolor: White
}
)

Make your gallery scrollable - without a scrollbar

As already covered in How to build a curved gallery in Power Apps and in How to create your own scrollbar for galleries in Power Apps we don’t need to use the built-in gallery scrollbar, but can either scroll without any control by swiping or we can create the illusion of having a scrollbar in the design of your choice.

This time I again used a slider control and related the X property of the button in my gallery to its value. All other X properties of the other controls in the gallery depend on that button.

I use a plane svg ✈ and relate its position as well to the slider value. As we can use CSS in svg code, we can rotate the svg conditionally to the value of the slider as well:

"data:image/svg+xml;utf8, " & EncodeUrl(
"<svg xmlns='http://www.w3.org/2000/svg' width='16' height='16' fill='rgb(231,221,251,0.9)' class='bi bi-airplane-engines-fill' viewBox='0 0 16 16' "& If(Slider1.Value > (Slider1.Max/2), "transform='rotate(90)'", "transform='rotate(-90)'")&">
<path d='...'/>
</svg> "
)

Add an additional visual layer on your screen

Background

Don’t use a plain White or plain Black background fillcolor. Both colors are very harsh on the eyes and don’t leave a lot of room for color harmony.

Use some waves

Love waves? Samesies. I use the wave generator at getwaves.io, save as svg and upload to my app. 💡 - ImagePosition: Fit is your friend.

If you now have the waves in the background and slightly overlap your gallery with them, you create an additional layer, so that the screen doesn’t look flat, but more 3D and dynamic.

Create Pop-Ups

Sometimes, a modal window is enough and you don’t need to build an entire new screen. If you want to create different pop-ups depending on which item in your gallery was selected (now again the button comes in handy), you can achieve that by:

Have a button/icon in the gallery
Set its OnSelect property to something like If(ThisItem.IsSelected, Set(isShowPopup, true);Set(gbl_PopupContent, ThisItem.id), "") to first determine if a popup shall be displayed and then which content shall be shown.
Create a text label of the size of your screen, fill it in a grey-ish color and set transparency to a value that you like.
On top of that blur text label, create a button/text label in a bright color (you can reuse the color of the button) and display the content you like on top of that. For this, set the Fill property of that background button to gal_pop.Selected.fill and the Image property of the image/content that you want to show to gal_pop.Selected.image
For some more depth, create a shadow with HTMLText again
Don’t forget to have a close/cancel icon as well. Set it’s OnSelect to Set(isShowPopup, false)
Set the Visible property of the blur text label, your background button, your content, the htmlText and the cancel icon to isShowPopup

There you go! You created a modern design, that doesn’t look like the typical canvas app.

Feedback and what’s next?

What are your design hacks? How do you make your apps stand out? I am curious! Please let me know on twitter*.

How to create your own scrollbar for galleries in Power Apps

Fri, 05 Aug 2022 20:12:36 +0000

tl;dr

Did you know that two buttons and a slider make a sweet scrollbar? Let me show you how to do it!

In my last blog post about How to build a curved gallery in Power Apps I already showed how you can use a slider to scroll through a horizontal gallery, and we hid that slider. This post shall show you how you can create your own scrollbar to navigate a vertical gallery.

To make this as flexible and reuasable as possible, we will componentize this.

create a component

Create a new component cmp_scrollGallery and add the following custom properties to it:

galleryStyles (Record): {X:0,Y:0,Width:cmp_scrollGallery.Width,Height:cmp_scrollGallery.Height}

galleryContent (Table):

Table({id:1,image:'image1',title:"Lake Tahoe",description:"d1"},{id:2,image:'image2',title:"Trees",description:"d2"},{id:3,image:'image3',title:"Waterfall",description:"d3"},{id:4,image:'image4',title:"Lake Louise",description:"d4"},{id:5,image:'image5',title:"Santa Barbara",description:"d5"},{id:6,image:'image6',title:"Ocean",description:"d6"},{id:7,image:'image7',title:"Beaver Dam",description:"d7"},{id:8,image:'image8',title:"Green",description:"d8."})

sizeWidth (Number): App.DesignWidth

sizeHeight (Number): App.DesignHeight

sliderStyles (Record): {X:cmp_scrollGallery.Width,Y:0,Width:50,Height:cmp_scrollGallery.Height}

backgroundBarColor (Color): ColorValue("#168aad")

scrollBarColor (Color): ColorValue("#1e6091")

scrollbarStyles (Record): {X:cmp_scrollGallery.galleryStyles.Width-20,Y:0,Width:20,Height:cmp_scrollGallery.Height}

titleStyles (Record): {Font: Font.'Open Sans', FontSize: 16, FontWeight: Bold, Color: White, Width: cmp_scrollGallery.galleryStyles.Width*0.5, Height:40, X: cmp_scrollGallery.imageStyles.X+cmp_scrollGallery.imageStyles.Width +40 } |

imageStyles (Record): {Width:128, Height: 128, BorderTopLeft: 0, BorderTopRight: Self.Width, BorderBottomLeft: 0, BorderBottomRight:0,X: 16}

bodyStyles (Record):{Font: Font.'Open Sans', FontSize: 12, FontWeight: Lighter, Color: White, Width: cmp_scrollGallery.galleryStyles.Width*0.7, Height:40, X: cmp_scrollGallery.imageStyles.X+cmp_scrollGallery.imageStyles.Width +40 }

Set the Width of the component to cmp_scrollGallery.sizeWidth and the Height to cmp_scrollGallery.sizeHeight

gallery

We will now add a gallery and refer to our custom properties.

Upload a few images
Add a horizontal gallery gal_1
Set the ShowScrollbar property to false
Set its items property to cmp_scrollGallery.galleryContent
X: cmp_scrollGallery.galleryStyles.X, Y: cmp_scrollGallery.galleryStyles.Y, Height: cmp_scrollGallery.galleryStyles.Height, Width: cmp_scrollGallery.galleryStyles.Width

image in the gallery

Add an image img to the gallery, set its Image property to ThisItem.image
X: 16, Width: cmp_scrollGallery.imageStyles.Width, Height: cmp_scrollGallery.imageStyles.Height
Add a button to the gallery, (I liked it to be semi transparent) and set its X to img.X and its Width*toimg.Width`
RadiusTopRight: cmp_scrollGallery.imageStyles.BorderTopRight, all other Radius… properties shall be 0 - this creates this quarter circle effect
TemplatePadding: 20, TemplateSize: 140

title text label in the gallery

Add a text label lbl_title
X: cmp_scrollGallery.TitleStyles.X, Y: img.Y, Width: cmp_scrollGallery.TitleStyles.Width, Height: 40
Color: cmp_scrollGallery.TitleStyles.Color, Font: cmp_scrollGallery.TitleStyles.Font, FontWeight: cmp_scrollGallery.TitleStyles.FontWeight, Size: cmp_scrollGallery.TitleStyles.FontSize
Set its Text property to ThisItem.title

description text label in the gallery

Add a text label lbl_description
X: cmp_scrollGallery.bodyStyles.X, Y: img.Y, Width: cmp_scrollGallery.bodyStyles.Width, Height: 40
Color: cmp_scrollGallery.bodyStyles.Color, Font: cmp_scrollGallery.bodyStyles.Font, FontWeight: cmp_scrollGallery.bodyStyles.FontWeight, Size: cmp_scrollGallery.bodyStyles.FontSize
Set its Text property to ThisItem.description

Now that we have the gallery, lets make it scrollable. We will add a slider control and hook this the Y property of the image. 💡 The Y property of all other controls in the gallery depends on img.Y

slider

Add a vertical slider sli_gal
X: cmp_scrollGallery.sliderStyles.X-Self.Width, Y: cmp_scrollGallery.sliderStyles.Y, Height: cmp_scrollGallery.sliderStyles.Height, Width: cmp_scrollGallery.sliderStyles.Width
Set its Min to gal_1.TemplatePadding+btn_ScrollBar.Height/2, its Max to gal_1.Height+gal_1.TemplatePadding-btn_ScrollBar.Height/2 and its Default to 50
Set the HandleSize to 50
Now set all color values to Transparent - we want to make the slider disappear. Don’t set the visible property to false - users can’t interact then with the control anymore

Now the most important step: Go back to img.Y and set it to sli_gal.Value-gal_1.Height+gal_1.TemplatePadding. You can now move the hidden handle and see that the items in the gallery in fact scroll :-)

Now we want to add the scroll bar:

2 buttons

Yes, for real. Our scrollbar only consists of two buttons, one for the background bar and one for the actual scroll bar

background bar

Add a button btn_backgroundBar, set its DisplayMode to View, we don’t want users to interact with it.
X: cmp_scrollGallery.scrollbarStyles.X, Y: 0, Height: cmp_scrollGallery.Height, Width: 20
Fill: cmp_scrollGallery.backgroundBarColor

scroll bar

Add a button btn_scrollBar, set its DisplayMode to View
X: cmp_scrollGallery.scrollbarStyles.X, Y: sli_gal.Height-sli_gal.Value+Self.Height/2-gal_1.TemplatePadding, Height: 40, Width: 20
Fill: cmp_scrollGallery.scrollBarColor

As a last step, rearrange the controls so that the slider is on top

Feedback and what’s next?

Who would have thought that its that easy to create your own custom scrollbar? Adjust sizes and colors as you please, and let me know on twitter how you like it!

How to build a curved gallery in Power Apps

Fri, 05 Aug 2022 12:32:53 +0000

tl;dr

Galleries in Power Apps do not have to look boring. With a little creativity we can create a curve effect.

gallery

Upload a few images
Add a horizontal gallery gal
Set the ShowScrollbar property to false
Set its items property to

Table(
{
id: 1,
image: 'image1',
title: "image1"
},
{
id: 2,
image: 'image2',
title: "image2"
},
{
id: 3,
image: 'image3',
title: "image3"
},
{
id: 4,
image: 'image4',
title: "image4"
},
{
id: 5,
image: 'image5',
title: "image5"
},
{
id: 6,
image: 'image6',
title: "image6"
},
{
id: 7,
image: 'image7',
title: "image7"
},
{
id: 8,
image: 'image8',
title: "title8"
}
)

Add an image img to the gallery, set its Image property to ThisItem.image
Add a button to the gallery, (I liked it to be semi transparent) and set its X to img.X and its Width* to img.Width
Set its Text property to ThisItem.title

ovals

Add two ovals to your screen, set their Width to gal.Width, set their Y property that the ovals slightly overlap with the gallery (depending on how intense you want the curve effect to look like)
Set the Fill property to Screen1.Fill and their BorderColor to Transparent - voila, they seem to be invisible

slider

As we don’t show a scrollbar (I find the built-in scrollbar ugly), we will add a slider with which we can scroll through our gallery

Add a horizontal slider
Place it on top of the gallery, matching its size
Set the HandleSize to gal.TemplateHeight
Set its Min to (gal.TemplateWidth*CountRows(gal.AllItems)-gal.Width-gal.TemplateWidth)*-1, its Max to gal.Width-gal.TemplateWidth, and its Default to Self.Max
Now set all color values to Transparent - we want to make the slider disappear. Don’t set the visible property to false - users can’t interact then with the control anymore

One last thing: Set the X property of the image in the gallery to slider.Value

That’s it!

Feedback and what’s next?

I’d like to know what you would like to display in such a curved gallery? Preview of documents? Images of assets? Also: did you know that you could use a slider to scroll through a gallery? Let me know on twitter!

How to build a swipe-right component in Power Apps

Thu, 04 Aug 2022 10:15:31 +0000

tl;dr

Your canvas apps do not have to look ugly. This blog post guides you how to build a swipe-right component that you can reuse across apps.

What we are going to build

Create the Component with custom properties

Create a new component cmp_SwipeRight and add the following custom properties

property	type	default
swipeHeight	Number	`55`
swipeWidth	Number	`250`
primaryColor	Color	`ColorValue("#c0c0c0")`
secondaryColor	Color	`RGBA(116,116,116,1)`
accentColor	Color	`RosyBrown`
textColor	Color	`White`
backgroundText1	Text	`"swipe to approve"`
backgroundText2	Text	`"thank you"`
chevronColor1	Color	`White`
chevronColor2	Color	`LightGray`
chevronColor3	Color	`DarkGray`
icon	Image	`Icon.Heart`
Onchange	Behavior(Text)	(needs number parameter called `valueslider`)

Set the Width property of the component to cmp_SwipeRight.swipeWidth+10 and the Height property to cmp_SwipeRight.swipeHeight+20

background button

Add a button btn_background_1, set its DisplayMode property to View - We don’t want people to interact with this button. The only reason this is not a text label is that we can’t do rounded corners with a text label 🙄
Set the Fill property to cmp_SwipeRight.primaryColor, the BorderColor property to Self.Fill and the Color property to cmp_SwipeRight.textColor
Position the button to X = (Parent.Width-Self.Width)/2 and Y = (Parent.Height-Self.Height)/2
Set the Width property to Parent.Width-10 and the Height property to Parent.Height-10
Set the Border radius to 10 (it’s the default value)
Set the Align property to Align.Center
Set the Text property to If(sli_swipeRight_1.Value<100,cmp_SwipeRight.backgroundText1,cmp_SwipeRight.backGroundText2) - don’t worry, this will give an error as we are referring to a slider control that doesn’t exist yet - we will fix this in the next step.

slider

You guessed it - we need a slider control.

Add a horizontal slider control, set its Min to 0 and its Max to 100, Default is 0 as well
Set its HandleSize to 200
Set X to btn_background_1.X+5 and Y to 0
Set Width to cmp_SwipeRight.swipeWidth-btn_swipe_1.Width-12 and Height to Parent.Height
Set all color values to Transparent - this control should be invisible to users - still resist that urge to set the Visible property to false - users can’t interact with the control anymore if you do that
Set the OnChange property to If(Self.Value<100, Set(isActionSuccess, false), Set(isActionSuccess, true)); cmp_SwipeRight.Onchange(Self.Value) - We determine if a user has (completely) swiped right and output this into a variable.

swipe button

As we don’t want users to see the slider handle (you can’t change its shape), we need something else so that they know that they swiped :-)

Add a button btn_swipe_1 and again set its DisplayMode property to View - this is just to be pretty, not to have users interact with it directly
Set X to sli_swipeRight_1.X+ sli_swipeRight_1.Width/100*sli_swipeRight_1.Value+1 and Y to (Parent.Height-Self.Height)/2 - which means that our swipe button moves alongside with the (hidden) handle of the slider
Set Height to btn_background_1.Height-20 and Width to Self.Height
Set Fill to cmp_SwipeRight.secondaryColor and BorderColor to Self.Fill
Set the Text property to "" - we don’t need any text in here - the entire magic is done in a gallery

gallery

Speaking of a gallery - we need this to show those nice chevrons!

Create a horizontal gallery gal_chevrons
Set its items property to

Table(
{
id: 1,
icon: Icon.ChevronRight,
color: cmp_SwipeRight.chevronColor1
},
{
id: 2,
icon: Icon.ChevronRight,
color: cmp_SwipeRight.chevronColor2
},
{
id: 3,
icon: Icon.ChevronRight,
color: cmp_SwipeRight.chevronColor3
}
)

Set X to sli_swipeRight_1.X+ sli_swipeRight_1.Width/100*sli_swipeRight_1.Value+1 and Y to btn_swipe_1.Y - which means that our gallery will stick to our swipe button when it moves
Set its Width to btn_swipe_1.Width and its Height to btn_swipe_1.Height
Set TemplatePadding to 1 and TemplateSize to 12
Set Visible to !isActionSuccess - remember, this is set when we move the slider :-) As a result, the gallery wil disappear once we swiped
Add an icon icon_chevron to that gallery
Set the Icon property of the icon to ThisItem.icon
Set its Height to Parent.Height and its Width to 15
Set the Color property to ThisItem.color

This empty swipe button should now indicate, that the swipe was a success:

icon

Add an icon to your component
Set X to btn_swipe_1.X+ (btn_swipe_1.Width-Self.Width)/2 and Y to btn_swipe_1.Y+(btn_swipe_1.Height-Self.Height)/2
Set Width and Height to 16
Set Color to cmp_SwipeRight.accentColor
Set the icon property of the icon to cmp_SwipeRight.icon
Set Visible to isActionSuccess - as a result once the gallery disappeared, the single icon shows up

WE now want to add some more 3D effect to our component and have a nice shadow on the swipe button.

HTMLtext

Add an HTMLText control html_shadowSwipe_1 to the component
Set X to sli_swipeRight_1.X+ sli_swipeRight_1.Width/100*sli_swipeRight_1.Value-10 and Y to 4 - this way it moves along with the swipe button and the gallery
Set Width to btn_swipe_1.Width+25 and Height to btn_swipe_1.Height+25
Set its HTMLText property to "<div style='margin:5px;width:"&btn_swipe_1.Width&"px;height:"&btn_swipe_1.Height&"px;background-color:#;box-shadow:3px 6px 6px 1px rgba(0,0,0,0.14); border-radius:"&btn_swipe_1.RadiusBottomLeft&"px'></div>"

Bring all controls into the right order

Make sure that all controls sit like this:

Add the component to your app

Now let’s add the component to our app and play around with the appearance - as we set a ton of custom properties for colors, sizes, and icon, we can easily adjust the look of this component. You can try out for example to change the colors of the chevrons depending on the Fill color of your swipe button or different icons to determine success and of course different texts.

Still one thing is missing - we need to know when our user swiped, right? To do so, set the (custom) Onchange property of the component to UpdateContext({loc_isSuccessValue: valueslider}) - This way we set a local variable that returns a 100 if the slider was swiped completely.

Feedback & what’s next?

What do you think? Would you like to use such a swipe component in your mobile apps? Let me know on twitter!

How to build a split button component for Power Apps

Wed, 03 Aug 2022 17:18:53 +0000

tl;dr

Less controls mean less user confusion and better performance - This blog post guides you through the creation of a simple yet effective split button component.

Let’s create a component

Create a new canvas component cmp_SplitButton and add the following custom properties to it

property	type	default
splitButtonHeight	Number	`40`
splitButtonWidth	Number	`196`
primaryColor	Color	`ColorValue("#1e6091")`
secondaryColor	Color	`ColorValue("#168aad")`
textColor	Color	`White`
buttonText	Text	`"open"`
Onchange	Behavior(Text)	(needs boolean parameter called `option`)
Onselect	Behavior(Boolean)	`true`

Add a button btn_main to the component
Set its OnSelect property to cmp_SplitButton.Onselect() - this will make sure that when we later call that function we will return a true so that we can determine in our app if that button was selected.

Now let’s refer to our custom properties:

property	value
BorderColor	`Self.Fill`
Color	`cmp_SplitButton.textColor`
Fill	`cmp_SplitButton.primaryColor`
Height	`cmp_SplitButton.splitButtonHeight`
HoverBorderColor	`cmp_SplitButton.secondaryColor`
HoverColor	`Self.Color`
HoverFill	`cmp_SplitButton.secondaryColor`
PressedBorderColor	`cmp_SplitButton.secondaryColor`
PressedColor	`Self.Color`
PressedFill	`cmp_SplitButton.secondaryColor`
Radius	0
Width	`cmp_SplitButton.splitButtonWidth-36`

Add a dropdown control drp_options to the component and refer as follows to our custom properties:

property	value
BorderColor	`cmp_SplitButton.primaryColor`
ChevronBackground	`cmp_SplitButton.primaryColor`
ChevronFill	`cmp_SplitButton.textColor`
ChevronHoverBackground	`cmp_SplitButton.secondaryColor`
ChevronHoverFill	`cmp_SplitButton.textColor`
HoverBorderColor	`cmp_SplitButton.secondaryColor`
Color	`cmp_SplitButton.secondaryColor`
Fill	`White`
Height	`cmp_SplitButton.splitButtonHeight+2`
HoverBorderColor	`cmp_SplitButton.secondaryColor`
HoverColor	`cmp_SplitButton.textColor`
HoverFill	`cmp_SplitButton.secondaryColor`
PressedBorderColor	`cmp_SplitButton.secondaryColor`
PressedColor	`cmp_SplitButton.textColor`
PressedFill	`cmp_SplitButton.secondaryColor`
SelectionColor	`cmp_SplitButton.textColor`
SelectionFill	`cmp_SplitButton.secondaryColor`
Width	`cmp_SplitButton.splitButtonWidth+2`

I know, that is a tedious task, but trust me, the result looks good.

Set the Items property to any array that you like - I used ["open in SharePoint", "open in Teams", "send as an email"]
Now let’s take of functionality of the dropdown - set the OnChange property to cmp_SplitButton.Onchange(drp_options.SelectedText.Value).

Add Functionality to your component

Depending on your use case, you will want to at least

determine, if the button has been selected (to then perform other actions)
determine, which value has been selected in the dropdown.

To achieve this,

Add your component to the app
Set the Onselect (custom) property to UpdateContext({loc_isButtonClicked:true}) - which saves a True value in local variable to determine if that button was clicked.
Set the Onchange (custom) property to UpdateContext({loc_selectedOption: option}) - this way you set a local variable to the Selected Text of your dropdown

We aim to deliver clean, consistent, and intuitive user experiences - and in cases where we want users to perform a main action or where its likely that one action is the most important action on a screen, we want to make that obvious to them. However sometimes, there are similar actions that can be performed as well - and then such a split button comes in handy. This design pattern is a great way to reduce visual clutter and provide a good user experience.

Feedback and what’s next?

I am curious - do you use split buttons as well? What are your use cases>? Let me know on twitter :-)

How to show the app version in Power Apps Canvas Apps

Wed, 03 Aug 2022 09:03:25 +0000

tl;dr

You can display the current app version in a canvas app using the Power Apps for Makers connector. This is especially helpful while during developing/debugging Power Apps for Microsoft Teams.

⚡ When building a Canvas app for Microsoft Teams, you will add your app to Teams to get contextual information such as locale or theme of Teams and validate if your app works as intended. In Power Apps Studio, there is a nifty button for that, which abstracts away the creation of a manifest.json file, but has some flaws. (Stay tuned for a post that covers that)

One of the problems is, that once you added the app to Teams, it doesn’t always pick up the latest version - which can make debugging a nightmare, as the UI in Teams doesn’t show you what you see in Power Apps Studio or in your extracted files in Visual Studio Code. Gave me some want to bang my head against the keyboard moments until I figured that the changes I made were just not present in the version that Teams picked up 🤯

Power Apps for Maker connector

Microsoft built a connector called Power Apps for Makers, which can help with that issue. The connector can show all kinds of information about the apps that you build and we can use it to display the version number inside of the canvas app. I usually have a variable in my apps called isDebugMode that controls if I want to display information for myself during development/debugging.

We will use three functions of that connector:

PowerAppsforMakers.GetApps, which gives us the names of our apps (watch out, these are not a friendly name/displayName, but a GUID)
PowerAppsforMakers.GetAppVersions, in which we can pass in the app name to retrieve the version number.
PowerAppsforMakers.GetApp which gives us the creation timestamp

Get the app name

To get the app name, add a text label, set its Text property to

LookUp(
PowerAppsforMakers.GetApps().value,
properties.displayName = "PrettyUp",
name
)

We use LookUp to get the name property of an app that has a displayName PrettyUp. This will return the GUID that we need to pass into the PowerAppsforMakers.GetAppVersions function in the next step.

Get timestamp

We can get the timestamp when we last published the app with

PowerAppsforMakers.GetApp(
LookUp(
PowerAppsforMakers.GetApps().value,
properties.displayName = "PrettyUp",
name
)
).properties.appVersion

Once again we pass in the GUID dynamically with the LookUp function.

💡 Watch out, properties.appVersion is not the version number, but a date-time field/timestamp.

Get the app version

As we want to get the version every time we run OnStart, its a good idea to put these functions in the OnStart property of your app:

Set(
appVersion,
CountRows(
PowerAppsforMakers.GetAppVersions(
LookUp(
PowerAppsforMakers.GetApps().value,
properties.displayName = "PrettyUp",
name
)
).value
)
);
Set(
appTimeStamp,
PowerAppsforMakers.GetApp(
LookUp(
PowerAppsforMakers.GetApps().value,
properties.displayName = "PrettyUp",
name
)
).properties.appVersion
)

In the first function, as we don’t want all versions, but only the latest one, we will use CountRows() and return the value of the PowerAppsForMakers.GetAppVersions table, in which we use the LookUp function of step 1. In the second function we will use PowerAppsForMakers.GetApp to retrieve the appVersion.

Show app version on screen

Change the Text property of the text label of step 1 to "This is v." &appVersion & " published last time " & appTimeStamp.

If you now publish your app and add it to Teams, you can see which version you are on and when you lastly published. This way it’s easy to determine if Teams picked up the latest version of your canvas app.

Feedback and what’s next

I’m curios as always - how do you use the Power Apps for maker connector and which struggles do you have with debugging Power Apps for Teams? Let me know on twitter!

How to navigate Power Apps studio formula bar keyboard-only

Thu, 28 Jul 2022 11:13:19 +0000

tl;dr

you can use Power Apps Studio way more efficient - and way more accessible in regards of different input devices than you might be aware of.

the annoyance

Recently, I had a chat with Yannick Reekmans who told me that he really wonders how anyone could be productive on Power Apps Studio. His example was:

If we select a property on the property-dropdown, then double-tab to the formula bar, make our changes and then want to select the next property, there is no obvious way on how to select the property-dropdown again - unless we use the mouse, which means losing time and also disturbing our flow of work.

And it was this kind of thing, that I always accepted as this is just how it is, and never really questioned this poor experience.

the solution

After some investigation and looking for accessibility content, I found a way of doing it.

Let’s say we want to insert a button and change some properties, going back and forth between property pane and formula bar:

Use the Tab key until you are on the Insert menu
Enter
User the Tab key until you are on the Button
Enter
2 times CTRL + F6 to select the property dropdown (you can use Ctrl + F6 or CTRL + Shift + F6 to navigate to the next landmark )
Arrow down or Arrow up until the desired property is selected
Enter
2 times Tab
change the value
ESC
2 times Tab to have the property dropdown selected again

We could not be the only ones not knowing this :-)

some more resources

If you want to know more on how to use Power Apps Studio with Screen Reader/keyboard, I can recommend to have a look at Kelly Ford’s session on Building a Microsoft Canvas Power App with a Screen Reader - thanks April Dunnam for the pointer.
Keyboard shortcuts for canvas apps

Feedback and What’s next?

Now why is all of this important? Because it gives people choice on how they want to interact with Power Apps studio, and choice is always improving accessibility. For me, personally, this has already been a game changer and I am only using it for 2 hours. I very much enjoy to not rely on my mouse when changing properties of controls, and I hope this tip will help you, too. I am curios, which hidden keyboard/shortcut/accessibility gems did you find in Power Apps studio and what makes you more efficient? Share your tips on twitter in this thread :-)

How to build a Power Apps progress bar component

Wed, 27 Jul 2022 14:20:36 +0000

tl;dr

Components are reusable building blocks in Power Apps which increase maker productivity and design consistency. If you are new to them, you should definitely start to learn how to build them - This post will make it easier for you! This progress bar component showcases also custom properties to give you an idea on how you can make a component customizable to different needs.

Progress Bar component: the result

Let’s dive in head first and have a look how the completed components will look like. As I designed them to be adjustable to different designs, here is some inspiration:

As you can see, the progress bars can have different widths and heights and can be horizontal or vertical. We will first tackle the horizontal one.

Build the component - horizontal

For this component, that I will name cmp_ProgressBar_hor, we only need two text labels, which you need to insert

lbl_BarCurrent, which shows the progress
lbl_barTotal, which shows the total

Create the custom properties

We will need a bunch of custom properties so the component is more flexible

barMaxValue (Number), set default to 100 - its the maximum value of the progress bar
barCurrentValue (Number), set the default gbl_barValue - this is the variable that controls how much progress is being made
barMaxFill (Color), I set the default to ColorValue("#1e6091") - it’s the fill color of the maximum value
barCurrentFill (Color), I set the default to ColorValue("#168aad") - it’s the fill color of the current value
barWidth (Number), I set the default to 200, it’s the width of the progress bar
barHeight (Number), I set the default to 42, its the height of the progress bar
labelColor (Color), I set the default to White, it’s the color of the label that shows the percentage of progress

Set properties for the labels

For our lbl_BarCurrent:

Color: cmp_ProgressBar_hor.labelColor
Fill: cmp_ProgressBar_hor.barCurrentFill
Height: lbl_barTotal.Height
Text: RoundUp(100*(cmp_ProgressBar_hor.barCurrentValue/cmp_ProgressBar_hor.barMaxValue),0) & "%"
Width: lbl_barTotal.Width*cmp_ProgressBar_hor.barCurrentValue/cmp_ProgressBar_hor.barMaxValue
X: lbl_barTotal.X
Y: lbl_barTotal.Y

For our lbl_barTotal:

Fill: cmp_ProgressBar_hor.barMaxFill
Height : cmp_ProgressBar_hor.barHeight
Text: ""
Width: cmp_ProgressBar_hor.barWidth
X: 5
Y: 5

Now set the Width of the component to cmp_ProgressBar_hor.barWidth+10 and the Height to cmp_ProgressBar_hor.barHeight+10.

If you want to try out the component in your app, you will need to have something that will set the value of our variable gbl_barValue. You can do this with a slider control. Set the OnChange property to Set(gbl_barValue, Self.Value), move the slider and voila, your bar is making progress! You can now insert another component instance and play around with the custom properties and change height and width, the label color as well as the fill colors.

Build the component - vertical

If you now want to create the same component but vertical, you can duplicate the component and then we only need to adjust a few things. Name your vertical component cmp_ProgressBar_vert.

For our lbl_BarCurrent:

Color: cmp_ProgressBar_vert.labelColor
Fill: cmp_ProgressBar_vert.barCurrentFill
Height: lbl_barTotal.Height*cmp_ProgressBar_vert.barCurrentValue/cmp_ProgressBar_vert.barMaxValue
Text: RoundUp(100*(cmp_ProgressBar_vert.barCurrentValue/cmp_ProgressBar_vert.barMaxValue),0) & "%"
Width: lbl_barTotal.Width
Y: lbl_barTotal.Y+lbl_barTotal.Height-Self.Height

For our lbl_barTotal:

Fill: cmp_ProgressBar_vert.barMaxFill
Height: cmp_ProgressBar_vert.barHeight
Width: cmp_ProgressBar_vert.barWidth

How can we use this component in apps?

People like to know the answer to the question Are we there, yet?. Indicating their progress in long forms is a nice way to improve user experience and satisfaction, as people then know what to expect.

Want to reverse-engineer? You can download the component library 🚀✨

Feedback and What’s next?

I would love to learn about your use cases. Where do you use progress bars or which other scenarios do you see for these bars? Let’s talk on twitter :-)

Why your Power Platform service principal doesn't need a Dynamics user_impersonation scope

Mon, 25 Jul 2022 13:58:24 +0000

Auth is hard, for most developers. This is also true when building Power Platform solutions. As I see some blog posts explaining how to use a service principal in Power Platform that contain some inaccuracies/wrong information, I’d like to clarify some auth myths :-)

Usually, Power Automate flows run in the context of a signed-in user. If we for example want to create a row in Dataverse table with a Power Automate flow, we would use the connection of this signed-in user, which can potentially lead to lots of issues. To tackle this, we can create a service principal that will connect our flow action with Dataverse. To do so, we will

Register an application in Azure Active Directory
Create an application user in the Power Platform Admin Center and assign a security role to it
Create a new connection in our flow

Let’s first tackle some auth basics

We need both the App registration and the security role as we need to cover

Authentication

Authentication refers to the identity of a user or an app, it’s the answer to the question Who is this?. You can think of it like your identity card or passport.

Authorization

Authorization refers to privileges of a user or an app, it’s answer to the question What are they allowed to do? You can think of it like a boarding pass for a flight.

In the end, you will need both documents to board/fly, as you will first need to prove your identity with your ID card/passport and then show your permissions to board a certain flight with your boarding pass (that also has your name/identity on it).

Register an application in Azure Active Directory

To handle authentication of our service principal, we need to register an application in Azure Active Directory. We will give this application a name and let Azure AD generate a username (App/Client Id) and password (Client secret) for it. If later a user or an application tries to log in, AAD will lookup Client Id and Client Secret and validate the identity. You can think of it like showing your passport with your picture to prove your identity.

To register an application in Active Directory, follow these steps:

Open portal.azure.com
Select Azure Active Directory
Select Add, then App registration
Enter a name for your app
Select Accounts in this organizational directory only
Select Register
Select Overview and copy Directory (tenant) ID and Application (client) ID - we will need these later
Select Certificates & secrets
Select New client secret
Select Add
Save the value of this secret somewhere - we will need this later
NO (and I repeat: NO API PERMISSIONS)

(Let’s revisit my last point a little bit later)

Create an application user in the Power Platform Admin Center and assign a security role to it

Now that we created our passport, we need to tell Dataverse about this app and relate this to a security role that will ultimately grant the connection access to the tables we want it to have access.

Head over to aka.ms/ppac to access the Power Platform Admin center
Select an environment of your choice
Select Settings
Select Users + permissions
Select Application users
Select New app user
Select Add an app
Select the app that you registered in the step before
Select Add
Select the appropriate Business unit
Select the pen icon next to Security roles
Add a security role, for example System Administrator (God mode)
Select Save
Select Create

What we now did is, we print our boarding pass with name and flight number on it. The System Administrator role may access every table and we assigned this role to an app that we registered in Active Directory.

Create a new connection in our flow

Now let’s create a flow and test this in action:

Open flow.microsoft.com
Make sure that you are in the same environment as your created your application user in
Create a new flow, it can be as simple as

On the ellipsis menue ... of the Dataverse action, select Add new connection
Select Connect with service principal
Give the connection a name
Fill in Tenant Id, Client Id, and Client secret
Select Create
Save your flow

By this we created a new connection that uses the Dataverse application user, to which we assigned the security role System Administrator.

Little discussion of API permissions

Next up: Run your flow - you will see, that it runs without any error - especially without any 403 error, which would mean Forbidden/missing privileges.

I saw in some blog posts (and I stumbled over that myself as well 🙄), that authors instruct to assign API permissions to the app registration, specifically Dynamics CRM –> user_impersonation.

This is relatable, if you do not realize, that security roles are the only way to control access (permissions) in Dataverse. Especially if you are familiar with app registrations that will enable apps to call Microsoft Graph API for example, you know the concept of an app registration with then one or multiple permissions that need to be assigned to it in order to make things work. It is therefore easy to fall into this trap when its about Dataverse/Dynamics CRM. But, unlike in Microsoft 365, we have security roles in Dataverse, which means that we do not need to take care of authorization (boarding pass) in the app registration but can use pre-defined or custom-tailored roles to give privileges.

The only permission scope for Dynamics CRM that we can find in the App registration is user_impersonation (Delegated), and it doesn’t make sense to select this, as our service principal in fact does application-only auth. Still I have been guilty of doing the same thing, as I was not really aware of this and didn’t fully understand security roles.

Feedback and what’s next?

Let me know, were you aware of how security roles of an application user and a service principal connection in a Power Automate flow interact with each other? Or did you also use user_impersonation scope? Let’s talk on twitter :-)

How to get the hex color value from a control in Power Apps

Mon, 25 Jul 2022 09:43:56 +0000

Sometimes, we want to output a color of a control as a hex value in a Power Apps canvas app. Unfortunately, there is no easy built-in function to convert an RGBA value into a hex color value in Power Apps. Still it is doable!

How do hexadecimal colors work?

To understand better what we want to convert our button1.Fill into, let’s first cover how hex colors work. Hex is the abbreviation of hexadecimal, which means Base 16. We humans normally count Base 10, as we have 10 digits - 0-9. To count Base 16, we need to have 6 digits more than 0-9, as as we ran out of digits (10, 11, 12 etc can’t do that job as they are not single digits but already 2-digit numbers), we use a trick and use A, B, C, D, E, F in addition to 0-9.

Hex colors can either br written in 6 digit or 8 digit notation.

6 digit notation: a pound symbol/hash # and then 6 digits (2 for the Red (R) value, 2 for the Green (G) value, 2 for the Blue (B) value)
8 digit notation: a pound symbol/hash # and then 8 digits (2 for the Red (R) value, 2 for the Green (G) value, 2 for the Blue (B) value, 2 digits for the alpha value that determines the transparency of the color)

If we now set the Fill property of a button1 to RGBA(100,100,100,1, we can use the JSON function to get the 8 digit hex notation:

Set(
gbl_colorAsHex,
JSON(
button1.Fill,
JSONFormat.IgnoreUnsupportedTypes
)
);

This will return "#646464ff". Please note that this value

is encapsulated by double quotes
is written in 8 digit notation

As we want 6-digit hex notation, we will use some Regex magic and match this value with #[a-fA-F0-9]{6} which will return #646464.

To unpack what #[a-fA-F0-9]{6} means:

# means that our string needs to start with a pound symbol #
[a-fA-F0-9]{6} represents the letters from a-f, A-F, or digit from 0-9 with a length of 6

Code looks like this then:

Set(
gbl_colorAsHex,
Match(
JSON(
button1.Fill,
JSONFormat.IgnoreUnsupportedTypes
),
"#[a-fA-F0-9]{6}"
).FullMatch
);

Now we can use the gbl_colorAsHex variable to color other controls or to output the hex value on a text label

I used this in the Power Apps Color Contrast Checker, the result looks like this:

Feedback and What’s next?

I am curious which use cases you see? Let me know on twitter!

How to build a Power Apps Likert component

Tue, 19 Jul 2022 16:11:14 +0000

tl;dr

Power Apps components allow makers to reuse fragments and patterns of their work to ensure design consistency and developer productivity. This Likert component showcases also custom properties and is an alternative way to gather data from users.

What are components and why would you want them?

Makers can create reusable building blocks and save them as components to either use them in a specific app or to use them across apps with a component library. Benefits of creating components:

build once, use repeatedly - no need to reinvent the wheel over and over again
if a component needs to be updated, it is updated once which will be reflected in all instances that are used inside of an app
design consistency
enhanced user experience due to standardization
increased developer velocity
improved productivity

Creating components is an investment into better performing, good looking, easy debuggable and maintainable apps. It’s true, that the initial effort of building them is a bit higher than using regular controls (when only used one time), but the more a component is used and the more complex an app gets, the better is the return on investment of creating components.

Likert component: result

To give you an idea how the likert component looks like, you can watch it here in action

Nice thing about it: It is already working in three different themes (default, dark, high contrast) and the design matches Microsoft Teams. To make this happen, we need to adjust the OnStart property of our app to this code:

// THEME
Set(
gblThemeDark,
Param("theme") = "dark" Or drp_dropdown.SelectedText.Value = "dark"
);
Set(
gblThemeHiCo,
Param("theme") = "contrast" Or drp_dropdown.SelectedText.Value = "high contrast"
);
Set(
gblAppColors,
{
// Fluent Design Colors
HighContrastDisabled: ColorValue("#2EF149"),
HighContrastHyperlinks: ColorValue("#FFFD39"),
HighContrastSelectedBackground: ColorValue("#00EBFD"),
HighContrastSelectedText: ColorValue("#000000"),
NeutralWebGray30: ColorValue("#EDEBE9"),
OverlayTransparent: RGBA(0,0,0 0),
TeamsDarkTint10: ColorValue("#6264A7"),
TeamsDefaultPrimary: ColorValue("#6264A7")
}
);

Build the component

Create a new canvas component and add

a slider control
a gallery with
- a textlabel
- an icon

Create custom properties:

SliderStyles as Record, add this code:

{
BorderColor:
If(gblThemeHiCo,gblAppColors.OverlayTransparent,gblThemeDark,gblAppColors.OverlayTransparent,gblAppColors.OverlayTransparent),
DisabledBorderColor:
If(gblThemeHiCo,gblAppColors.HighContrastDisabled,gblThemeDark,gblAppColors.NeutralWebGray150,gblAppColors.NeutralWebGray30),
FocusedBorderColor:
If(gblThemeHiCo,gblAppColors.HighContrastSelectedBackground,gblThemeDark,gblAppColors.TeamsDarkTint10,gblAppColors.TeamsDefaultPrimary),
HandleActiveFill:
If(gblThemeHiCo,gblAppColors.HighContrastHyperlinks,gblThemeDark,gblAppColors.TeamsDarkTint10,gblAppColors.TeamsDefaultPrimary),
HandleFill:
If(gblThemeHiCo,gblAppColors.HighContrastHyperlinks,gblThemeDark,gblAppColors.TeamsDarkTint10,gblAppColors.TeamsDefaultPrimary),
HandleHoverFill:If(gblThemeHiCo,gblAppColors.HighContrastHyperlinks,gblThemeDark,gblAppColors.TeamsDarkTint10,gblAppColors.TeamsDefaultPrimary),
RailFill:
If(gblThemeHiCo,gblAppColors.HighContrastHyperlinks,gblThemeDark,gblAppColors.TeamsDarkTint10,gblAppColors.TeamsDefaultPrimary),
RailHoverFill:
If(gblThemeHiCo,gblAppColors.HighContrastHyperlinks,gblThemeDark,gblAppColors.TeamsDarkTint10,gblAppColors.TeamsDefaultPrimary),
ValueFill:If(gblThemeHiCo,gblAppColors.HighContrastHyperlinks,gblThemeDark,gblAppColors.TeamsDarkTint10,gblAppColors.TeamsDefaultPrimary),
ValueHoverFill:
If(gblThemeHiCo,gblAppColors.HighContrastHyperlinks,gblThemeDark,gblAppColors.TeamsDarkTint10,gblAppColors.TeamsDefaultPrimary),
Default:3
}

which references the colors of the slider control to the ones that we set in OnStart of the app and sets the default value to 3.

GalleryStyles as Record, add this code:

{Color: gblAppStyles.Label.Color}

which references the colors of textlabel and icon

LikertContent as Table, add this code:

Table(
{
Id: 1,
Body: "Strongly Disagree",
Icon: Icon.EmojiFrown
},
{
Id: 2,
Body: "Disagree",
Icon: Icon.EmojiSad
},
{
Id: 3,
Body: "Neutral",
Icon: Icon.EmojiNeutral
},
{
Id: 4,
Body: "Agree",
Icon: Icon.EmojiSmile
},
{
Id: 5,
Body: "Strongly Agree",
Icon: Icon.EmojiHappy
}
)

which populates our gallery with an id (serves also as rating), the text to be displayed in the label and the icon to be displayed.

OnChange Behavior as Text, add one parameter Rating as Number. When we later ad an instance of our component to an app, we will call this function and update it to pass the current value from the slider.

Work on the Slider

Set the Default property to cmp_Likert.SliderStyles.Default
Set the OnChange property to cmp_Likert.OnChange(sli_Rating.Value)

Work on the Gallery

Set the Items property to cmp_Likert.LikertContent
Set the Icon property of the icon to ThisItem.Icon
Set the Text property of the textlabel to ThisItem.Body
Set the Height and Width properties of the icon to If(sli_Rating.Value= ThisItem.Id, 30, 20)
Set the Size property of the textlabel to If(sli_Rating.Value= ThisItem.Id, 11, 9)
Set the FontWeight property of the textlabel to If(sli_Rating.Value= ThisItem.Id, Bold, Normal)
Set the Color property of the icon to If(sli_Rating.Value= ThisItem.Id, cmp_Likert.SliderStyles.HandleActiveFill, cmp_Likert.GalleryStyles.Color)

Add the component to your app

Now that our component is complete

Add it to the app
Set the OnChange property to Set(gbl_likeValue, Rating)

What happens now is, that when you move the slider, the current value label and emoji are emphasized and a we store the current value in a variable.

Feedback & What’s next

I am curios - where would you use such a component? Can it replace rating DataCards? Which enhancement would you like to see? Tell me on twitter.

How to implement a Power Automate progress indicator in Power Apps

Mon, 11 Jul 2022 17:37:29 +0000

tl;dr: An indicator to show the progress of a Power Automate flow

Especially when users need to perform several tasks to complete a workload, they like to know, if the thing worked. Simple notifications like “your request has been submitted” still leave them in some uncertainty in regards of the progress of said process. Learn here how a simple SharePoint list can help you to achieve exactly that.

First idea: Respond to Power Apps

In Power Apps, we can start Power Automate flows and even get a response back, Lewis Baybutt recently blogged about how to Notify users if the flow ran successfully. But what if the flow has several big steps and we want to inform users along the way in Power Apps? Unfortunately, we can’t use the Respond to PowerApps action more than one time in a flow, which means that this is already out of the game.

Second idea: External datasource to the rescue

But what if we logged steps/status of our flow into an external table and update our app from there? This could be a Dataverse table, a SharePoint list or whatever makes you happy.

In total we will need

SharePoint list setup

I used a SharePoint list called LogList in which I need 3 columns:

Title (comes already out of the box)
GUID (single line of text, to hold a GUID that we get from Power Apps as we want to use LookUp to get the right flow run)
Status (number, to hold the status/step of the flow progress)

Power Apps setup

In our Power App, we need

a button which will start the flow
a timer which will take care of refreshing
a gallery to indicate progress

Gallery

For everything, that needs to be repeated, I use a gallery in Power Apps. The effect on time to build, design consistency and performance is really amazing.

Set the Items property to

Table(
{
Id: 1,
Value: "validated data",
Icon: Icon.Check
},
{
Id: 2,
Value: "approval pending",
Icon: Icon.Check
},
{
Id: 3,
Value: "approval granted",
Icon: Icon.Check
}
)

Add a Label, a Rectangle, an Icon, a Circle to the Gallery
Set the Text property of the Label to ThisItem.Value
Set the Visible property of the Rectangle to If(loc_currentStatus.Status>=ThisItem.Id, true, false)
Set the Fill property of the Circle to If(loc_currentStatus.Status>=ThisItem.Id, Self.BorderColor, Transparent)
Set the Visible property of the Icon to loc_currentStatus.Status>=ThisItem.Id
Set the Icon property of the Icon to Icon.Check

Button

Our Button shall kick of the flow and pass in a unique ID

Set the OnSelect property of the button to

//create GUID
Set(gbl_stateGUID,GUID());
//start Power Automate Flow
flowStatus.Run(gbl_stateGUID)

Timer

We could of course build a refresh button as well for all impatient users, but a hidden timer is way more elegant.

Set the OnTimerEnd property to

Refresh(LogList);
UpdateContext({loc_currentStatus: LookUp(LogList,GUID=Text(gbl_stateGUID))})

Set the AutoStart property to !IsBlank(gbl_stateGUID)
Set the Duration property to 500 (ms)
Set the Repeat property to loc_currentStatus.Status<>3

Reset button

For testing purposes its really nice as well to have a Reset button

Set its OnSelect button to

UpdateContext(
{
loc_currentStatus: Patch(loc_currentStatus,
{
Status: 0,
Title: "you submitted"
}
)
}
);
Set(gbl_stateGUID,"");

Power Automate flow setup

Create a new flow from within Power Apps Studio, which automatically gives it the right trigger
Create an item in your SharePoint list, pass in the GUID from Power Apps in the GUID column and set the status to 0
Now add a scope and perform the actions you want to perform in this scope. To mock this, I added a delay
After this first scope, update the list item with a status message in the Title and set the Status to 1
Add another scope and perform the actions you want to perform in this scope. To mock this, I added another delay
After this second scope, update the list item with a status message in the Title ands et the Status to 2
Add another scope and perform the actions you want to perform in this scope. To mock this, I added another delay
After this third scope, update the list item with a status message in the Title and set the Status to 3

Conclusion and What’s next

This is how you pass values between Power Apps and Power Automate and hook them into a nice looking UI. For flows that run for quite a while, its a nice way to inform users in-app and not to rely on sending Adaptive Cards or other notifications. I am curious: Which scenarios do you see? Let me know on twitter

How to enhance maker experience with a custom theme for Teams apps

Wed, 06 Jul 2022 11:51:35 +0000

tl;dr

Creating beautiful UI in Power Apps canvas apps is hard - even more when the app shall run in the context of Microsoft Teams, as there is no theme out-of-the-box that matches Teams look and feel or supports accessibility in terms of adapting to default, dark, and high-contrast mode.

Design

When building UI in canvas apps, we have some options to apply a certain design to our app. If we want to build an app that runs in Teams, we should aim for a Teams native looks & feel. Let me explain, the good, bad an ugly :-)

The ugly

Unimaginable, but still the very ugly truth: People live with the default styles or only apply minimal styling to any controls. Their apps then look like this:

Now this is not just about my personal taste, but very obviously, this app neither matches the Teams Design, nor is it inclusive and accessible to all people, as it lacks of default, dark and high-contrast mode.

The bad

We can style each and every single button, text label, input, dropdown etc. to match our design requirements. This will often result in styling one of each correctly and then copy-paste them. It is a tedious task and very often makers tend to try to shortcut this task which then results in poor DevX and inconsistent UI.

The Good

Of course, there are better options. The default style of all controls is determined by the themes.json file that we can find in the unpacked .msapp file of the app. We can unpack the .msapp with Power Platform CLI, then manipulate the file by changing values for all the properties that we want to change and then re- pack the source code files so that they make up an .msapp again. By applying all the Teams-appropriate colors, shapes, sizes, fonts, we can achieve an almost-native look and feel just with the (new) default controls.

The Better

However, you will have stumbled upon the almost :-) To match the Teams look, some controls need styling that can neither be applied by manipulating themes.json nor be achieved in Power Apps Studio. Let me give you two examples:

Example: Input field

For an input field, we need a border only at the bottom of the control, for which we don’t have a property in Power Apps Studio, nor in the themes.json.

Example: Calendar control

Even with manipulated values in themes.json, the calendar pop-up of the datepicker control doesn’t fully match Teams’ design when we apply dark mode or high contrast - which means that this is design-inconsistent and not accessible.

To illustrate this: On the left is the default calendar, the fill color of the header can not be styled within Power Apps studio. In the middle is the calendar already styled with the properties that we can find in theme.json, however, the background fill color can’t be changed. On the right is the custom canvas component, that nicely adapts to all three Teams themes.

Even if we do not need these particular controls, usually we can only see very basic UI in PowerApps, which is a big contrast to the advanced and slick UI of Microsoft Teams. Ever saw such a carousel in a Power App?

Solution: Teams theme & reference app and 10 components

To tackle this, I did not only create a Teams-design-matching themes.json for you, but also a reference app, that allows you to switch between default, dark, and high-contrast mode and also 10 canvas components for regular controls like input field or dropdown menu but also for more advanced UI snippets like the carousel component (as shown above), the calendar component, and more.

All components adapt to default, dark, and high-contrast mode and are also used in example screens that serve as inspiration how a Teams app can look like. You can find this in the PowerApps-samples repo on GitHub.

But aren’t there OOTB alternatives?

Power Apps Studio knows the concept of themes like PowerPoint does - but apparently no one thought about implementing a Teams theme into Power Apps studio directly so that this goodness is available to all makers just via UI.
Microsoft’s recently released Creator Kit for makers doesn’t offer Microsoft Teams specific Fluent UI components, but only Office specific Fluent UI components.
Within Power Apps Studio in Microsoft Teams we have access to Fluent UI controls but they neither match Office (Fluent UI) nor Teams (Fluent UI Northstar), as a button for example has no rounded corner (Office) but has a default Fill of 6264A7, which is ‘Teams blurple’. This means, that this is a very weird mix of both design approaches :-(

Feedback and what’s next?

In my opinion, a dedicated Teams theme, a component library with common UI elements and guidance how to work with it should’ve been in the product - as of day 1.

Let me know what you think on twitter.

How to build a color-contrast-ratio checker for improved accessibility in Power Apps

Sun, 03 Jul 2022 12:53:04 +0000

tl:dr

Color contrast ratio is important for accessibility - here is how to build an in-app checker to build more accessible Power Apps

What is an color-contrast-ratio checker and why would I care?

Although Power Apps studio has a built-in Accessibility checker, which warns makers if they for example forgot an AccessibleLabel which is used by screen reader applications to announce what a control is about, it doesn’t cover any issues that might occur regarding the contrast of used colors.

This means, that makers don’t get a warning when they choose colors that don’t match accessibility standards. The Power Apps documentation recommends a color contrast ratio for texts and backgrounds of at least 4.5:1 and for large text of at least 3:1, however there is no guidance on how to calculate this ratio and even then, the information is not where makers need them - in their app.

Accessibilty is one of the most crucial design goals for every app and every website as we do not aim to proactively exclude people because we do not match their needs with appropriate features.

Idea: Color-Contrast-Ratio checker for Power Apps -in Power Apps

What if makers had an app or even a hidden screen in all of their apps where they can check contrast ratio in the early stage of app development to avoid accessibility issues that are not addressed by the Power Apps Accessibility Checker?

Requirements

Let makers easily change the primary color and background color of their app
Automatically calculates if the color contrast ratio is sufficient to fulfill WCAG 2.1 Success Criteria
Informs maker about the outcome of that calculation

How to let makers easily change the primary color and background color of their app

Insert some controls (buttons, TextLabels, Icons, TextInput, etc.) on your screen
Insert 3 slider controls reflecting the RGB values for the primary color
Set the Max property of all 3 sliders to 255
Rename the sliders to sli_Red, sli_Green, and sli_Blue
Insert a Button on the screen, rename it to btn_primaryColor
Set its Fill property to RGBA(sli_Red.Value, sli_Green.Value, sli_Blue.Value,1) - This button will now be our reference for the primary color the entire app
Insert another 3 slider controls reflecting the RGB values for the Background
Set the Max property of all 3 sliders to 255
Rename them accordingly
Insert another button on the screen, rename it to btn_backgroundColor
Set its Fill property to RGBA(sli_Red_1.Value, sli_Green_1.Value, sli_Blue_1.Value,1) - This button will now be our reference for background color in the entire app
Set the Text property of the btn_primaryColor to "primary color: RGB(" & sli_Red.Value & ", " & sli_Green.Value & ", " & sli_Blue.Value & " ,1) "
Set the text property of the btn_backgroundColor to "background: RGB(" & sli_Red_1.Value & ", " & sli_Green_1.Value & ", " & sli_Blue_1.Value & " ,1) "
Set the Fill property of your screens background to btn_backgroundColor.Fill
Set the Fill property of the buttons you inserted in step 1 to btn_primaryColor.Fill
Set the Color property of the TextLabel you inserted in step 1 to btn_primaryColor.Fill

If you now use the sliders for background color and primary color, you can see that the color of your two reference buttons changes and with them the entire color scheme of your app.

How to automatically calculate if the color contrast ratio is sufficient to fulfill WCAG 2.1 Success Criteria

Let’s first understand what needs to happen so that we can implement this in our app: For matching the WCAG 2.1 Success Criteria we need to take care of two important values:

brightness difference
color difference

The brightness difference is calculated as (299*R_pc + 587*G_pc + 114*B_pc)/1000 - (299*R_bg + 587*G_bg + 114*B_bg)/1000, where as R , G, B stands for Red, Green, Blue and _pc stand for primaryColor and _bg stands for BackgroundColor. The result of this calculation needs to be a number > 125.

In our app we will therefore calculate the brightness difference with (299*sli_Red.Value + 587*sli_Green.Value + 114*sli_Blue.Value)/1000 - (299*sli_Red_1.Value + 587*sli_Green_1.Value + sli_Blue_1.Value*114)/1000

The color difference is calculated as -((R_pc - R_bg) + (G_pc - G_bg + (B_pc - B_bg)). The result of this calculation needs to be a number > 500.

In our app we will therefore calculate the color difference with -((sli_Red.Value -sli_Red_1.Value) + (sli_Green.Value-sli_Green_1.Value ) + (sli_Blue.Value-sli_Blue_1.Value))

💡 Important: Both conditions need to be fulfilled.

How to indicate the outcome of that calculation

Easiest part is now to make the result of these calculations visible to makers:

Insert a text label for lblbrightnessDifference and set the Text property to the brightness formula shown above
Set the Color property to If(Value(Self.Text) < 125, Red, Black)
Insert a text label for lblColorDifference and set the Text property to the color formula shown above
Set the If(Value(Self.Text) < 500, Red, Black)
Insert another text label and set the Text property to If(Value(lblColorDifference.Text) < 500 Or Value(lblBrightnessDifference.Text) <125, "failed color contrast check according to W3.org", "passed color contrast check according to W3.org")

Update: v1.1 of the color contrast checker is now available on GitHub

I worked on additional features:

display the hex color value of an RGBA value
have Textinput fields for accurate input of RGBA values

hexcolor - Regex to the rescue

Unfortunately, there is no easy built-in function to convert an RGBA value into a hex color value in Power Apps, still it is doable! I wrote in a separate post on how to get hex-color value in Power Apps

Input fields

Create an input field for every slider, I will use the sli_Red as an example:
Set the OnChange of the input field to

If(
Value(Self.Text) > 255 || Value(Self.Text) < 0,
Notify(
"please enter a value between 0 and 255",
NotificationType.Error
)
);
Set(
defaultRed,
Value(Self.Text)
);

Set the Default property of the input field to sli_Red.Value
Set the Default property of the slider defaultRed

The result can look something like this:

You can find the updated source code and solution in my personal GitHub account, a PR to PNP/powerapps-samples is pending, I will update accordingly once this is processed.

What are your thoughts?

How do you improve color contrast ratio in your apps and make sure that you comply to WCAG 2.1 Success Criteria? Let me know on twitter.

Get insights about Power Apps usage with Microsoft Clarity PCF code component

Tue, 21 Jun 2022 11:00:28 +0000

Getting insights on user behavior in Power Apps canvas apps can be in various ways - for instance, you can analyze app telemetry with Azure Application Insights and trace events. If you are more interested in visual heatmaps and session recordings, you might already have had a look at Microsoft Clarity, which exactly provides that:

What is Microsoft Clarity and how do I connect it to a Power Apps canvas app?

Clarity is a user behavior analytics tool that helps you understand how users are interacting with a website through features such as session replays and heatmaps. It is installed by adding a tracking code into the <head> section of the website.

As a Power Apps canvas app running in the browser is also still just a website, we only need to find a way on how to inject the Clarity JavaScript script into the head of our canvas app.

Unfortunately, there is no connector for Microsoft Clarity, but we can leverage the Power Apps component framework for that.

Power Apps component framework to the rescue

With Power Apps component framework we can create code components for Power Apps. I created a code component for Microsoft Clarity, so that we can use Clarity in our canvas apps.

High level overview

To give you an idea on how to create this, here is high level overview- it’s not meant to replace extensive learning with very detailed step-by-step instructions though. I will link to resources though if this is your first code component - it was my first :-)

Sign up for a free Clarity account
Set up your project

Use Power Platform CLI to create the code component
In the scaffolded project, locate ControlManifest.Input.xml and index.ts
Update the ControlManifest.Input.xml file to

<?xml version="1.0" encoding="utf-8" ?>
<manifest>
 <control namespace="ClarityNameSpace" constructor="ClarityCodeSnippet" version="1.0.0" display-name-key="ClarityLovesPowerApps" description-key="Clarity Code Component to analyze user behavior" control-type="standard" >
 <property name="YourClarityProjectID" display-name-key="<your-clarity-project-id>" description-key="description" of-type="SingleLine.Text" usage="bound" required="true" />
 <external-service-usage enabled="false">
 </external-service-usage>
 <resources>
 <code path="index.ts" order="1"/>
 </resources>
 </control>
</manifest>

In the index.ts file, we first need a private _Container: HTMLDivElement; above the constructor
then add the following code to the init method

 public init(context: ComponentFramework.Context<IInputs>, notifyOutputChanged: () => void, state: ComponentFramework.Dictionary, container:HTMLDivElement): void
 {
 const head = document.getElementsByTagName('head')[0];
 const script = document.createElement('script');
 script.innerHTML = '(function(c,l,a,r,i,t,y){c[a]=c[a]||function(){(c[a].q=c[a].q||[]).push(arguments)};t=l.createElement(r);t.async=1;t.src="https://www.clarity.ms/tag/"+i;y=l.getElementsByTagName(r)[0];y.parentNode.insertBefore(t,y);})(window, document, "clarity", "script", "<your clarity project id>");'
 head.insertBefore(script, head.firstChild);
 const textDiv = "<div>We are tracking this app with Microsoft clarity, have a lovely day!</div>"


 this._Container = document.createElement("div");
 this._Container.id = "ClarityDivID";
 this._Container.innerHTML = textDiv;

 container.appendChild(this._Container);
 }

Packageand Build your component
Import your code component solution
Add your code component into a Canvas App
Don’t forget to (re-) publish your app ;-)

When you now use the app, you can open Edge Dev tools on the Network tab and see the work Clarity is doing:

How does this now look like in our Canvas app?

In your Canvas app, you can either style your code component or you can set the Visible property to false to hide it.

It takes a decent while (I guess about 90 minutes) for data to arrive for the first time in Clarity, but after that it runs smoothly - here is how the dashboard then looks like:

If we now want get more into the details of users are interacting with our apps (sometimes easier than asking them), we can watch a replay of the session recordings:

This gives us information on where users click, scroll and type.

Heatmaps are a valuable feature to determine which parts of an app are most selected:

Where to find the component

You can find this component on my GitHub - Let me know if you have questions!

How to rename files in SharePoint with Power Automate

Wed, 27 Apr 2022 10:48:16 +0000

the issue

Although SharePoint and Power Automate are heavily interwoven, there is no “rename file” action in Power Automate - if the file lives in a SharePoint library. Out of the box that is only possible for files living in OneDrive.

I recently saw a cry for help on twitter and decided to share here how my solution looks like.

In order to change a filename, we will need to use SharePoint REST API, which is accessible to us in Power Automate via the Send an HTTP request to SharePoint action.

the Power Automate flow

To make things easy, we start with a For selected file trigger. (In a real-world scenario, you’d typically rename a file after something else has happened.)
We then Get file properties (not needed as we already have the ID from the For selected file trigger, but if you run this after another action you will need the file properties to get the ID so that you can rename the right file).
We now need to use the Send an HTTP request to SharePoint action:
- Site Adress: choose from Dropdown
- Method: Get
- Uri: _api/lists/getbytitle('<DisplayName of your Library goes here>')
This will re turn the ListItemEntityTypeFullName property, which we will need for the next step.
As a last step, use another Send an HTTP request to SharePoint action:
- Site Adress: choose from Dropdown
- Method: Post
- Uri: _api/lists/GetByTitle('<DisplayName of your Library goes here>')/Items(@{outputs('Get_file_properties')?['body/ID']})
- Headers:
  - Content-type: application/json
  - IF-MATCH: *
  - X-HTTP-METHOD: PATCH
- Body:

{'__metadata':
{'type':'@{outputs('Send_an_HTTP_request_to_SharePoint_to_get_type')?['body']?['d']?['ListItemEntityTypeFullName']}'},
'FileLeafRef':'<your new filename goes here>'}

For the type, we are selecting the ListItemEntityTypeFullName property from the output of the previous action. You could also use Parse JSON action to obtain that value.

Conclusion

Once again, the Send an HTTP request to SharePoint action in Power Automate is a lifesaver for everything that doesn’t work with the built-in actions. Also, no additional license than your Microsoft 365 license is required to use it.

Resources

To learn more about SharePoint REST, use these resources:

Feedback & what’s next?

I’d love to know what are your renaming-scenarios and also what you use the Send an HTTP request to SharePoint action for! Let me know on twitter.

how to use oh-my-posh with PnP PowerShell

Sun, 17 Apr 2022 07:53:14 +0000

What is oh my posh?

Oh-my-posh is an amazing prompt engine that does not only pretty up the terminal you use, but it will ease your work. By using an established theme or creating a new one, you get important information directly in the context of your work, highlighted in the way that works best for you. For example:

In which repository am I working in?
Which branch?
When did I execute a command?
On which node.js version am I working?

the M365Princess theme by Luise plus environment variables by Anoop

Making good things even better: A while ago, Luise created her own theme and now Anoop had the idea to level it up:

When interacting with Microsoft 365, most of the times we use the Microsoft 365 platform community driven PowerShell module called PnP PowerShell. One of the first commands we execute while using PnP PowerShell, is Connect-PnPOnline to connect to a SharePoint site. We can now see right in the terminal which SharePoint site we are connected to and which Microsoft 365 tenant the SharePoint site lives in.

These are displayed with the help of a couple of environment variables that are set by PnP PowerShell after running the Connect-PnPOnline command.

In the preview below, the connected SharePoint site is /sites/yoursite which is in the tenant named yourtenant.sharepoint.com

The original idea to show these values comes from Erwin van Hunen, the father of PnP PowerShell.

How to install oh-my-posh and the theme

To have this experience in Visual Studio Code, complete the following steps:

Install oh-my-posh and posh-git
- Open the the terminal and run
  - Install-Module oh-my-posh -Scope CurrentUser
  - Install-Module posh-git -Scope CurrentUser
Edit your PowerShell profile in VS Code
- Open it with code $PROFILE
- Insert this:

Import-Module oh-my-posh
Import-Module posh-git
Set-PoshPrompt -Theme M365Princess

Install a font
- Download a font of your choice from Nerdfonts
- Install a monospace version of that font
- Open settings in VS Code with CTRL + SHIFT + P and select Preferences: Open settings (JSON)
- Add (for example) "terminal.integrated.fontFamily": "CaskaydiaCove Nerd Font"
- Save settings and restart VS Code

Slow prompt?

In case the prompt is responding slow on Windows OS, then one of the reasons might be the oh-my-posh process being blocked by Windows defender. To overcome that, please run PowerShell with elevated permissions (Run as administrator) and execute the following command:

Add-MpPreference -ExclusionProcess "oh-my-posh.exe"

If that doesn’t solve the problem then, execute the following command

Add-MpPreference -ExclusionPath "$env:POSH_PATH\oh-my-posh.exe"

For more information see the comments this issue.

Conclusion

It’s the little things! Of course this is just one puzzle tile, but better overview, crucial information presented in a minimal but nerdy and compelling way helps people to ease their workloads. When working with PnP PowerShell, it’s a game changer to know to which of your tenants and sites you are connected to.

If you like the oh-my-posh and can afford it, go buy Jan, who builds and maintains this awesome open source project, a coffee ☕: oh-my-posh repository

sharing is caring

This post was written by Luise Freese and Anoop Tatti

How to query Azure Monitor Log Analytics in Logic Apps with a Managed Identity and output results in a SharePoint list

Wed, 13 Apr 2022 12:30:36 +0000

Azure Monitor Log Analytics is super powerful to collect data and give you insights on what’s going on with your apps and resources. There is even an Azure Monitor Logs connector for Logic Apps.

⚡ Very unfortunately, the connector doesn’t support authentication with a Managed Identity - which means that you’d need either to be a signed-in user or use an app registration, which comes with its own challenges on secret handling. I explained in my previous blog posts why Managed Identities are a way superior way to authenticate.

💡 Azure Log Analytics REST API to the rescue!

We can call the Azure Log Analytics REST API from Logic Apps with the generic HTTP action - and authenticate with a Managed Identity. For this example, I chose a user-assigned Managed Identity, so that you can reuse it across resources, but of course you can go with a system-assigned Managed Identity as well.

I wanted to create a sample on how to create a Logic App that queries Log Analytics with a user-assigned Managed Identity that has the Log Analytics Reader assigned. The Managed Identity also has Microsoft Graph permissions with scope Sites.ReadWrite.All assigned in order to create new items in a SharePoint list about the result of a query of Azure Monitor logs. That could be beneficial for users who don’t have access to the logs but should be notified or similar.

Deployment

Fork and clone this repository
Browse to the root folder in your clone
Connect to the Azure subscription that you want this to run in
Run the deploy.ps1 script, it will
- create the resource group
- create the resources
- assign the Log Analytics role to the Managed Identity
- assign Graph API Sites.ReadWrite.All permissions to the Managed Identity
You will be prompted to provide
- a location for your resources
- a Resource group name
- the siteID of the site your list lives in
- the listId of the list in which new rows shall be created

Validate deployment

Check in the Azure Portal after you read the success-message Resources deployed successfully, role assigned
- Resource group
- Logic App
- Azure Log Workspace
- Managed Identity

In the Logic App, the Authentication works with the Managed Identity
Our Managed Identity has the Log Analytics Reader role assigned
Our Managed Identity has the SitesReadWrite.All permission assigned

Our Logic App should look like this:

💡 Please make sure that you insert a query into the Logic app that makes sense depending on your scenario. Also adjust the body of the Create list item action to match your SharePoint list.

Conclusion

Connectors can be a good way to easily achieve what you need in Logic Apps. However, they sometimes don’t fit your scenario or don’t support your way of doing things - like I really like Managed Identities. Therefore, its always worth a try to call the API directly so that you do not need to rely on the wrapper.

Questions?

If you have questions, want to use this, make it better - please do! Find me either on twitter or on GitHub

sharing is caring

How to get started with deploying Azure resources with Bicep

Wed, 09 Mar 2022 18:30:05 +0000

What is Bicep?

Good question. First of all, it’s most probably Azure’s nerdiest dad joke, as it derives from ARM (Azure Resource Manager) and has something to do with the biceps doing the heavy lifting/provides extra power 💪.

Bicep is a language specific to Azure and is used to provide Infrastructure-as-Code in an easy-to-author way. Syntax is much simpler than regular ARM templates and this results in more readable files.

This sample shows how to deploy Azure Cognitive services.

param serviceName string = 'cognitive-${uniqueString(resourceGroup().id)}'
param location string = resourceGroup().location
param sku string = 'S0'

resource cognitiveService 'Microsoft.CognitiveServices/accounts@2017-04-18' = {
 name: serviceName
 location: location
 sku: {
 name: sku
 }
 kind: 'CognitiveServices'
}

If you compare this to the JSON definition, you will notice

less curly brackets
less quotation marks
less lines of code

{
 "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
 "contentVersion": "1.0.0.0",
 "metadata": {
 "_generator": {
 "name": "bicep",
 "version": "0.4.1008.15138",
 "templateHash": "3830258995596078"
 }
 },
 "parameters": {
 "serviceName": {
 "type": "string",
 "defaultValue": "[format('cognitive-{0}', uniqueString(resourceGroup().id))]"
 },
 "location": {
 "type": "string",
 "defaultValue": "[resourceGroup().location]"
 },
 "sku": {
 "type": "string",
 "defaultValue": "S0"
 }
 },
 "functions": [],
 "resources": [
 {
 "type": "Microsoft.CognitiveServices/accounts",
 "apiVersion": "2017-04-18",
 "name": "[parameters('serviceName')]",
 "location": "[parameters('location')]",
 "sku": {
 "name": "[parameters('sku')]"
 },
 "kind": "CognitiveServices"
 }
 ]
}

Time to play! If you like to familiarize yourself with Bicep, you can use the Bicep Playground - it’s an interactive experience that lets you explore and try out Bicep - similar to MGT Playground, Graph Explorer or Adaptive Cards Designer in a safe space where you can’t break anything. (I took the example from that Playground)

How do you create a Bicep template from an Azure resource?

In order to create a deployable Bicep file, we will need to use some tools. I will work on Windows and with Azure CLI, but you can of course choose Azure PowerShell as well or work on Linux or Mac.

Tools

In Visual Studio Code (VS Code), install the Bicep extension. (Most probably you will need to restart VS Code after installing the extension.)
Install Azure CLI - You can validate which version you have installed when you run az --version in your terminal.
Install Bicep CLI in terminal by running az bicep install. If you did that already a while ago, it’s a good idea to upgrade to the latest version with az bicep upgrade

Get the ARM template

You could of course write the entire definition of your resources from scratch (and with the extension installed you get Intellisense, which is really convenient), but as you probably already built resources, you can go to the Azure portal and export the ARM template:

Open the Azure portal
Select the resource group
If you want to export a template for the entire resource group including all resources
- select Export template
If you want to export only the template for a particular resource
- select the resource
- select Export template
Extract the downloaded .zip file
Open the extracted template.json file in VS Code

Decompile

Open the terminal
Navigate to the folder where your template.json file sits
Run az bicep decompile --file template.json

This will create a new file template.bicep. To make this template file better, we will do a few things:

Modules

If you want to deploy more than one resource, you will end up with a very lengthy file, which makes it hard to gain overview - also collaboration and debugging is hard with that. Luckily, Bicep knows a concept that is called modules, which are also Bicep files that can be deployed from a root Bicep file. You can even share modules for reusing modules in your organization.

This is how we do it:

Select the resource in the template.bicep file
Cut it and paste it into a new Bicep file (e.g. My-managedIdentity.bicep)
Repeat this with the other resources as well
Now create modules in template.bicep like this:

module managedIdentityDeployment 'My-managedIdentity.bicep' = {
 name: 'managedIdentityDeployment'
 params: {
 userAssignedIdentities_My_Identity_name: userAssignedIdentities_My_Identity_name
 resourceLocation: resourceLocation
 }
}

Make sure that you declare the parameters in the file as well. Repeat this until have a module for each resource that is defined in a corresponding Bicep file.

Few tweaks and quirks

If - in your exported template you had hard coded values that you still want to get rid of - this is a good time to do that:

resource workflows_MyWorkflow_name_resource 'Microsoft.Logic/workflows@2017-07-01' = {
 name: workflows_MyWorkflow_name
 location: 'westeurope'
 identity: {
 type: 'UserAssigned'
 userAssignedIdentities: {
 '/subscriptions/fdf0XXX-0726-404c-XXX-23d183XXX/resourceGroups/MyResourceGroup/providers/Microsoft.ManagedIdentity/userAssignedIdentities/My-ManagedIdentity': {}
 }
 }
}

We would replace the hard coded value of the userAssignedIdentities that contains our Subscription Id with

{
 '${resourceId('Microsoft.ManagedIdentity/userAssignedIdentities/',userAssignedIdentities_My_Identity_name)}': {}
}

Also, we would replace the hard coded value 'westeurope' with a parameter.

Sometimes when decompiling, we don’t get the right API version - in this case we got 2017-07-01 - but in fact 2019-05-01 is correct. How would we know? Bicep extension warns us with yellow squiggly lines :-)

Deploy with Azure CLI

Now let’s deploy this to Azure! Again, we will be using Azure CLI

$DeployTimestamp = (Get-Date).ToUniversalTime().ToString("yyyyMMdTHmZ")
az deployment group create `
 --name "DeployLinkedTemplate-$DeployTimestamp" `
 --resource-group $ResourceGroupName `
 --template-file path-to/template.bicep `
 --verbose

That’s it 🚀

What do you think?

Let me know on twitter

How to be better at twitter - part 2

Wed, 09 Mar 2022 10:35:59 +0000

In one of my last blog posts, I covered How to be better at twitter, sharing some insight about tools and when to mention people and I got a lot of good feedback for that, which is why I want to share some more tips here in part 2.

De-clutter your feed

Are you following lots of people? Like, hundreds, or even thousands? Then most probably, your feed looks like this

tweet of a person you follow
advertisement
reply to a tweet of a person you follow
tweet of which twitter thinks it is interesting for you
tweet of a person you follow
tweet that is liked by a person you follow
tweet by a person a lot of accounts you follow follow

If you are bit like me, not all of that is relevant to you. If you use the twitter web app, type into the search bar: filter:follows -filter:replies - which means that you only get tweets by accounts you follow, but not the replies into your feed. This of course does not mean that you can’t read replies.

You can now save this search

Alternative: type in this as the URL

https://twitter.com/search?q=filter%3Afollows%20-filter%3Areplies&src=saved_search_click

https://twitter.com/search?q=filter%3Afollows%20-filter%3Areplies&src=saved_search_click&f=live

if you want the latest tweets on top.

When to use what

Do you know when you should like, reply, retweet or quote-retweet (QT)?

The official consultant answer of course it - it depends

(sticker by PimpYourOwnDevice.com)

💡 tl;dr: replies have the biggest impact

Lets explore our motivation and what we want to achieve:

like = support

With a like you show support for someone’s tweet or reply. You also let them know that you read their tweet. Those likes only shows up in people’s feed if they don’t filter their feed. If they do not filter, then those tweets do show up in their feeds, but most probably so do hundreds or thousands of other likes of people they follow. This means that they will be overwhelmed and don’t really read but doom-scroll.

A like therefore is a good way to show someone: I saw and support this, but it is not a good way to engage with an audience beyond the person who tweeted what you liked.

retweet = attention for a tweet

With a retweet, you share a tweet to your followers. This makes sense, if you feel a tweet doesn’t get enough or the attention of the right (?) people. Please be aware that if you overuse retweets by only retweeting other people’s tweets or by only retweeting tweets inside of a very focused filter-bubble, people will turn off your retweets

(select the ... on a person’s profile and select Turn of Retweets)

because it is too noisy. While retweets (depending on your follower count) bring attention, they don’t drive engagement, which means that you broadcast in a one-way manner without encouraging others to get involved or join the discussion.

quote-retweet = attention for yourself

With a quote-retweet you take the discussion out of its original context and make it about your thoughts. To give you an analogy: Imagine you are in a big room full of people, there are small groups everywhere and you discuss something with a few people. Now one person walks by, and decides to talk about the exactly same topic - but somewhere else and without the people that already joined your talk. This person separates the discussion (and the people) for the sake of leading the conversation. Use this very carefully and only if you feel you really give the conversation a new direction which you couldn’t do with a reply. Quote-retweets make it unnecessary hard for people to follow a conversation, as it now takes part in several threads.

reply = engagement

With a reply you add your thoughts to a tweet. This could be a validation of the original tweet, or you being in disagreement or also bringing in a new perspective. Without replies, twitter would be just a big rook where everyone just uses a megaphone to broadcast their opinions but without listening. If you want to show that you listen and are open for a two way-communication, this is what you should do mostly.

Also, the amount of replies is the primary reason so that the Twitter algorithm can rank this tweet higher and it will be displayed to more people - which increases reach and visibility.

A few tips for good replies

Don’t reply something like “cool/awesome/great”. It shows that you didn’t put any effort into your reply - and it doesn’t add value to the conversation as the discussion ends now.

Instead, share why you think the idea which wa share is cool/awesome/great. Also if you don’t agree, don’t be like “nah/meh/this is bad”, but share your reasons (respectfully).

Rule of thumbs: If you don’t have time/mental capacity to do this, yuo shouldn’t reply as you are only causing noise.

Also a good way to engage is asking questions, because that is what keeps a conversation going.

I want it all

Now what if you what attention for the original tweet and drive engagement? Well, you can combine the methods:

add a reply, sharing what you think
retweet (not quote tweet)

What do you think?

Share your thoughts with me on twitter :-)

Get rid of Key Vault! (Making good things even better)

Tue, 08 Mar 2022 14:31:10 +0000

I love open-source, because it is a fantastic way to learn and share. I recently saw this tweet by Peter Klapwijk, who built a Logic App to monitor licenses of your Microsoft 365 tenant. The solutions uses

a Logic App with an Office 365 API connection (to send emails with the built-in Outlook connector)
a Key Vault (to protect the secret that is generated for the Azure AD app registration)
manual deployment with a custom template

As much as I love the idea of the solution, I felt this can be improved - and this is of course complaining on a very high level.

I wanted to do two things:

Get rid of the secret and the Key Vault
Automate deployment

Get rid of the app registration

You may ask- How does this work? At least that was Peter’s first question :-) App registrations in Azure Active Directory (which handles identity and access management) give your app an identity and we can assign (and consent to) permissions in different APIs (like Microsoft Graph). To make things secure, we can protect this app with a secret. Together with the app id (client id) this is username/password for the app.

As we now want to protect this secret, we store can store it in an Azure Key Vault, but to log into Key Vault, we again need credentials - it’s a chicken/egg problem. Also, rotating the secret and taking care when it expires is a tedious task.

But even if you feel that Key Vault is fine - There is still an security hole:

⚠ If you have a contributor role assignment on the app (not on the Key Vault!), you can read the value of the secret that is stored in Key Vault in Kudu.⚠

Let’s face it: where there are secrets, there will be leaks.

Now there is a solution to this problem: Azure Managed Identities - give your app an identity without an app registration. It’s an amazing example on how Azure abstracts away the complex stuff (creating, storing, rotating secrets) so you can focus on the nicer parts of development. I decided to use a user-assigned Managed Identity, which is a standalone Azure resource and can be shared in case we want to add more resources to an extended version of the solution. This Managed Identity of course will need to have the permissions assigned that the previous app registration had assigned.

Automate deployment

I created Bicep 💪 files (super cool way to provide an ARM template) and split the template so that I can call every resource (Logic App, Managed Identity, API connection) as a module from the root deployment file and end up with separate files for each resource. That is more convenient to work with during development and also makes debugging easier.

param connections_office365_name string = 'office365'
param workflows_Monitor_main_name string = 'Monitor-LogicApp'
param userAssignedIdentities_Monitor_Identity_name string = 'Monitor-ManagedIdentity'
param ResourceGroupName string
param resourceLocation string


module managedIdentityDeployment 'Monitor-ManagedIdentity.bicep' = {
 name: 'managedIdentityDeployment'
 params: {
 userAssignedIdentities_Monitor_Identity_name: userAssignedIdentities_Monitor_Identity_name
 resourceLocation: resourceLocation
 }
}

module connectionsDeployment 'Monitor-connections.bicep' = {
 name: 'connectionsDeployment'
 params: {
 connections_office365_name: connections_office365_name
 resourceLocation: resourceLocation
 ResourceGroupName: ResourceGroupName

 }
}

module MainDeployment 'Monitor-main.bicep' = {
 name: 'MainDeployment'
 params: {
 resourceLocation: resourceLocation
 userAssignedIdentities_Monitor_Identity_name: userAssignedIdentities_Monitor_Identity_name
 workflows_Monitor_main_name: workflows_Monitor_main_name
 connections_office365_name: connections_office365_name
 }
 dependsOn: [
 connectionsDeployment
 managedIdentityDeployment
 ]
}

I learned this one the hard way: Providing Infrastructure as Code (even if it is just for a small solution) is a faster, more sustainable and better way to deploy resources. It is painful how often GUIs change and results are not repeatable then. Also, it is more convenient to run a script rather than having to click yourself through a lengthy README file. (Been there as well)

The script will create the resource group that holds the resources and assign the correct Microsoft Graph permission scope to the managed identity:

Here is the interesting part that assigns the permission, full script on GitHub 💚:

$ManagedIdentity = az identity show --name Monitor-ManagedIdentity --resource-group $ResourceGroupName | ConvertFrom-Json
$principalId = $ManagedIdentity.principalId
# Get current role assignments
$currentRoles = (az rest `
--method get `
--uri https://graph.microsoft.com/v1.0/servicePrincipals/$principalId/appRoleAssignments `
| ConvertFrom-Json).value `
| ForEach-Object { $_.appRoleId }
$graphResourceId = az ad sp list --display-name "Microsoft Graph" --query [0].objectId
#Get appRoleIds for Organization.Read.All
$graphId = az ad sp list --query "[?appDisplayName=='Microsoft Graph'].appId | [0]" --all
$orgReadAll = az ad sp show --id $graphId --query "appRoles[?value=='Organization.Read.All'].id | [0]" -o tsv
$appRoleIds = $orgReadAll
#Loop over all appRoleIds - in case we later extend and need more than permission
foreach ($appRoleId in $appRoleIds) {
$roleMatch = $currentRoles -match $appRoleId
if ($roleMatch.Length -eq 0) {
# Add the role assignment to the principal
$body = "{'principalId':'$principalId','resourceId':'$graphResourceId','appRoleId':'$appRoleId'}";
az rest `
--method post `
--uri https://graph.microsoft.com/v1.0/servicePrincipals/$principalId/appRoleAssignments `
--body $body `
--headers Content-Type=application/json
}
}
Write-Host "🚀 -Deployment completed"

(I re-used the script that we use at ProvisionGenie 🧞)

As a result, we can see the the assigned permission scope in Azure Active Directory

(Navigate to Enterprise Applications, then filter by Managed Identities, select the created Managed Identity and select Permissions):

I did a PR on Peter Klapwijks repository and added my approach there as well - communityrocks ✨

What do you think?

You like it? Let me know! You don’t like it? Let’s talk!

👉🏻 Find the discussion on twitter

How to create a custom connector for your own Azure hosted API

Sun, 27 Feb 2022 18:28:39 +0000

In this blog post I am going to cover

How to create an API with JavaScript
How to deploy this to Azure
How to wrap the API into a custom connector
How to use the connector in Power Apps

Don’t know what is an API? Don’t worry, here is help:

Imagine, you are dining in a restaurant (this is the app/client). You do not talk to the kitchen (server/database) directly, but you can send requests to the API, which is our waiter*waitress. They will request dishes from the kitchen and get them in return and then respond back to you.

Operations you could do are

GET (request data from a server)
POST (send new information to a server)
PUT (make changes to existing data on a server by replacing the entire entity)
PATCH (make changes to existing data on a server by updating provided fields)
DELETE (remove existing information from a server)

How to approach things

In this example, we only want to do GET requests, as we want to read news from different newspaper websites such as BBC, New York Times and New York Post. In order to achieve that, we will scrape the websites of these sources and extract title and URL of the articles. We will later deploy this to Azure as a web app and wrap the API into a custom connector for Power Platform. Last thing is then consuming this custom connector in a Canvas app.

1. make it work on your machine

Create a new directory on your computer and navigate into it
Make sure you have node.js installed
Run npm init, which prompts you to answer some questions about your project (you can just hit return). It will then create a package.json file in your project for you. It contains some metadata about your app such as your name, the version and the license. You can change the file according to your needs.
Create a index.js file as an entrypoint for the app
Install the following dependencies
- cheerio, which allows us to parse HTML to get exactly the data we need from a website
- axios, to ease the process of HTTP requests for CRUD operation
- express, as backend framework for node.js - this will be our listener 👂
- nodemon, which helps us with restarting our nodejs app on change

💡 Dependencies will show up in your package.json file.

Please delete the “scripts” object in this file and replace it by this object:

"scripts": {
 "start": "nodemon index.js"
 }

We can later start our app with nodemon index.js

💡 You can also see now, that you have a package-lock.json file - you may want to have a look, but we won’t touch this file.

We wil now go ahead, open our index.js file and first create the listener 👂


const PORT = process.env.PORT || 8000

const axios = require('axios')
const cheerio = require('cheerio')
const express = require('express')

const app = express()

app.listen(PORT, () => console.log(`my server is running on PORT ${PORT} 🚀`))

You can of course use a port of your choice.

We can now create our first endpoint:

app.get('/', (req, res) => {
 res.json('Welcome to my 📰 News API')
})

This endpoint sits at the root / and displays just a little welcome message. You can later delete that, it’s just to see if things already work.

Now we want to create an array of newspapers/sources that we later want to loop over.

💡 As some of them don’t provide their baseURL when linking to an article on their website but only a relative path, it’s a good idea to have a baseURL property.


const newspapers = [
 {
 name: 'nyt',
 address: 'https://www.nytimes.com/',
 baseURL: ''
 },
 {
 name: 'un',
 address: 'https://www.un.org/',
 baseURL: ''
 },
 {
 name: 'bbc',
 address: 'https://www.bbc.co.uk/news/',
 baseURL: 'https://www.bbc.co.uk'
 },
 {
 name: 'nyp',
 address: 'https://nypost.com/',
 baseURL: ''
 }
]

Next step is to create an empty array of articles and then loop over all newspapers to fill the array with articles

Visit the address using axios,
Save the response (this is the entire HTML of the website)
Pass this HTML into cheerio
Look for elements with an a tag that contains “Ukraine”
Grab the title (text) and the url (which us the href attribute)
Push this as an object into our articles array

const articles = []

newspapers.forEach(newspaper => {
 axios.get(newspaper.address)
 .then(response => {
 const pageHTML = response.data
 const $ = cheerio.load(pageHTML)

 $('a:contains("Ukraine")', pageHTML).each(function () {
 const title = $(this).text()
 const url = $(this).attr('href')

 articles.push({
 title,
 url: newspaper.baseURL + url,
 source: newspaper.name
 })
 })

 })
})

We now want to see this work in action - and create an endpoint /news for it:

app.get('/news', (req, res) => {
 res.json(articles)
})

If you now visit localhost:8000/news ,you should see an array of of objects displaying title, source and URL of articles of all your sources. So far, so good. but what if we want to filter the sources with /news/nyt or /news/bbc?

Let’s introduce the newspaperId. We will again do the same axios and cheerio magic once again - Our new array is now called specificArticles and will also contain the id of the source.

app.get('/news/:newspaperId', (req, res) => {
 const newspaperId = req.params.newspaperId

 const newspaperAddress = newspapers.filter(newspaper => newspaper.name == newspaperId)[0].address
 const newspaperBase = newspapers.filter(newspaper => newspaper.name == newspaperId)[0].base


 axios.get(newspaperAddress)
 .then(response => {
 const pageHTML= response.data
 const $ = cheerio.load(pageHTML)
 const specificArticles = []

 $('a:contains("Ukraine")', pageHTML).each(function () {
 const title = $(this).text()
 const url = $(this).attr('href')
 specificArticles.push({
 title,
 url: newspaperBase + url,
 source: newspaperId
 })
 })
 res.json(specificArticles)
 }).catch(err => console.log(err))
})

You can now test this with localhost:8000/news/bbc or localhost:8000/news/nyt

👉 Please do yourself a favor and create a .gitignore file with

node_modules

so that you later on don’t commit the node modules.

2. Make it work on Azure

Cool, we made a service work on our machine, but more people could benefit if we deployed this API now to Azure. The service we will be using here is an Azure Web app. As I am a Windows person, I’d like to try more things on Linux, so we will be creating a Linux app 🤓

Open VS Code or the terminal of your choice
make sure you have Azure CLI installed
Create a new web app with the following command: az webapp up --sku F1 --name <mywebapp42> --location <location-name>

💡 please note:

the name of the webapp needs to be globally unique
the location is optional - if you don’t know which region you want to use, you can get a list with az appservice list-locations --sku F1
if you don’t like Linux, use --os-type Windows

The web app will be created for you, this can take a few moments, as it does not only create the web app for you, but also automatically creates a resource group and an App service plan. It also packs and deploys your local project.

In the output, you will see something like:

Starting zip deployment. This operation can take a while to complete ...
Deployment endpoint responded with status code 202
You can launch the app at http://<mywebapp42>.azurewebsites.net

Select that link! In case you didn’t delete the root endpoint, you should now see the greeting ❤ Test your other endpoints as well! Also go to the Azure portal and check the resources that have been created for you.

It should look something like this:

3. Wrap your API into a custom connector

Now that we have a cool API, let’s use it in Power Platform!

Open flow.microsoft.com
Select Data, select Custom Connectors
Select New
in the General for Host enter your new app URL http://<mywebapp42>.azurewebsites.net
Don’t do anything in the Security tab - this is a public API and we don’t need authenticated access
On the Definition tab, select New action
For Summary, Description, and Operation ID enter something like GetNewsAll
Select Import from sample for Request
Select Get and paste in the URL http://<mywebapp42>.azurewebsites.net/news
Select Add a default response and paste an array in it - you don’t need actual values, the schema is enough.

[
{
"title": "string",
"url": "string",
"source": "string"
},
{
"title": "string",
"url": "string",
"source": "string"
}
]

Select Create connector
you may want to test your connector on the Test tab. To do so, select New Connection and then select Test operation - This should return an HTTP code 200 and you should see some real data.

Repeat the steps 6-12 for the other endpoints that you created (i.e. /news/bbc) You can also pass in the newspaperId as a parameter.

4. Consume the custom connector in a Canvas app

Open make.powerapps.com
Create a new canvas app from blank - don’t forget to save it
In the left hand bar, select Data and add your custom connector
Create a gallery and set its Items property to Defaulttitle.GetNewsAll()
Set the
- Text property of the Title label of the gallery to ThisItem.title,
- Text property of the Subtitle label of the gallery to ThisItem.source,
- Onselect property of the icon of the gallery to Launch(ThisItem.url)

You can even create a dropdown menu that holds the different sources so that users can change what they want to consume.

Conclusion

You can wrap ANY API into a custom connector for Power Platform - even the ones that you create.

Resources

Some helpful resources

Quickstart: Create a Node.js web app - Azure App Service | Microsoft Docs How to Scrape Websites with Node.js and Cheerio (freecodecamp.org)

Create a custom connector from scratch | Microsoft Docs

How to use a custom connector in Power Automate (m365princess.com)

Working with Custom Connectors in Power Platform for beginners (michaelroth42.com)

#SharingIsCaring 💖

How to be better at twitter

Fri, 28 Jan 2022 14:29:48 +0000

I use socials every day to engage, get the news I need to know and send out the messaging that helps me building a community. I want to share some good practices about using twitter and explain some do’s and don’ts. Also I want to suggest some tools that help you keep track and some approaches to mute some white noise.

Do’s & Don’ts

@ mentions

Don’t @-mention ‘big accounts’ like ‘@Microsoft’, ‘@SharePoint’ and also not the personal accounts of leaders in this space.

These official accounts are managed by people in marketing and there are typically strict rules in place how to engage, as in what do like, if and what reply and what to retweet. If you are now tweeting your questions that should go to helpdesk, your feature requests, your Look at me, I am hosting an event tweets and mention these accounts, nothing will happen - other than that you wasted characters on @ mentioning accounts that won’t engage with you.

⚠ It is a common misunderstanding, that if you @ mention an account, their followers would see that in their feed. They don’t.

Also: Can you imagine how many @ mentions personal accounts of leaders in the space get each and every day? Do you really want to spam them?

Instead of @ mentions, use appropriate hashtags, 1-3 will do the job. Don’t invent new hashtags, don’t have more hashtags than actual words in your tweet. Why? People might not follow you, but they monitor hashtags. Hashtags are the way to tame the information overload and get the content you want. And if you are a content creator on twitter, you should make use of these. Consistency is key here.

.@ mentions

before 2017, if you posted an @ mention at the beginning of a tweet, twitter interpreted this as a reply to this account, which meant, that your tweet was only in the feed of accounts that followed you and the account you were @ mentioning. People therefore chose to put a character before the @mention, for example a dot .- Twitter changed this so that it doesn’t make any difference anymore if you put a dot . or not. It doesn’t harm, but it let’s you look as if your last update on how twitter works is already too long ago.

Media

Tweets not containing media such as links (with preview image), an image or a gif usually don’t get a lot of engagement. Most people are strongly visually oriented and they click when they skim over something that looks interesting.

Pro Tip: use the Twitter Media Studio to manage your media

Enriching your texts with media is a great idea to make them more compelling. You can also structure your tweet with emojis and paragraphs if you have a lot to say.

You can check the preview of your Open ID card with the Twitter Card validator tool.

URL shortener

Are you using a fancy URL shortener to have more characters left for your tweet when you share a URL? URL shorteners have some benefits - you get the stats, they look nice, people could even remember them, but they do nothing for the length of your tweet. A tweet may contain up to 280 characters, if there is no URL in it. If there is a URL, the URL counts as 23 characters, regardless if it has more or less characters.

Accessibility

Not caring about accessibility is a luxury that we indulge on the expense of others. Most twitter clients have an Alt text feature so that you can describe your images. If the client you use doesn’t have this feature, either consider to change to another client (as it is not feature complete) or add another tweet to your original tweet that then adds the Alt text.

Please don’t do any fancy fonts or special characters or try be extra funny/nerdy like D:\ebbie in your Twitter Name - screen readers will not be able to interpret this correctly.

Tools and how to use them

Tools that help me keeping track of things:

Tweetdeck

Tweetdeck is most probably the best invention since twitter. Its an application by twitter that allows you to organize content in columns. You can display hashtags, lists, users, your scheduled tweets just right next to each other. It also allows you to filter in these columns by engagement and you can include/exclude authors.

Pro Tip - you can add Tweetdeck as a PWA :-)

Lists

You don’t have lists? You should probably change that. Lists allow you to curate content based on what is important to you. This way, you don’t need to necessarily follow each account that is somewhat interesting for you. You can put them in a list. Think about list as channels in Teams - they give you content in a certain context - but you don’t need everything in your home feed.

I use Twitter List Manager to organize my lists - not the most compelling UI, but it does the job :-)

Bookmarks - or the ‘I will never look at that again’-list 😥

Twitter has a bookmark feature, but until I discovered dewey I didn’t find it useful. dewey allow me to organize my bookmarks so that unsactually make sense of that pile of guilt. It’s a Chrome/Edge extension and I love it!

Search

Want to find a tweet again and keep on scrolling? Twitter web client offers you an advanced search

Analytics

If you are interested in how you are doing on twitter, there are several tools to track that Twitter has built-in analytics, which you will find in the web client. You can also access it at https://analytics.twitter.com/user/<your user name here>/home

Stay focused

Although Twitter is important we all need to make sure to not get overwhelmed by this constant stream of news and call to actions.

The art of muting

You follow some accounts but there are subjects that keep on annoying you? Instead of blocking people, you can mute words. Also, you can mute Retweets of people that retweet a lot of content that you already have in your feed.

Notifications & other settings

My best advice is to have an intense look at your notification settings and see if you really need all of them. If you use a tool like Tweetdeck or analytics to monitor and manage your content, you don’t necessarily need real time distractifications 🔔

Last but not least - Make sure that you see tweets in chronological order and not by whatever Twitter thinks you should see now. This way you know when you read everything.

Drive Engagement

Want a deeper connection with your community? Best way to achieve this is to have meaningful conversation, sharing your insights and keep on listening.

When to tweet?

As a consultant, I need to say: It depends! - But there is a sweet built-in tool called twitter Insights that allows us to see when you get the highest engagement.

I also use Social Bearing which gives me some insights on how my tweets are doing.

Feedback & What’s next

What are your twitter hacks? Let me know on twitter

be brave enough to suck at something new

Mon, 27 Dec 2021 11:16:07 +0000

Tis the season where we all look back to reflect what happened in the year, what we achieved, where we grew and where we helped others. At the beginning of this year, I told myself to be brave enough to suck at something new, which meant to me that I wanted to make more courages decisions - what to learn, what to build, what to dare. Turns out, that this was a good approach for me.

Instead of listing now each and every little thing I did, (well this ain’t the MVP community contribution list that I STILL need to update 😇), I’d rather like to emphasize a few initiatives that are near and dear to my heart - and that consumed not only a lot of my time but also of my mental capacity. Like a lot of us, I felt affected (yet another year) by the global world is on fire situation.

Open Source

Giving back to community balances this feeling, it lifts me up to see others thrive and I find joy and calm in collaborating with community for a greater good. This is why open-source became so important to me.

Microsoft 365 PnP

In December 2020, I joined the Microsoft 365 PnP team, which is ‘a virtual team consisting of Microsoft employees and community members focused on helping the community make the best of Microsoft products’. We help others to extend Microsoft 365 with tools, guidance, community calls and lots of initiatives. If you never heard about it, its worth checking it out.

In January 2021 I launched the Microsoft 365 PnP community blog, where everyone can share their knowledge about building things with Microsoft 365. This hub is also the home for community call recordings, the Microsoft 365 Developer podcast, and the PnP Weekly podcast. As of today, we managed to publish almost 1 article for each day. I’ve even been rewarded as MVP of the month April 😁 for this initiative. But please stay tuned -more exciting things here will happen in early 2022 🎉

Also, I am part of the Sharing is Caring initiative, which aims to make it easier for new contributors to find their way into our open source projects. We run a lot of sessions, on how to help with code and documentation, established a buddy system for new presenters in community calls and even run Office hours to help everyone achieve more together. I like to say a big thanks to the entire team

ProvisionGenie

Throughout the entire year, I’ve been working together with Carmen Ysewijn on our open-source Microsoft Teams provisioning engine called ProvisionGenie. We got quite some attention and are pretty happy with it, but like any other application: it’s never finished and there is always work to do. Huge 🧞💜 thanks to our all-time supporter and Chief Debugging Expert Yannick Reekmans

even more open-source

- Wassim Chegham invited me to consult the team during the Microsoft Global Hackathon - and WE WON 🎉🎉🎉
- I participated in the Hackathon held at SouthCoastSummit with my amazing team mates Carmen Ysewijn, Lee Ford, Michael Roth, Tomasz Poszytek and Yannick Reekmans - read about it here
- In the beginning of the year, Eddie Jaoude asked me to join his #Eddiehub guild and to participate in the Major League Hacking Hackathon - and guess what? We won!
- I worked with Marc Duiker on his awesome initiative Azure Functions University - this will be an ongoing effort in 2022 as well

Conferences

I know, most of us stayed at home for yet another year, but I was very fortunate to be able to attend and speak at two in-person events:

At SouthCoastSummit I spoke together with Yannick Reekmans about “FusionDev - hello from the other side”, which reflected our thoughts about makers and developers needing to join forces. Although totally overwhelming (people!), we had a blast and I was truly happy to see lots of my friends again.

Later on in November, it was Collabsummit, the community conference that is so close to my heart. One more special thing was, that it took place in Duesseldorf, where I happen to live. I delivered a session on “Azure Managed Identity and Microsoft Graph”, attendees seemed to like it 😇

- I published 36 blog posts on m365princess.com
- I learned 100+ hours JavaScript but missed my goal of doing this for 100 consecutive days
- I completed Harvard’s CS50 Introduction to Computer Science
- I completed the 30 days of Postman challenge
- I delivered countless online sessions (for real, I lost track)
- As a special xmas present to myself, I passed the MS-600 exam - Microsoft 365 Developer Associate

What’s next?

Good question! I want to continue to learn and share and grow with all of you! If you have a cool idea in mind, please reach out! I am always happy to help!

Have a happy new year - hope to see you soon somewhere!

How to move your blog from Wordpress to Hugo

Sat, 18 Dec 2021 17:51:35 +0000

If you are a little bit like me, you started to blog some years ago on Wordpress and now don’t like it anymore. It’s clumsy and slow and kinda uncool and you would like to have a better experience for authoring your blog posts. A couple of months ago, I moved my own blog m365princess.com from WordPress to Hugo. This blog post explains what you need to do to do the same and how you can manage your website then in Visual Studio Code.

I will guide you how to

convert your WordPress HTML posts into markdown files with blog2md
how to host your site with git and GitHub
host the files with Netlify
author, manage and publish your blog posts with VS Code and Front Matter

This means, that you need to have

git installed
a GitHub account
a Netlify account
Hugo installed
Visual Studio Code installed
Front Matter installed

All of the above is free/ has a Freemium model. In case you are not familiar with git and GitHub, I got your back, read How to get started with GitHub and Git, then continue here.

git and GitHub

After you read that post I will assume that you have git installed and that you are the proud owner of a GitHub account.

Create a new repository on GitHub
Clone this repository locally
- Select the green Code button on your repository
- Select the Copy button
- Open VS Code
- Open a new terminal
- Navigate to a parent folder where you like to have have your repository in
- Type in git clone <the copied value from the repository> to get a local copy
Navigate into this folder cd <repositoryname>
create a new folder either mkdir <hugoblog>
Create a new branch so that you have a stage to deploy from with git checkout -b <your branch name>

Netlify

Once you created your Netlify account, you can connect your GitHub repository to it. In the dashboard

Select Add new site
Select Import an existing project
Select the GitHub button to connect
Log in
Select Configure Netlify on GitHub
Log in
Select the repository you created earlier
Select save

The repository should now appear on the Netlify site.

Select it
Ignore all the fields (for now, we can set this up later)
Select Deploy site

You will see a 404 - this normal!

Select Site information
Select Change site name and change it to something more friendly, like Luise-new-blog

With this, the new address for your site is https://luise-new-blog.netlify.app. Yet again, if you click on it - don’t be disappointed about the 404 error.

You can later change the CNAME record of your website so that your preferred URL points to that new site.

Hugo

We will now install HUGO on your computer. I’m on Windows 10, pretty sure it works similar to that on Windows 11 that way as well. If you are on MaC/Linux, please look up your preferred way to install on Hugo

Create a folder Hugo
Create two subfolders in the Hugo folder and name them bin and Sites
Download the latest .zip file from Hugo releases

Extract the zip file into the bin folder
Add the bin folder to PATH:
- Open the Windows settings
- Select Advanced system settings

- Select Environment variables - Select Path in the user variables - Select Edit - Select New - Type in the Path to your bin folder

- Select OK - Select OK - You may close settings

Test if you did things right by opening a terminal (I use VS Code) and type hugo help - it should respond with this:

build your site

navigate to your Sites dir
type in hugo new site <your sitenamegoes here> --force

Hugo has a built-in live server, so that you can work locally. You can start it with hugo server - it will tell you on which localhost address you can preview your empty site - for me it localhost:1313.

To have a cool site, you need to

define its structure in the config.toml file
have your blog post .md files in the contents folder
have your images in the static/images folder
either create a new theme or install a theme

Let’s tackle this one step at a time:

config.toml

Let’s make sure we have the site name and blog URL (the friendly URL from Netlify)

title = "Luise's new blog"
baseURL = "https://luise-new-blog.netlify.app"

Later, you can set up navigation in this file as well.

blog posts

To have your (old) blog posts in here, we will first need to convert the HTML pages to .md files. You can either use a browser-based tool like Code-Beautify or run blog2md, which is what I prefer.

Export all blog posts from WordPress
- Select Tools
- Select Export
- Select Posts
- Select Download Export File
- This will output an xml file
Install blog2md
Transform the xml file to md files with blog2md
node index.js w <Path to your xml file> <folder where you want your old blog posts to live.>
Do a little cleanup, and delete the blog2md repository clone and the npm dependency

handle metadata with Front Matter

You will notice, that in each and every .md file, you will not only find the content of your previous HTML page, but also metadata, encapsulated by --- - this part is called front matter. Front matter is the first section of a book and gives information on author, publishing house and so on. These preliminary matter made its way to digital content as well, as a blog post usually has an author, publishing date, URL, preview image and so on. As every new blog post will need front matter, you could come up with some awkward workaround of copy/paste that and then adjust it every time to your needs. But lets face it: Thats not how we want to work.

Lucky you, there is an amazing extension for Visual Studio Code to handle the front matter - and more. It’s called Front Matter. It’s a headless CMS and works with every static site generator, also with Hugo. It allows you to author and preview your content in VS Code and lets you set the front matter with ease. It gives recommendations for SEO and lets you easily preview and insert images into your blog posts. The media dashboard also lets you add metadata to the images so that you can manage the alt tags for them. Best thing: Its open-source. If you like it, consider to sponsor its creator and give Elio a shout out.

static

Images need to be in the static folder, I have a subfolder images in here. If you use Front Matter, you can insert images into your blog post by selecting the Insert image button or link to the image.

a theme

If you don’t like to create your own theme, you can install a Hugo theme and then adjust it to your needs. I can recommend getHugoThemes.com, but there are free themes available on the thing called internet as well. Follow the documentation to install the theme.

Now its time to actually create your site. Depending on your skills you can copy/paste from example sits of the docs of your theme and then replace with the values you need for navigation, site, content, or write the site from scratch.

Deploy

If you now want to create a new post, I’d recommend to do this with Front Matter. You will need to do this in the contents folder. Once your blog post is ready to be published, make sure that the draft property is set to false.

Push your changes towards your stage branch
Change Site settings on Netlify
- Build command = hugo
- Production branch = main (in case you used an old repository it could also be that the default repository is called master)
- Branch deploys = Deploy only the production branch
Merge from stage into main which deploys your site
Time for a happy dance

The beauty of having several branches now is that you have more control - with only one branch each and every push will rebuild your site.

Conclusion

Either way, you can now author and manage your blog post straight from VS Code. You will use git to commit and push your changes to re-deploy your site.

You can benefit from the entire cool ecosystem around VS Code with all its extensions, great docs and awesome community around.

Let me know, what you use to blog? If you don’t use Hugo, would you now like to migrate?

How to deal with many to many relationships in Dataverse

Thu, 18 Nov 2021 08:39:22 +0000

While building an app that stores data in Dataverse, I came across a not easy to resolve problem. If you already follow me for a bit longer, you may assume that this is about ProvisionGenie, and so I will use this use case of provisioning Microsoft Teams teams and storing data about that as an example. To explain the issue, we first need to understand some basics, which I will cover here first:

What is Dataverse

Dataverse is a is a secure and scalable SaaS data service, that sits right in Power Platform. Datverse’s database is Azure SQL, and often, people refer to Dataverse just as ‘a database’, but it is so much more:

I will not go into full detail in this blog post, but cover something that people with a background in Microsoft 365/SharePoint might not be aware of:

How does Dataverse distinguish from SharePoint lists and what makes it a ‘real database’?

In Dataverse, we store data in tables, we can either use predefined ones or we can creates our own tables. We can choose from different kind of column types to store data just as needed. The beautiful thing that get our Dynamics 365 colleagues excited is, that Dataverse can serve as a ‘relational database’, which means that we can create all kinds of relationships between data, which gives us a better overview on data as we can put data into context.

Also, we have role-based access control (RBAC), which means that we can granularly control who can view, edit, delete etc. data, while this isn’t possible with SharePoint lists. If we use a list as data source for a Power Apps, we need to share the entire list with all users of that application, which means that users can even bypass the app and manipulate and delete data directly on the SharePoint site.

Now you may ask, what is it about relationships in Dataverse that makes it so special?

What kind of relationships do exist in Dataverse?

1-to-many relationship

In a 1:N (1-to-many) relationship we associate a (1) row of a table to many other rows in a related table with a lookup column. We can see a list of the related rows that are associated with our primary table.

You will come across the term ‘N:1(many-to-1)’ as well - it is the same thing as a 1:N relationship- just viewed from the related table, not from the parent/primary table.

As an example, please imagine a table Teams Requests and another related table Teams Channels. Each Team can have many channels, but a channel can be only associated with one Team (represented in the Teams Request table). This means, that we need to have a 1:N relationship between Teams Requests table and the Teams Channels table. We reference this like this:

We get the correct environment, fetch the table Team Channels and filter by TeamsRequestId so that only the related channels to that Teams request will be returned.

Many-to-many relationships

An N:N (many-to-many) relationship depends on a special relationship table (intersect table), so that many rows of one table can be related to many rows of another table.

We can see a list of all rows in the related table that our primary table is associated with.

As an example, please image now the Teams Requests table again that needs to be related to a Teams Users table. In this Teams Users table we want to store information on members and owners of the teams in the Teams Requests table.

A Teams can have many users as members, and each user can be a member of different Teams.

Also, a team can have many users as owners and these users can be owners of several different teams.

This means, that we need to have two N:N relationships between teams Requests table and Teams Users table.

Now the intersection tables come into play: They make sure that we can associate many rows of the related table to the primary table.

In Dataverse, we don’t get to see these intersection tables. but we can customize their name:

How can you reference Many-to-Many Relationships in Azure Logic Apps?

Now that the distinguishing element between an Owner of a Team and a Member of that Team is in the relationship, we need to reference that intersection table in a Logic App flow in order to fetch the right rows from the Teams User table to add them with the correct role to the Team that we want to provision.

In order to do so, we select the correct environment, and type the name of the relationship table followed by a set, then we filter for the correct Teams Request ID so that only members for that specific team will be returned.

The very same applies to the relationship table for the owners.

Conclusion

Before you build your Power Platform solution, its absolutely worth it to spend a couple of thoughts on the data model. If you

need more relationships than a simple lookup column
need granular control who can access which rows
a performant place to store data
a highly scalable solution

then its very likely, that Dataverse is a service that you should consider.

In order to take full advantage of Dataverse’s capabilities in terms of being a ‘relational database’ its worth it to understand what is an intersection table and how you can reference it. Let me know what you think in the comments

How 3 makers, 2 devs and a princess came together to save kittens for a hackathon

Sat, 23 Oct 2021 10:40:45 +0000

How 3 makers, 2 devs and a princess came together to save kittens for a hackathon

The Story (Michael)

Just before Southcoast Summit 2021 got started, the organizers hosted the Automate Everything - SS2021 Hackathon where every solution revolves around Flic buttons. Wait, you don’t know what a Flic button is? It’s basically a wireless smart button that lets you control devices, apps and services. Push once, twice or hold the button and let each variant trigger a different action. There are multiple use cases in business but also in personal life in which Flic buttons make your life easier. Check out the Flic homepage to learn more.

Meet Petrol Push. A modern day organization that has a clear mission: Save kittens. There are hundreds of kittens all over Britain that get stuck in trees, get lost within the urban jungle or need help in any other kind of way. Luckily Petrol Push underholds a huge fleet of volunteers to rescue kittens every day.

the challenge As you may know there is a petrol shortage happening right now and of course you wonder, how can Petrol Push keep up their noble mission? Flic Buttons and the Microsoft Power Platform gave them the ability to come up with a solutions to help all their volunteers in their day to day work.

the solution Every Petrol Push car got a Flic button installed and whenever Petrol Push volunteers pass a gas station, they can indicate with a push of a button, whether the gas station has fuel available or not. This information gets stored on a map so every Petrol Push employee knows where fuel is available and where it’s not. This way the volunteers can keep their focus on their mission. They don’t need to drive around searching for fuel or worry where to gas up. The community of volunteers takes care of that.

Petrol Push cares deeply about their volunteers so they don’t want to put them in danger in any way. That’s why this solution comes with a little extra. Petrol Push workers don’t have to check the map over and over again to see whether anything has changed. If one of the volunteers found a gas station where fuel is available, the button gets pushed and the fleet will get notified with a song. That way the drivers know when to check the map for updates.

Within these times it might happen that our drivers get in trouble themselves, run out of gas, have a flat tire or something else. Once again, Petrol Push cares about their volunteers deeply so the Flic button provides the opportunity to call other volunteers on the road for help. Once again with a song, so no other driver needs to check their phone. The position gets indicated on the map though, so that help can be arranged quickly. It’s only the supervisor that gets an additional text message in order to provide further information.

Note: you will probably know by know, but this use case exemplifies the ability to combine geographic location with notifications that are not based on text. In this way, we want to draw attention to how versatile Power Platform solutions are and we also want to think about the people who can only use devices in a limited way. Please use this use case to customize it to your needs. And always remember, only as a community we are strong, so let’s be inclusive.

Now, let’s dive into details and see how this solution actually works

The Flic and the flow (Tomasz)

In a big picture, the flow was built to get information about location of a driver who triggered it, next to lookup details of the closest petrol station (by using Azure Maps API). Finally to save the station’s data together with status into database, so later it can be displayed with a proper color of a pin, inside the app. But in details, it’s much more interesting.

The flow can be triggered by any driver (1️⃣). Also, for any Flic event, but that will be described later. Next, bot looks up details of the button itself (2️⃣), to get its owner (3️⃣). This information will be later used to record data along with information about the driver.

Next the flow calls Azure Maps custom connector via a dedicated child flow (1️⃣), by passing latitude and longitude of a driver’s location. Coordinates are obtained using GPS from driver’s phone that is paired with Flic button. Obviously this should be done using the action directly within the parent flow, however for some unknown reasons we were facing an issue while saving process with the action inside, so we decided to move it into a child flow. Don’t judge 😁 Data returned by the child flow, that represents details about the nearest petrol station is then parsed (2️⃣).

Finally bot using postal code is filtering existing stations’ data to get a match (3️⃣). This is done using ODATA expression: woi_postalcode eq '@{first(body('Parse_JSON')?['results'])?['address']?['extendedPostalCode']}'. Then it saves its row ID into variable (4️⃣). Naturally, if there’s no station for the given postal code, variable will be empty. We also made an assumption, that there can be one station for a given postal code 🤷‍♂️😀

Process now checks, if station’s row ID is empty (1️⃣) - if yes, it means it has to be created. Creation (2️⃣) of the record takes all the details returned from Azure Maps API, like full address, station name, lat and lon, information about driver who reported it and finally - the postal code. After that row ID of the created station is being saved into variable.

Now process moves to check what kind of action occurred on the Flic. There are 3 possible activities:

Single click - means that there’s petrol on the station,
Double click - means that there’s no petrol on the station,
Long press - means there’s an issue and driver requires assistance.

To check what action occurred, we are using switch action (1️⃣). For each branch process executes the same actions, just with different statuses. First, bot creates an entry in Activities table (2️⃣), to record latest status (to one from Petrol, No petrol, Issue) for the station together with driver details who reported it.

After that is done, it updates status (again to one from Petrol, No petrol, Issue) of the station record itself (3️⃣). Then it saves created activity record OData id into a variable. And finally it relates records (4️⃣) - petrol station together with the created activity record.

What is also worth to mention is that the whole process is built using the try-catch pattern. All actions that are executed in terms of the business logic are stored in the “Try” scope (1️⃣). If anything fails within the scope, it is caught by the “Catch” scope (2️⃣), that has it’s “Run after” settings configured to only be executed if previous actions fails, times out or is skipped.

Process in the “Catch” scope first filters (3️⃣) results of the “Try” scope, using the expression result('Try') to leave only those entries which contain information about errors: @equals(createArray('Failed', 'TimedOut'), ''). Next for each such record (4️⃣) it is adding information about the details to a string variable. Finally, variable’s contents is sent to admin as a notification (5️⃣) and the whole process ends up with “Failed” outcome.

Show me something beautiful - The canvas app (Carmen)

With the data stored in Dataverse, the canvas app can be created to display the available information and inform the people where they can find fuel. The canvas app consists of a header (with the company logo, name and refresh icon) and a map control.

We are using the built-in map control, which allows us to display the gas stations with their appropriate color, automatically center on the user’s current location and display additional information about each gas station when selecting the location pin.

To get the location pins on the map, we added the Dataverse table as a source in the Items property of the map control. We are currently not doing any filtering, but this could be added if needed. The latitude, longitude, labels and colors is each contained in a specific column within the data source. These are provided as values for the following properties (where the text between quotes is the name of the column in the Dataverse table):

ItemsLabels = "woi_name"
ItemsLatitudes = "woi_latitude"
ItemsLongitudes= "woi_longitude"
ItemsColors = "woi_color"

The woi_colors columns is defined as a calculated column that is influenced by the value of the Petrol Status column in the same table. Petrol Status contains the last known status of fuel at the respective station. The colors are defined as hex values with the following mapping:

Last Known Status	Color	Color name
Petrol	“#66FF00”	Light Green
No petrol	“#FF0000”	Red
Issue	“#FFBF00”	Amber

The color of the grouped pins is defined by the PinColor property of the map control. It is set to Green, which is a darker color than the green used for the stations with fuel.

When a pin is selected, the info card is shown. This is defined by setting the InfoCards property of the map to 'Microsoft.Map.InfoCards'.OnClick. The fields that are shown on the info card are defined by editing the Fields in the properties pane of the map. Four fields are shown on the info card:

Name
Address
Postal code
Modified on (to know when the station’s status was last updated)

This can be seen on the below screenshot.

The resulting app shows a map with all identified gas stations and their last known status, indicated with the color of the pin. Selecting a specific gas station provides the user with more information on that station.

We need a real map - The custom connector to Azure Maps (Lee)

A key part of the solution is populating a list of petrol stations and their status based on presses of the Flic button. We initially looked to use the built-in Bing maps Power Automate connector and actions to find the current address when a Flic button was used. However, this would return the nearest address, which is not necessarily a petrol station (e.g. it could be a house on the opposite side of the street which is deemed nearer).

To work around this, we created an Azure Maps resource in Azure. Azure Maps can return a list of addresses within a certain radius that fit a particular “POI (point of interest) category” - in this case a petrol station. Using the subscription-key (API key) from the Azure Maps resource, we were able to create a custom connector in Power Automate and query for the nearest petrol stations to the longitude and latitude when the Flic button was pressed.

Bring me the vibes - The Spotify connector (Yannick)

We like to celebrate victories and help each other in times of need, and what better way than use music for this? We have a sound system in the office connected to Spotify so let’s use that to keep everyone updated on things that happen on the road! A new Power Automate flow will trigger every time a new petrol station status is logged, excluding when no petrol was available. In the case someone found Petrol at a gas station, we get super excited for our colleague and play Fuel by Metallica in the office to have a small party. When someone gets in trouble, for whatever reason, we play Trouble by Coldplay (so we know we need to rush to rescue) and a text message is sent to the manager.

Integrating with Spotify isn’t too difficult (the API is well-documented) but requires the creation of a custom connector with following API actions:

Get a User’s Available Devices: fetch a list of all devices currently connected to the Spotify service
Start/Resume a User’s Playback: play a song on a specific device

When combining both, we can first fetch all connected devices and then filter them on the device id of our office sound system. If the device is connected, we can play the appropriate song for the occasion with the second API call.
And lastly, for the text message we’ll use Twilio. Luckily they have an existing connector within Power Automate so it’s only a matter of registering for a Twilio account, getting a number to send messages from and configuring the action in our flow.

The princess and the push (Luise)

Straight from the beginning of the hackathon, we took care of documenting our architecture decisions and how we would implement them. We set up a GitHub repository, invited everyone in the team so they could commit their files. We continued to document all major steps so that everyone could use this as a reference to explain our solution, although each member was only in charge of their workload. Getting all information and documenting while building ensured accuracy but also gave an opportunity to think through the app and reflect on decisions.

Documentation includes screenshots of the flows, explains the data model and environment variables. We also published the solution itself in this repository to give community the chance to play with our app.

What can we learn from this epic quest? (everybody)

As a group, we discussed the hackathon for quite a while even after it had ended, and we came up with, for us, four important lessons this experience has taught us.

1. Do one thing the right way, instead of a million things in a messy way

What helped us build this solution in a short timespan, was that each person of the team was responsible for a specific part of the solution. There was no context switching between the app studio and building the cloud flow for example. Instead, we made some agreements in the beginning of the day and let each other know verbally and in the documentation if anything needed to change. This allowed all of us to focus on their own part, resulting in finished pieces to the puzzle.

2. Take care of documentation

Since development was decentralized, it was important we could keep each other up to date on what we were doing. Therefore, we documented from the start. Since we were working against the clock, we had one person who constantly went around the table to see what each of us was working on and to make sure it was captured in the documentation. After the individual pieces were finished, this allowed us to piece them together more easily.

3. 1 + 1 = 3

Or in our case 6 x 1 = 10 (or something). Each of us has a different background, no two are the same. Because of this, we were able to share different perspectives and we were able to find the most efficient way to create the different pieces of the puzzle: e.g. Azure maps for station identification, canvas apps for a quick user interface and cloud flows for logic. Since we were not limited to one area of expertise, our solution combines the best of different worlds. In the process, we all learned from each other, either technical skills or an approach how to tackle something. And since we were all eager to learn from and share with each other, we had a lot of fun doing it. 👍🏼👍🏼

4. We are all developers

Each of us is building or creating something on a daily basis, be that using no-code, low-code or code-first platforms and tools. During the hackathon, we realized that our commonalities are more important than our differences. We share a common problem-solving and solution-oriented approach. We can define logic and we do it in very similar terms (if - then - else, anyone?). We can conceptualize solutions and explain them to each other. And then each of us can find some way using their own tools to build that solution. This is what makes us developers, not the language or tool set we build things in, but the approach and mindset we share. All of us are developers, and you can be one too.

This blog post and hackathon team is a collaboration of

ProvisionGenie - an open-source provisioning engine for Microsoft Teams

Wed, 29 Sep 2021 18:33:47 +0000

Once upon a time

I teamed up with my friend and partner in crime Carmen Ysewijn. We both work as Power Platform developers and Microsoft 365 consultants, and got both tired of doing the same things over and over again:

Organizations would roll out Microsoft Teams, and either not make too much fuzz on meeting user’s needs and just assume that changing working behavior would magically happen or they would get a business consultant (us) who would then sit with each and every single team and explain

why cascading folder structures in SharePoint are a bad idea
how to keep track of what really matters
how we do not drown in information and notification overload
how to excel at the art of teamwork

Our idea

Now, when #poweraddicts really get tired of doing something, they will spend a huge amount of time on automating this. Our idea was to create a process, that

walks users through these considerations
ask them how the “team of their dreams” would look like:

Which channels would they need?
Which columns in an additional SharePoint library could support their work?
How about Microsoft lists?
What would they use to keep track of their tasks?

as a result provisions the Team for them.

We agreed on making this both open-source and enterprise-grade, which affected all of our

Architecture decisions

For our UI, we chose a Power Apps canvas app - following the design guidelines of the Teams UI toolkit so that our app looks and feels like a Teams native app.
As our database, we decided that Dataverse would be the best option to log all requests in
We created security roles in Dataverse to ensure that data wouldn’t get over-exposed
For automation, we went with Azure Logic Apps, as this gave us not only a better developer experience, but would also make deployment easier
Authentication in our Logic Apps is handled by a Managed Identity

We also needed to make some hard decisions, like

No Microsoft Planner provisioning

As the Microsoft Planner API doesn’t support application-level permissions, we chose to not provision a Planner part with ProvisionGenie until Planner comes up with a fully working API. This meant, that we needed to come with an alternative for user to manage their tasks. Optionally, we provision a Microsoft List, that mimics the experience of Planner and introduce users to the gallery view.

Deleting the Teams Wiki

The Teams Wiki isn’t everyone’s darling and we don’t like it for some reasons- but the fact why we decided to delete it as part of the provisioning process for all channels is that, once the Wiki is (accidentally?) removed, all content is hard-deleted.

Making ProvisionGenie a deployable solution

To make this solution available, it was not enough to only provide the (opaque) .zip file for the canvas app. We provide

a Power Platform solution including
- 1 canvas app
- 5 Dataverse tables
- 2 security roles
5 Logic Apps, ready to be deployed with ARM template files, including
- authentication handled by a Managed Identity
- a script to deploy the files
- a script to handle the Microsoft Graph permissions for the Managed Identity
proper documentation

As a result, the app looks like this:

We open-sourced ProvisionGenie 🧞 and just shipped our first release, you can find the repository here - with guidance how to get the app and how to contribute to it: https://github.com/ProvisionGenie/ProvisionGenie

We would love 💜 to get your feedback and improve our solution!

Special thanks go to

Yannick Reekmans, for debugging, guidance, emotional support and introducing me to Carmen
Michael Roth for all ProvisionGenie visuals 💜
Lee Ford for listening to my endless rants during debugging

4 ways to level up your Power Automate flows

Sat, 18 Sep 2021 13:26:31 +0000

Intro

A while back, I wrote about How to use a custom connector in Power Automate showing how easy you can create a connector to a cloud service that is not already in the very long list of connectors in Power Automate. I chose to create a connector for Spotify and connected a Get_Current_Song action with an IOT button and twitter. As a result, information about the song I would be listening to would be tweeted.

Now I stumbled upon a really great blog post by fellow MVP Loryan Strant who also used this Spotify connector to change the pinned message of your status in Microsoft Teams. To get the most value out of this post, go read Loryans post first- it is written with great clarity and also I love this guys’ taste of music 🎶! Also please understand his flow first. I love the idea and creativity! The result of such a flow looks like this:

While some would debate if this flow is necessary, I feel it shows that custom connectors are a great way to extend Microsoft 365. Also: #MusicWasMyFirstLove - case closed :-)

However when reading this blog post, I saw some patterns that I often see in flows and that could be improved - and as I could already learn so much from Loryan, this time I hope to return the favor :-)

Loryan created 13 actions and as I seem to be just more lazy than he is, therefore I thinned out his awesome idea to just 5-6 actions: This is what it looks like:

The result is about the same - just that I display also a message if I am currently not listening to music (yes, this happens!)

Parse JSON

First thing I wanted get rid of was the Parse JSON action. While it is super powerful and lets you easily access properties of objects that you get as response, it is unnecessary sometimes: We can also write the flow without it if we take a look on how we can select properties and return their values in expressions.

To be successful with that, it is crucial to understand the JSON schema of the response we are interested in. Easiest way to achieve that:

a) copy the body of the output of that action, paste it into a code editor - I work with Visual Studio Code b) we make sure that we select JSON as language - VS Code will then color everything nicely for us and highlight beginning and ends of objects for example c) we have a look at the code. For the sake of better readability - this schema is about 450 lines long, I already collapsed two arrays called available markets - it’s a long list of country codes in which a particular song is available. We don’t need it here. If you aim to rebuild this, its highly recommended to copy the code from YOUR output, not from this blog post, as I shortened the code.

 {
"timestamp": 1631969547352,
"progress_ms": 85903,
"item": {
"album": {
"album_type": "album",
"artists": [
{
"external_urls": {
"spotify": "https://open.spotify.com/artist/3CQIn7N5CuRDP8wEI7FiDA"
},
"href": "https://api.spotify.com/v1/artists/3CQIn7N5CuRDP8wEI7FiDA",
"id": "3CQIn7N5CuRDP8wEI7FiDA",
"name": "Run–D.M.C.",
"type": "artist",
"uri": "spotify:artist:3CQIn7N5CuRDP8wEI7FiDA"
}
],
"available_markets": [
],
"external_urls": {
"spotify": "https://open.spotify.com/album/7AFsTiojVaB2I58oZ1tMRg"
},
"href": "https://api.spotify.com/v1/albums/7AFsTiojVaB2I58oZ1tMRg",
"id": "7AFsTiojVaB2I58oZ1tMRg",
"images": [
{
"height": 640,
"url": "https://i.scdn.co/image/ab67616d0000b273894ae4df775c6b47438991af",
"width": 640
},
{
"height": 300,
"url": "https://i.scdn.co/image/ab67616d00001e02894ae4df775c6b47438991af",
"width": 300
},
{
"height": 64,
"url": "https://i.scdn.co/image/ab67616d00004851894ae4df775c6b47438991af",
"width": 64
}
],
"name": "Raising Hell",
"release_date": "1986-05-15",
"release_date_precision": "day",
"total_tracks": 12,
"type": "album",
"uri": "spotify:album:7AFsTiojVaB2I58oZ1tMRg"
},
"artists": [
{
"external_urls": {
"spotify": "https://open.spotify.com/artist/3CQIn7N5CuRDP8wEI7FiDA"
},
"href": "https://api.spotify.com/v1/artists/3CQIn7N5CuRDP8wEI7FiDA",
"id": "3CQIn7N5CuRDP8wEI7FiDA",
"name": "Run–D.M.C.",
"type": "artist",
"uri": "spotify:artist:3CQIn7N5CuRDP8wEI7FiDA"
},
{
"external_urls": {
"spotify": "https://open.spotify.com/artist/7Ey4PD4MYsKc5I2dolUwbH"
},
"href": "https://api.spotify.com/v1/artists/7Ey4PD4MYsKc5I2dolUwbH",
"id": "7Ey4PD4MYsKc5I2dolUwbH",
"name": "Aerosmith",
"type": "artist",
"uri": "spotify:artist:7Ey4PD4MYsKc5I2dolUwbH"
}
],
"available_markets": [
],
"disc_number": 1,
"duration_ms": 310386,
"explicit": false,
"external_ids": {
"isrc": "USAR19900334"
},
"external_urls": {
"spotify": "https://open.spotify.com/track/6qUEOWqOzu1rLPUPQ1ECpx"
},
"href": "https://api.spotify.com/v1/tracks/6qUEOWqOzu1rLPUPQ1ECpx",
"id": "6qUEOWqOzu1rLPUPQ1ECpx",
"is_local": false,
"name": "Walk This Way (feat. Aerosmith)",
"popularity": 69,
"preview_url": "https://p.scdn.co/mp3-preview/c7a8010bbddcd0d793a832de76a24d2cae5ab497?cid=2e75e650d1e74b6a994734ed4aea2ef7",
"track_number": 4,
"type": "track",
"uri": "spotify:track:6qUEOWqOzu1rLPUPQ1ECpx"
},
"currently_playing_type": "track",
"actions": {
"disallows": {
"resuming": true,
"toggling_repeat_context": true,
"toggling_repeat_track": true,
"toggling_shuffle": true
}
},
"is_playing": true
}

b) look for the properties you are interested in - for example we want to if a song is playing right now - we will find the is_playing property, which will either return true or false, which makes it perfect to put this into our condition:

The expression is outputs('Get_Current_Song')['body']['is_playing'].

Why is that? Let’s deconstruct this: From the output of the Get_Current_Song, we are interested in the ['body'] and inside of this we want the value of the ['is_playing'] property

Now if we are also interested in the name of the song, we would do a quick search in that file for name and get four results:

in line 14: this name property sits in the artists array, that consists of an album object and the name property here refers to the name of the artist of album, not to the name of the song that we are interested in.
in line 221: this name property also sits in the album object and refers to the name of the album.
line 235: this name property sits in the artists object and refers again to the name of the artist.
finally, in line 432, we find the name property we were looking for; it sits in the item property.

Therefore, we will access the song name with:

outputs('Get_Current_Song')['body']?['item']?['name]

If we now also want to have the name of the artist, we get this with:

outputs('Get_Current_Song')['body']?['item']?['album]?['artists][0]?['name']

Wait, what? These are a lot of properties, so let’s slow down for a bit to take a closer look:

we get the Get_Current_Song action with outputs('Get_Current_Song')
now we go ahead and with the ? operator and select the first level property we are interested in: item
next up is taking a look inside of the item property: what do we want to get here? It’s the album property. We do this as before with ? and the name of the property in []: ?['album']
Inside of the album property we want to get the artists property and yet again we do this with ? and the name of the property in []: ?['artists']
Now remember that artists was an array? You can see this by the brackets [] in the code. We want to return the first element of this array, therefore we put a [0]. It’s a zero, because arrays in JSON are zero-based, which means that the first element of an array has the index 0, the second one has index 1, and so on.
Now that we returned that first element in the artists array (it’s only one, but Power Automate will yell at you if you don’t select just one element and instead return the entire array), we will go ahead and finally select the name property from it, which refers to the artist.

You see, it’s all about understanding the underlying JSON schema and see, which properties are part of which objects. If you use the Parse JSON action, you don’t need to write these expressions, but you face some disadvantages:

you can now select from four name properties in your dynamic content - and need to select blindly
You have no clue WHY you get four of those as you don’t understand the data structure
Parse JSON is yet another action which blows up your flow

unnecessary Apply-to-each loops

You know that moment when you are creating a flow and and out of a sudden Power Automates automatically adds an Apply-to-each for you and you wonder why this happened? Also, you will face some issues later on? Wherever possible it’s a good idea to avoid loops that are not necessary.

The fact that we didn’t just parse the JSON output from our Get_Current_Song action but understood the JSON schema gives us an option to avoid a loop - we did not return an array of (one) artist, that triggered Power Automate to insert an apply-to-each loop, but we only returned the first element of the artist array - this way we don’t need to loop over this one-element-array, which means that we got rid of another action!

variables and expressions

Power Automate knows some nice actions for variables - the most important one is initialize variable - in Power Automate all variables need to be initialized (with or without value) before we can use them.

Now as we already skipped successfully the Parse JSON action and could also access artist name and song name without the use of variables but in expressions, I want to minimize the other initialize variables and compose actions from Loryans flow:

Instead of several actions and calculations to

– get the timestamp when the song started – get the current time – add the duration of the currently playing song to the current time,

we could have one variable called duration with this expression: addSeconds(utcnow(),div(sub(outputs('Get_Current_Song')?['body']?['item']?['duration_ms'],outputs('Get_Current_Song')?['body']?['progress_ms']),1000))

Explanation:

This adds seconds to utcnow(), which is the current time.
How many seconds? The return value from the subtraction of the duration in milliseconds ['duration_ms'] minus the ['progress_ms'] current progress in milliseconds
With the div function this value is divided by 1000 as we want seconds instead of milliseconds.

understand APIs

The Get_Current_Song returns the LAST song that was played - and the is_playing property returns if the song is currently (still) playing or not. This means, that we need to distinguish between a song that played before I needed to turn off the music and a currently playing song. You might say, well, this doesn’t really matter - but if we take a closer look to understand, which data is returned when, we would need to redesign our flow: The fact that we get an output of the get_Current_Song even if the is_Playing property is false, means that we don’t get a null when our subsequent actions expect an object, a string, an array or anything else that is NOT null. Yet again, understanding what happens behind the scenes because we understand the output of an action will make it easier to create flows.

How to get started with GitHub and Git

Thu, 09 Sep 2021 13:26:31 +0000

Intro

Ever wondered how you could get started in contributing to open-source projects? Let’s say you would like to contribute to an open-source project and the contributing guide tells you that you would need to fork a repository and you have no idea what this should mean? Fear not, help is on the way and you already opened it. We will also cover how you connect everything in the code editor Visual Studio Code and where you can find like-minded people.

What are GitHub and Git?

Don’t confuse Git and GitHub- they are related to each other, but not the same:

GitHub is website for hosting projects that use Git.
Git a software for version control that makes it easy for developers (authors, makers and more) to track even minor (but also big) changes in files.

At the very heart of GitHub, you will find repositories to host your content in. You can invite specific people to collaborate with or open your project for everyone - while still staying in control. Small changes in files can be made on the GitHub.com website. This is very convenient, as it gives you a nice interface and you don’t need to store any files on your computer. However, the bigger the change is that you want make, the more you will need a more sophisticated system. For example, if you need to pause your work and want to continue later on, there is no way on the website to save your files without committing them. So, what is a commit and how does that work?

A commit is a change to one or more files. You save your work by committing it, and git (not GitHub) will create and assign unique ID, which is called hash or SHA. This then allows you to answer questions like:

Who changed that? (author)
What exactly changed? (highlights the changes)
Why did this change happen? (reading the commit message (should be a short description what changed and why))

This enables traceability, revertability, and collaboration. Just imagine we would work with code like we did this with Excel sheets and PowerPoint presentations for years… saving the 2021-09-08-project-deathstar-draft_07-super-important_finalFINAL2.pptx (1) and then mailing copies of copies of that file around 🙄

As already mentioned, GitHub is a good way to host your projects, but its website comes with some limitations, as, for example, we can’t save this for later but I don’t want to commit yet, and most probably no one wants to write their code on a website… it means you can’t work offline or with poor connectivity, also, what if you accidentally close the browser tab? What if we could write our code, documentation, more in local files on our computer and then use Git to upload them to GitHub once we are ready? To achieve this, we need a couple of things and this article will cover all of that:

Install Git

First, we will install Git for Windows, if you work on a macOS, download Git for macOs. To continue with Windows,

Open Git for Windows
Download the latest version (64-bit or 32-bit).
Optional: If you are not sure what you need, you can check it:
- Press WIN key and type about
- Select about your PC, it shows you the System type in the device specifications
Open the downloaded file
Confirm the User Account Control window by selecting Yes
In the Git Setup window, select Next for 6 times, Git will now extract the files
Select Finish

Create a Git account

Now let’s first check if you installed Git correctly

Open PowerShell or PowerShell in the terminal of Visual Studio Code. (If you don’t have VS Code installed please install it- it’s an amazing Code editor.)
Type git --version in a directory of your choice
You should see the installed version as a response

If so, you can proceed!

Set your user name with git config --global user.name "<your-first-name> <your-last-name>" - replace the <placeholders> with the real values
Set your email address with git config --global user.email "<your-email-here>" - replace the <placeholder> with the real values

Congrats, you now have a Git account.

To use Git, we will either need a GUI (graphical user interface) client or a CLI (command-line interface). This is somehow a matter of personal preference, but I found GUI clients a bit more confusing.

Before we learn some Git commands, lets head over to GitHub and get you an account if you don’t already have one.

Create a GitHub account

Open github.com
Select Sign up
Type in your email address when prompted
Select Continue
Type in a password
Select Continue
GitHub will generate a username for you, but you may change it
Select Continue
Type y if you want product updates per mail, else type n
Select Continue
Verify that you are a human by selecting Start puzzle
Select the correct image that meets the criteria described - maybe you need to do this twice.
Select Create account
Type in the 6 digit code that you received per mail
Optional: personalize your experience

Create a repository

Now create your first repository and make it available for you in VSCode:

Select Create repository
Notice that you will be the owner of said repository
Type in a name for the repository
Select add a README file
Select Create repository
Notice that this is already a commit, and more specific the initial commit - If you select 1 commit you can see the the changes made:
- additions highlighted in green
- deletion highlighted in red (this time, we only added something and that was the name of the repository)
- author who changed the file (your account)
- time of when the changes were made
- hash of the commit

Now that you have your own repository, make it available on your computer. We do this by cloning the repository:

Clone the repository

Select Code
Copy the URL (it is https://github.com/<YOUR GITHUB ACCOUNT>/<YOUR REPOSITORY NAME>.git)

Open the terminal in VS Code
navigate to a directory where you want to clone the repository (you can use cd <PATH OF YOUR DIRECTORY> for this)
type git clone <COPIED URL HERE>

This will create a copy of your remote repository in that folder. Now navigate to your local copy with cd <YOUR REPOSITORY NAME HERE> Open the project in Visual Studio code by typing code . in PowerShell or terminal in VS Code (yes, there is a between code and .)

Work with your clone

Now either add some files or change the only existing file (it’s the README.md). When you completed your changes, you want 3 things:

add the files you want to commit to a staging area (and only those)
commit the files with a descriptive commit message
push the files so that the changes will be reflected on the GitHub website as well.

As you probably already assumed, there are some specific command to achieve this:

to add a specific file to that staging area from which you can commit it (without touching the other files that are not ready to be committed now), type git add <YOUR FILENAME HERE> for a specific file or git add <YOUR PATH HERE> for a specific directory. If you want to add all changes to the staging area, type git add . (yes, there is a between add and .)
to commit all files that are now in staging area, type `git commit -m “”
to push your changes, type git push

Your changes are online 🎉

If you now use both, the GitHub website and your local files, the changes that you make remote won’t be reflected automatically in the local files. To do that, you will need to type git pull to pull all the changes that were made remote. If you forget that, or if others were working on your repository and you want to push next time, git will tell you:

! [rejected] main -> main (fetch first)
error: failed to push some refs to 'https://github.com/M365Princess/MyFirstRepository'
hint: Updates were rejected because the remote contains work that you do
hint: not have locally. This is usually caused by another repository pushing
hint: to the same ref. You may want to first integrate the remote changes
hint: (e.g., 'git pull ...') before pushing again.
hint: See the 'Note about fast-forwards' in 'git push --help' for details.

Read the message carefully and go ahead with git pull to be up to date in your local files. You can now accept the maybe conflicting changes in the editor and resolve the situation.

Then use the commands git commit and git push again. (You can always access your last commands with the arrow-up and arrow-down key.) You should see a response that looks about like this:

Please note that you see two abbreviated hashs, with which you could also compare what happened in the last commit compared to the previous one: Type git diff <FIRST HASH HERE> <SECOND HASH HERE>

Contribute to open-source projects

But what if you want to contribute to a repository of which you aren’t the owner? It’s possible to work locally in those projects as well, but we need to do a couple of more steps:

Fork the repository

as the repository owner would not want you to directly commit to their repository, you will first create a remote copy - this is then called your fork. To do that:

open the repository that you want to contribute to
make sure you understand the contributing guide, in most cases, you will be asked to fork the repository:
Select Fork, the URL of your fork is now https://github.com/<YOUR GITHUB ACCOUNT>/<REPOSITORY NAME>/

Now clone this repository locally.

Add Upstream

You will now want to make sure, that all your contributions point to the original repository, which is why you want to add an upstream to it:

navigate to the folder where your cloned repository is located
type git remote add upstream <ORIGINAL REPOSITORY URL HERE>
to check if everything works correctly, type git remote -v, you should see this output:

origin https://github.com/<YOUR ACCOUNT HERE>/<REPOSITORY NAME>.git (fetch)
origin https://github.com/<YOUR ACCOUNT HERE>/<REPOSITORY NAME>.git (push)
upstream https://github.com/<ORIGINAL ACCOUNT HERE>/<REPOSITORY NAME> (fetch)
upstream https://github.com/<ORIGINAL ACCOUNT HERE>/<REPOSITORY NAME> (push)

Some repository owners will ask you in the contribution guide to create a new branch for the feature you want to add - you can create and switch to that new branch with git checkout -b <YOUR BRANCH NAME HERE>. Like in your own repository, you can work on the local files and commit and push your changes to your remote fork.

Pull request

You will now want to (kindly) ask the repository owner/ maintainer to pull in your changes. You do that by doing a pull request:

Open the original repository
Select Pull requests
Select New pull request

Select compare across forks
Select your fork from the head repository

fill out the form

working together

A maintainer will review your pull request and

reach out to you with a comment (you will get a notification about that)
request changes or
merge your changes. This means that they approved your work and that your changes will be added to the original repository.

Additional resources

If you ned more help for your first contributions, have questions or just want to connect with like-minded people, and for everyone who is more into interactive sessions: Within Microsoft 365 PnP, I am part of the Sharing is Caring initiative, who aims to lower barriers for new contributors. We run a couple of sessions, please check out Sharing is Caring

You can also have a look into the documentation of GitHub and Git- this article should only get you started, not replace reading the docs.

Open-source is fun and very rewarding and I hope that this article made your start a little bit easier! Please reach out if you have questions, comments, or want to connect.

Create a portfolio site with GitHub pages and reveal.js

Mon, 06 Sep 2021 16:09:09 +0000

In this post I want to show how you can create a simple portfolio site with GitHub pages and reveal.js

GitHub pages lets you host your website directly from the GitHub repository

But instead of having a lengthy README.md file with a lot of images in it, we want to use reveal.js to create a cool look&feel:

reveal.js is an open-source HTML presentation framework that lets you create rich, interactive slides using open web technologies.

The result should look a little something like this:

To go from 0 to hero, we will need to accomplish the following steps:

I will show how todo this on Windows and using Visual Studio code, if you run on a different OS or code editor, it might look a bit different, but the steps stay the same.

create a repository

open github.com
log in. If you don’t have an account, sign up, it’s free.
select New

Give it a name
Check Add a README file
Check Choose a license
Select a License that suits your needs
Select Create repository

Now let’s clone this repository so that we have it locally available:

Select Code, then copy the URL to your clipboard
Open Visual Studio Code terminal or (I run PowerShell, your commands might look different if you run another shell)
Navigate to a folder where you want to clone the repository
Type git clone <COPIED URL GOES HERE>
Navigate to your new folder with cd <YOUR REPO NAME GOES IN HERE>
Open your project in a new VSCode instance with code . (yes, there is a between code and the .)

reveal.js

preparations

To install reveal.js, we will need to prepare our repository a bit:

Create a new docs folder at the root of your (nearly) empty repository with mkdir docs
Navigate to this docs folder with cd docs
Create a media folder (this is where you will store all your portfolio images in) with mkdir media

installation

Download the reveal.js zip file from here: reveal.js basic setup
unzip the file into the docs folder of your repository

create slides

open the index.html file
replace the existing two sections with your content, link to images that you will store in the media folder.

<!DOCTYPE html>
<html>
 <head>
 <meta charset="utf-8" />
 <meta
 name="viewport"
 content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no"
 />

 <title>Demo Portfolio</title>

 <link rel="stylesheet" href="dist/reset.css" />
 <link rel="stylesheet" href="dist/reveal.css" />
 <link rel="stylesheet" href="dist/theme/black.css" />

 <!-* Theme used for syntax highlighted code -->
 <link rel="stylesheet" href="plugin/highlight/monokai.css" />
 </head>
 <body>
 <div class="reveal">
 <div class="slides">
 <section>Unicorn slide<img src="media/unicorn.png" /></section>
 <section>Cupcake slide <img scr =media/cupcake.png"></section>
 </div>
 </div>

 <script src="dist/reveal.js"></script>
 <script src="plugin/notes/notes.js"></script>
 <script src="plugin/markdown/markdown.js"></script>
 <script src="plugin/highlight/highlight.js"></script>
 <script>
 // More info about initialization & config:
 // * https://revealjs.com/initialization/
 // * https://revealjs.com/config/
 Reveal.initialize({
 hash: true,

 // Learn about plugins: https://revealjs.com/plugins/
 plugins: [RevealMarkdown, RevealHighlight, RevealNotes],
 });
 </script>
 </body>
</html>

create GitHub pages

We will now create the GitHub page

open your GitHub repository again
Select Settings
Select Pages
Select main as Branch
Select /docs as folder
Select Save

Now let’s publish :-)

In terminal, type

git add . to add all changes to your staging area
git commit -m "<YOUR COMMIT MESSAGE HERE>"
git push

If you work on Windows, it might be that you see warnings for all files:

The file will have its original line endings in your working directory warning: LF will be replaced by CRLF in reveal.js-master/test/test.html.

The end of a line in a unix system represented with a line feed (LF), while on windows a line ends with a carriage return (CR) and a line feed (LF) => (CRLF). We get this warning on Windows when the file was originally uploaded from a unix system. What to do about it?

You can either decide to not care (everything should be working fine, just those warning can be a little annoying), you can read more about line endings and in case you are really the only developer working on these files, you can change settings with git config core.autocrlf true.

Now check again the GitHub Pages site - it should confirm:

If you now select the link, you should see your GitHub pages site!

How to continue:

make vertical slides
change to a different theme
tell others :-)

I hope you liked this little tutorial!

Putting some more FUN into Azure Functions, Managed Identity & Microsoft Graph

Sat, 07 Aug 2021 18:20:02 +0000

I want to show, how you can use a Managed Identity in Azure Functions to get an access token for Microsoft Graph API. I will later expand on that scenario and make the solution available to be consumed in Power Platform.

Solution Overview

Prerequisites to benefit from this article

To get the most out of this post, you should understand the following concepts - I included some links that should help you getting started.

Managed Identity - What is that and why would I want one?

Managed Identities are the state-of-the-art way to get Azure Active Directory access tokens, because you won’t need to handle credentials, which is of course a security benefit

where there are credentials, there are leaks ¯\_(ツ)\_/¯

If you are unfamiliar with tokens, this article by Lee Ford will help. This is not a full tutorial on Managed Identities, for more information please start to read here. Also, Yannick Reekmans posted an entire series on Managed Identities, highly recommended to read this - helped me a lot to understand.

Azure Functions

If you’d like to deploy and execute code without needing to THINK about server infrastructure or VMs, you may like Azure Functions. Azure Functions can be written in a lot of languages and you can deploy and execute Azure functions on any platform that can run .NET Core. Azure Functions are scalable, as they use compute-on-demand: More resources are allocated automagically, when the demand of execution increases. If the demand decreases again, you don’t need to worry about the extra resources anymore as they drop off again. This way, you only pay what you need. For more info please start to read here: Azure Functions Overview | Microsoft Docs

I will use PowerShell for my Azure Functions, so that IT-Pros can benefit from this post as well. But please do choose ~~your poison~~ your favorite language, the concept stays the same. Use whatever you are familiar with or what makes you happy.

Microsoft Graph

Microsoft Graph is THE API to access Microsoft 365 resources, in our case we will want to read all Microsoft 365 groups - for more information see also the Microsoft Graph permissions reference - Microsoft Graph | Microsoft Docs.

Our challenge will be to access the Graph API with a Managed Identity. I will show how to do this entirely in Azure CLI & VS Code. Creating and assigning Managed Identities has been shown often before in the Azure portal, but a script would allow for automation, it is usually faster than working in a visual environment and you can use the tool of your choice. I highly recommend VS Code as editor (and I like the built-in terminal as well).

Create your Azure Functions locally

You still may create your first Azure Function in the Azure Portal (I did as well), which demos really nicely, but as we want to go for real world, I will show how to develop your Azure Functions in Visual Studio code. This has some great advantages:

you develop locally using the tools that you are already familiar with
you don’t need to adjust to ever changing UI in Azure portal
you can benefit from source control
you can collaborate with others

I covered how to do this also in a previous post, but for the sake of a start-to-end scenario, here we go again:

Install the Core Tools package with npm install -g azure-functions-core-tools@3 --unsafe-perm true
Install the Azure Functions extension for VS Code
Select New Project
Select a folder for your project
Select a language - I will use PowerShell
Select HTTP trigger as a template
Type in a better name like GetGraphToken
Select Authorization level Function
Select how you want to open your project – I prefer Add to workspace

You will now see your Local Project in the pane.
(yes, my pane is on the right hand side so that my code doesn’t “jump” all the time when I am expanding or collapsing the pane)

Visual Studio Code showing an Azure Functions project

We will now write the code. Replace the default code of run.ps1 in VSCode by this:

using namespace System.Net

# Input bindings are passed in via param block

param($Request, $TriggerMetadata)

# Write to the Azure Functions log stream.

Write-Host "PowerShell HTTP trigger function processed a request."

# Interact with query parameters or the body of the request

.$Scope = $Request.Query.Scope
if (-not $Scope) {
 $Scope = $Request.Body.Scope
}
#If parameter "Scope" has not been provided, we assume that graph.microsoft.com is the target resource
If (!$Scope) {
$Scope = "https://graph.microsoft.com/"
}

$tokenAuthUri = $env:IDENTITY_ENDPOINT + "?resource=$Scope&api-version=2019-08-01"
$response = Invoke-RestMethod -Method Get -Headers @{"X-IDENTITY-HEADER"="$env:IDENTITY_HEADER"} -Uri $tokenAuthUri -UseBasicParsing

$accessToken = $response.access_token

#Invoke REST call to Graph API
$uri = 'https://graph.microsoft.com/v1.0/groups'
$authHeader = @{
'Content-Type'='application/json'
'Authorization'='Bearer ' + $accessToken
}

$result = (Invoke-RestMethod -Uri $uri -Headers $authHeader -Method Get -ResponseHeadersVariable RES).value

If ($result) {
$body = $result
$StatusCode = '200'
}
Else {
$body = $RES
$StatusCode = '400'}

# Associate values to output bindings by calling 'Push-OutputBinding'

Push-OutputBinding -Name Response -Value ([HttpResponseContext]@{
StatusCode = $StatusCode
Body = $body
})

Take a moment to understand what the code does:

log that a request was received
define the scope (if not stated, it’s Microsoft Graph)
obtain the token from the environment variables IDENTITY_ENDPOINT and IDENTITY_HEADER which come from the Managed Identity (thanks Yannick Reekmans for this hint) - learn more here: Managed identities - Azure App Service | Microsoft Docs - you can also see your environment variables here, the mentioned ones will show after you assigned the system assigned Managed Identity: https://<your-functionappname-here>.scm.azurewebsites.net/ENV.cshtml#envVariables)
pass that token in the header of the REST call towards the group endpoint of Microsoft Graph
get the status code (hopefully 200)

Watch out - the Graph API will this way return up to 100 groups - Please adjust with query parameters as needed like https://graph.microsoft.com/v1.0/groups?$top=42 or use pagination, which is described here: Paging Microsoft Graph data in your app - Microsoft Graph | Microsoft Docs

Resources in Azure

We will now create the Functions App in Azure - You can either install the CLI or use Cloud shell (available on shell.azure.com - no installation is needed then and it works in any browser!)

Variables & names

For testing purposes, I pseudo-randomized a number to not always need to come up with new names:

#Get a random number between 100 and 300 to more easily be able to distinguish between several trials
$rand = Get-Random -Minimum 100 -Maximum 300

We will now set some variables,this reduces risk of typos and makes our code better readable, also we can reuse it better. This is a courtesy to future-self

#Set values
$resourceGroup = "DemoPlay$rand"
$location = "westeurope"
$storage = "luisedemostorage$rand"
$functionapp = "LuiseDemo-functionapp$rand"`

Resource group

Let’s create a resource-group that will later hold our Azure Functions App

#create group
az group create -n $resourceGroup -l $location`

Storage Account

As our Functions App will need a storage account, we will create this as well:


#create storage account
az storage account create ` -n $storage`
-l $location ` -g $resourceGroup`
--sku Standard_LRS

Function App

Now create the Azure Functions App which later holds our function (remember we created that earlier locally, but will later deploy it to Azure)

#create function
az functionapp create ` -n $functionapp`
--storage-account $storage ` --consumption-plan-location $location`
--runtime powershell ` -g $resourceGroup`
--functions-version 3`

It will take a few moments for everything to be set, once this step is completed, you will be prompted with a message, that you also can benefit from Application Insights.

Managed Identity

We want things to be super secure - this is why we want to enable a system assigned Managed Identity for our new function:

az functionapp identity assign -n $functionapp -g $resourceGroup

Our Managed Identity shall have the right permission scope to access Graph API for Group.Read.All, and to eventually be able to make the required REST call, we will need the Graph API service Provider permission scope, expressed as App role. Let’s do this:

Get Graph Api service provider (that's later needed for --api)
az ad sp list --query "&#91;?appDisplayName=='Microsoft Graph'].{Name:appDisplayName, Id:appId}" --output table --all
#Save that service provider
$graphId = az ad sp list --query "&#91;?appDisplayName=='Microsoft Graph'].appId | &#91;0]" --all
# Get permission scope for "Group.Read.All"
$appRoleId = az ad sp show --id $graphId --query "appRoles&#91;?value=='Group.Read.All'].id | &#91;0]" `

Time to make the REST call to assign the permissions as shown above to the Managed Identity:

#Set values
$webAppName="LuiseDemo-functionapp$rand"
$principalId=$(az resource list -n $webAppName --query &#91;*].identity.principalId --out tsv)
$graphResourceId=$(az ad sp list --display-name "Microsoft Graph" --query &#91;0].objectId --out tsv)
$appRoleId=$(az ad sp list --display-name "Microsoft Graph" --query "&#91;0].appRoles&#91;?value=='Group.Read.All' && contains(allowedMemberTypes, 'Application')].id" --out tsv)
$body="{'principalId':'$principalId','resourceId':'$graphResourceId','appRoleId':'$appRoleId'}"
#the actual REST call
az rest --method post --uri https://graph.microsoft.com/v1.0/servicePrincipals/$principalId/appRoleAssignments --body $body --headers Content-Type=application/json`

If you like to, you may now have a look at our Managed Identity permissions in the Azure portal - for everyone who loves to be assured in a UI that things have worked:

Open portal.azure.com
Select Azure Active Directory
Select Enterprise applications
Select Managed Identity from the Applications dropdown
Note the app level permission Read all groups for Microsoft Graph

Deploy to Azure

Let’s now deploy our function to our Functions App. Go back to Visual Studio Code:

Select the Azure extension *Select deploy to Functions App - its that little cloud icon

Select the Functions App you already created in Azure
Confirm the Pop up window by selecting Deploy

Time to test!

Please note, that due to our Managed Identity, we can’t test locally. You can trigger your functions with Postman or similar or run a test in the Azure portal:

Open portal.azure.com
Select Resource groups
Select the resource group you worked in
Select the Azure Function App you worked in
Select Functions
Select Code + Test
Select Test/Run
Select Run

You should see a status code 200 - and a list of all your Microsoft 365 groups. YAY!

Conclusion and FusionDev scenario

As developers, we could build a robust, scalable and secure solution, developed with familiar tools like VS Code, PowerShell or Azure CLI. But what if we want to make this available to makers/citizen developers? What if we want to make sure, that this could be used in Power Apps and Power Automate? One way to achieve this, is creating a Power Platform custom connector. This way, makers can use the connector which calls our Azure Functions in a canvas app and display for example the groups in a gallery or table.

Please note, that there are of course more fancy use cases, I will focus in this blog post on the code - If you have a good story, please reach out 🙂

More Resources to learn

Get started with Microsoft 365 development by signing up for a free Developer tenant

Join the Microsoft 365 PnP Community - join our calls and benefit from guidance, tools, samples

The friendly SMS reminder with Logic Apps, Azure Functions & Key Vault

Mon, 26 Jul 2021 20:37:57 +0000

Yay, this is a new blog post series on how to put the FUN in Azure Functions 🙂

Recently, I was learning about Azure Functions and came up with a sweet use case what I could do to combine Azure Functions and Logic Apps: I want to automatically call or text myself (using Twilio) to remind me of recurring tasks, like putting away the laundry , buying more Lego , or similar.

There will be of course more sophisticated use cases, for the sake of an easy demonstration we will stick to this and use a simple SMS.

Prerequisites

Azure subscription -If you don’t have one, you can get one for free here
Twilio account
Twilio trial number - trial comes for free - sign up here Twilio Luise (Transparency: This is a referral link, which will get you and me 10$ to spend on Twilio for cool future projects that aren’t covered by the trial. However, if you don’t like us to get the 10 bucks, you can also sign up without the referral link with https://www.twilio.com)

Here is our solution overview:

As you can see, we will touch some interesting things like

Azure Logic Apps
Azure Function App
Azure Key Vault
Managed Identity
Twilio API

I will sometimes provide several approaches to reach the same goal, you can pick whatever feels right to you.

Azure Resource group & Function App

Ok, so we will create an Azure Function App that will do the heavy lifting for us. Our Azure Function needs a Resource group to live in, and we will first create the Resource Group and then add some resources to it.

Go to portal.azure.com
Select Create a resource

Search for Function App in the search bar
Select Function App

Select Create

Fill out the form:
- (1) Select your Azure subscription
- (2) Select Create New to create a new Resource Group where our Function app lives in
- (3) Type in the name of your new Resource group
- (4) Select OK
- (5) Give your app a name
- (6) Select Node.js as Runtime stack
- (7) Select your Region
- (8) Select Review + Create

you can now review everything - as a last step

Select Create

It will take a few seconds for Azure to deploy your Resource group and the Function App. You will be notified when everything is ready for you.

As an alternative, you may want to create your Azure Function from within Visual Studio Code:\

Creating the Azure Function in Visual Studio Code

Please follow these steps:

Install the Core Tools package with npm install -g azure-functions-core-tools@3 --unsafe-perm true
Install the Azure Functions extension for VS Code
Select New Project
Select a folder for your project
Select a language
Select HTTP trigger as a template
Type in a better name, like SampleTexts
Select Authorization level Function
Select how you want to open your project - I prefer Add to workspace

You will now see your Local Project in the pane.

You can now develop, debug and test your function locally and have source control of your code . I like this way more than jumping back and forth in the different blades of the Azure portal - also, I rely on IntelliSense pretty much ¯_(ツ)_/¯

To deploy your function app, select the **deploy **icon. If you are not already logged into your Azure account, a browser window will pop up and ask you to sign in with your credentials.

Once you selected the deploy icon, you need to specify the function in Azure and need to confirm that you know what you are doing 🙂

Azure needs again a few seconds to deploy and Visual Studio Code will let you know once this is done ✅

Twilio

Before we add a function and some code to it, let’s understand first what we will be doing: We want to automagically send a text message to our own phone number. We do this by using our brand new Twilio account and log in with our account SID and an Auth token. We will also need our own phone number and the trial number we got from Twilio. As we do not want to hard-code these credentials, we will store them in the Function app configuration and refer to the configuration in our code. In a second scenario below, I will show how to store the credentials even more secure in an Azure Key Vault. But first, head over to Twilio, create an account and get a trial number. Your Twilio Dashboard should look a little like this:

Copy Account SID
Copy Auth token
Copy your Trial number
Have your own phone number present

We will need these values in a moment!

Azure Function App configuration

Head over to your Azure Function App

(1) Select Configuration
(2) Select New application setting
(3) Type in TWILIO_SID as name
(4) Paste in your copied Account SID as the value
(5) Select OK

Repeat step 1-5 from above for

TWILIO_TOKEN
SENDER_NUMBER (your Twilio trial number)
RECIPIENT_NUMBER (your phone number)

Hit save Your App setting should now look like this:

Azure Function App -add function

Now its time to add some functionality to our app:

(1) Select Functions
(2) Select Add
(3) Select HTTP trigger
(4) Type in a name
(5) Select Add

(1) Select Code + Test
(2) Delete the sample code in the index.js file
(3) Paste in the following snippet:
(4) Don’t forget to hit the save button - I always do ¯_(ツ)_/¯

const accountSid = process.env.TWILIO_SID;
const authToken = process.env.TWILIO_TOKEN;
const client = require("twilio")(accountSid, authToken);

module.exports = function (context) {
 client.messages
 .create({
 from: process.env.SENDER_NUMBER,
 body: "Woohoo- it worked!",
 to: process.env.RECIPIENT_NUMBER,
 })
 .then((message) => {
 context.log("Message sent");
 context.res = {
 body: "YAY it worked - girl check your phone ",
 };
 context.done();
 })
 .catch((err) => {
 context.log.error("Twilio Error: " + err.message + " -- " + err.code);
 context.res = {
 status: 500,
 body: `Twilio Error Message: ${err.message}\nTwilio Error code: ${err.code}`,
 };
 context.done();
 });
};

Please note

how we refer to the app configuration settings with environment variables - If this is your first Azure Function app, I can highly recommend that you have a look over here: JavaScript developer reference for Azure Functions | Microsoft Docs
that we of course want a success (for status 200/default) or error message (for status 500)
More information on how to work with Twilio - including code - How to Send an SMS with Node.js (twilio.com)

Now Select Overview and then Get Function URL - copy the URL- we will need this in the next step.

Azure Logic Apps workflow

Let’s now have some more fun in Azure and use a Logic Apps workflow to trigger our Azure Function. We will first add a Logic App to our resource group and then define a workflow within that app. We will cover two options how to call our Azure Function, option A with the built-in ‘Call an Azure Function’ action and as option B with an HTTP action. In both cases, navigate to your resource group>

Select Create a resource
Search in the search box for Logic App
Select Logic App from the results
Select Create

Now fill out the form as follows:

(1) Select your Azure subscription
(2) Select your Resource Group
(3) Type in a name
(4) Select your region
(5) Select Review + Create

You can now review your input - when everything looks OK, then select Create

Azure will need a few seconds to deploy your brand new resource and notify you once this is completed. Once this is done,

(1) Select Workflows
(2) Select Add
(3) Type in a name for your workflow
(4) Select Stateful
(5) Select Create

Now select your new workflow and follow these steps:

(1) Select Designer
(2) From the left hands pane, select Recurrence as a trigger
(3) Fill out the form as follows for a weekly reminder on Sundays (as an example) by adding parameters Start time and On these days - For testing purposes I’d choose a higher frequency 🙂

as stated above, there are (at least) two ways to call our Azure function, this is:

Option A with the built-in ‘Call an Azure Function'

Select the + icon in the designer
Select Add an action
In the left hands pane, search for Azure Fun
Select Call an Azure Function
Select your Azure Function App
Give your connection a name
Select the function within your Functions app
Select Create

Select Get as Method
Save your app.
Select Overview
Select Run Trigger
Select Run

Note the custom output body that we defined in our Azure Function

Now let’s discover the other option to call our Azure function:

Option B with the generic HTTP action

Create your workflow as above, but instead of searching for Azure Fun, search for HTTP

Select HTTP
Select Method GET
Enter the copied Azure functions URL as URI
Save your workflow

Once again, you can see the outputs of your workflow run ✅

Next step, makes this even more secure by storing our Twilio token and the Twilio SID in an Azure Key vault so that we can refer to it in our app configuration.

Azure Key Vault

Head over to your Resource Group

Select Create a resource
Search in the search box for Key vault
Select Key Vault from the results
Select Create

Now fill out the form as follows:

Review and select Create.

It will take a couple of seconds again for Azure to deploy your resource and you will be notified once the Key vault is ready for you.

In our shiny new Key Vault, we need to store the key/value pairs for both Twilio SID and Twilio Auth Token:

(1) Select Secrets
(2) Select Generate/Import
Fill in the form as follows:
- Name: **TWILIOTOKEN **(watch out, no underscores allowed)
- Value: the copied Twilio token value from your Twilio dashboard
Select Create
Repeat for TWILIOSID

We will use these two secrets later again in our Azure Function, but to make this work, we first need to enable system-assigned Managed Identity to it and then add an access policy for our function app. If you never heard about that, Yannick Reekmans blogged a series about secretless applications.

Head over to your Function app again and

(1) Select Identity
(2) Switch the Status toggle to On
(3) Select Save

A Pop-up displaying the following message appears, select Yes

Now we will add the access policy to our Key vault so that our function may read the secrets. Head over to the Key vault and

(1) Select Access policy
(2) Select Add Access Policy

Now fill out the form as follows:

Key permissions: Get and List
Secret permissions: Get and List
Certificate permissions: Get and List
Select principal:
- Search for the name of your functions app
- Select it
- Select Select
Select Add
Don’t forget to Save

Now that our function app has permission to read the secrets from our Key vault, we will reference to the secret in the functions app configuration and get rid of the hard coded values in there. For this, we only need the name of our vault and the name of the secrets TWILIOTOKEN and TWILIOSID.

Let’s now add these to the app configuration of our functions app. Head over to the functions app and

Select Configuration
Select New Application Settings

Fill out the form as follows:
- Name: TWILIOSID
- Value: @Microsoft.KeyVault(VaultName=myvault;SecretName=mysecret)
- Select OK
Repeat for TWILIOTOKEN
Don’t forget to **Save
**

Now let’s get rid of our hard coded values in the app configuration to clean up things:

Select the Delete icon - please check twice to delete the right settings!

Now we need to make sure that our Azure function looks at the right app settings.
Select Functions

Select your function
Select Code + Test
Replace the old environment variables by the new ones
Don’t forget to Save

**That’s it - you made it work! And this is the result: **

You successfully

✅ created a resource group

✅ build a function app with one function

✅ called an API in that function

✅ stored secrets in a Key Vault

✅ assigned Managed Identity

✅ referenced to your Key vault in your function app configuration

✅ created a Logic app that kicks off the function weekly

Conclusion & what’s next?

Both approaches low code (Logic Apps) and Code (Azure Functions) tie in nicely together. Some thoughts though for everyone who wondered:

yes, you could get the same result with about 42 other approaches - there is no THE right way to do it
yes, you can replace the the Logic App with a Power Automate flow - which comes with some disadvantages:
- the HTTP action requires a premium license
- you can’t easily monitor your entire solution in Azure as your flow would now not live in your resource group anymore
- your flow would run in a user’s context - or would need a service account ( MFA)
- you can’t easily templatize and deploy and redeploy your entire solution anymore as the flow is not part of your resource group.
no, I did not want to use the Twilio connector in Power Automate or in Logic Apps which allows to send SMS without a single line of code - I was looking for a well documented service outside of Azure to showcase that we can call any API in Azure Functions. If you want to level up:
the amazing Chloe Condon delivered a session on IOT and Azure Functions, watch the video here
yes, you can do all of the above in Azure CLI as well, to get you started, please read here: Azure Functions | Microsoft Docs

You have a more fancy use case? Let me know about it! Just imagine that we can integrate other services/data in Azure and/or Microsoft 365 and beyond - and decide if we want to do this in a low code or code manner.

In my next post I will show how to templatize and deploy a solution.

Should you attend yet another meeting?

Mon, 12 Jul 2021 09:51:53 +0000

Do you suffer from meeting overload as well?

We joke around, that “this meeting could have been an email” and still our calendars are filled with meetings, meetings and even more meetings. Sometimes, our time is double or even triple-booked. We “wait for everyone to join” because we know that people sit in hour-long or day-long back-to back sessions. This comes with a lot of disadvantages… Our ability to focus on the content is going down, we zone out, we do other stuff (like catching up on mails and messages while we are stuck in a meeting ).

We need to develop a new skill: determining if our presence (not only having our account joined the meeting but proactively contributing to the meetings objectives) is required or not. To make better decisions when you are about to hit the “accept, use this handy flowchart:

LearnTogether: Build Apps with Microsoft Graph

Thu, 15 Apr 2021 14:43:10 +0000

This week, I had the great pleasure to attend Microsoft’s Learn Together: Build apps for Microsoft Graph event. I also did sketchnotes of the event, you may find high resolution files (images, gifs and mp4) are available here on GitHub.

Call to action: Learn how to make apps with Microsoft Graph and complete this Microsoft Graph Learn Challenge

Microsoft Graph Fundamentals learning path – Module 3

Wed, 07 Apr 2021 13:59:31 +0000

Doing Microsoft Graph Fundamentals learning path on MS Learn - Part 3

This is already the third part of my little series on what it takes to do the Microsoft Graph Fundamentals Learning Path on Microsoft Learn. If you missed part 1 or part 2, it would be a good idea to catch up first, as the parts build upon each other.

After we already saw how easily we could configure a JavaScript application to retrieve Microsoft 365 data using Microsoft Graph in the last module, we will focus this time on how to access user photo information by using Microsoft Graph.

This module is supposed only to take 17 minutes to complete - timer set 😇.

intro

Our goal is to insert a user profile in our app that we already used in the last module. We will need to authenticate our user using Microsoft identity and receive an access token and call Microsoft Graph API with this token. - If you now wonder, ‘wait, but why?’ it’s a good idea to reread part 2 of my summary or do the last module.

After making us aware of WHY we should display a user picture, we learn that there are several ways to get profile picture information with Microsoft Graph, for example GET https://graph.microsoft.com/v1.0/me/photo/$value gets us the image of the signed-in user itself. I used the Graph Explorer to check that:

https://raw.githubusercontent.com/LuiseFreese/blog/main/media/GraphFun/GraphFun-image.png

Let’s do an exercise:

Exercise - Use Microsoft Graph in your web application to retrieve a user’s profile photo

build upon module 2

As we are building upon the last module, we will not need to clone the repository again. The unit quickly walks us through the four primary files for our app index.html, auth.js, graph.js and ui.js to make us aware of what they will do and repeats the steps we did in module 2 to insert tenant ID and application ID.

Now the new part

copy - paste two code snippets into the index.html file to create and style a button with an image element
add a function to the graph.js file to call Microsoft Graph API and retrieve the photo of the signed-in user
add a function to the ui.js file that displays the image that we got from Graph into the image element that we created and styled in step 1
copy-paste a snippet to show a button that a signed-in user can click on to view their profile picture.

time to run our app

Like in Module 2, open your terminal (I use the built-in Powershell in Visual Studio Code) and type in npm start, which will open your browser with localhost:8080.

Click on Sign in with Microsoft
Click the show profile picture button
see that profile pic? YAY - time for a happy dance- You made it!

conclusion

As I did module 2 just a couple of days before, I did not need to reinvent the wheel, and it took me way less than 17 minutes to complete this module 3 - but I realized that I could reuse this app over and over again to whenever I need to sign-in a user or want to display information that I can get from Microsoft Graph API.

I wrote this summary of the whole learning path because I worked with Microsoft Graph before, and although I don’t write (a lot) of code daily, these modules felt doable - even if you are not a super experienced developer. I hope there will be even more cool content!

If you now read this and wonder if you could build applications with Microsoft Graph as well: Yes, you can! To learn more - from developers, please join Microsoft’s Learn Together event: Building apps with Microsoft Graph on April 14!

I would love to hear your feedback! Did you start this learning path? Or completed it? What were your aha moments? Where did you struggle? What content is now needed to take you to the next level? Please comment below!

🦒

Microsoft Graph Fundamentals learning path – Module 2

Fri, 02 Apr 2021 19:56:13 +0000

Doing Microsoft Graph Fundamentals learning path on MS Learn - Part 2

Welcome back to my series about the Microsoft Graph Fundamentals learning path on Microsoft Learn. This is part 2; if you did not read part 1 yet, this is your chance to catch up! I will stay here and wait for you with a coffee ☕.

This module is called Configure a JavaScript application to retrieve Microsoft 365 data using Microsoft Graph and we start with an

intro

We are still sticking to the business scenario from module 1: We want to create an app that can access email, chats, files, meetings. To authenticate users, Microsoft 365 uses Microsoft Identity, and we will need to use Microsoft Identity and Microsoft Graph to get the data we want to display in our app by using Microsoft Authentication Library(MSAL).

Wait, what? Don’t worry if you did not completely understand this. We will do this step-by-step.

Understand the role of Azure Active Directory with Microsoft Graph

OK, we already understood that Microsoft Graph is THE API to access data in Microsoft 365 - but of course, this data needs to be secured because we don’t want everyone to access them, right? This is what we need Microsoft Identity platform for. Microsoft identity ensures that only authorized users (delegated permissions) and apps (application permissions) access data stored in Microsoft 365. The challenge now is to link Microsoft Identity (of which we will use Azure Active Directory) to our Microsoft Graph powered app. The module explains in detail how you register your app in Azure AD and retrieve your application ID. Later on, you will add this ID into the MSAL (Microsoft Authentication Library)’s code of your app to link to your Azure Active directory.

But before we do this in an exercise, we will learn some theoretical stuff that we need later on.

Crucial to understand that a user or admin needs to consent before the app requests permission to access Microsoft 365 data via Graph, which is why we need to know a little bit more about:

Scopes

All resources have specific scopes, like User.Read (lets you read the profile of the signed-in user) or User.Read.All lets you read the profiles of all users present in this directory. Of course, you will want only to allow scopes that are necessary for the application. You can look up scopes for each request in the official documentation and also learn about them while trying out requests in Graph Explorer.

Permission types

We can perform requests on behalf of a user (delegated permission), and we can run background processes like creating, reading, updating, or deleting events of all calendars without the requirement of a signed-in user. This means that an admin will need to pre-consent to these permissions.

Access tokens

The unit also describes how the magic with an access token works - and uses a great comparison for that! An access token is like a movie ticket - but your application gives it to Graph to show it has permission to access the requested data in Microsoft 365. LOVE this explanation so much!

We use this movie ticket/access token in the Authorization header of our HTTP request.

Register an application with Azure Active Directory

In this unit, you learn which account type you can select when registering an app in AD and that web and single-page apps will require a redirect URI so that identity platform redirects and sends security tokens after authentication.

In case you wondered: There is a big difference between authentication and authorization.

Exercise - Register an application with Azure Active Directory

This exercise walks us step by step through registering an app in Azure AD- I highly recommend following this unit if you never registered an application before:

Let’s now

Retrieve an access token using MSAL

MSAL will make Token interaction more effortless for you because we can acquire tokens from the identity platform to authenticate users and access Microsoft Graph.

Now that we understood the authentication flow, it’s time to get our hands dirty with

Exercise - Retrieve an access token using MSAL

To get this straight - you will clone a repository either using git or downloading a zip file. After opening this in Visual Studio Code (or any other editor), you will need to replace two placeholders with tenant ID and app ID from your Azure app registration.

The unit walks you through some crucial parts of your app and lets you map this code to the authentication flow.

Congratz! - you made it!

Conclusion

I loved this module - even if I already knew how to register applications and what Microsoft Graph does - it clarified the authentication flow once again and walked me nicely through some crucial parts of the code that I cloned from the MSLearn repository. Some basic understanding of JavaScript was beneficial to let the app run and know WHY and HOW it runs.

Microsoft Graph Fundamentals learning path - Module 1

Thu, 01 Apr 2021 21:08:13 +0000

Doing Microsoft Graph Fundamentals learning path on MS Learn - Part 1

This blog post will summarize how I did the brand new Microsoft Graph Fundamentals Learning path. Microsoft Graph Fundamentals consists of 3 modules:

What is Microsoft Graph - lets you understand the Graph services and shows you how you can access user information from Graph using their learning playground called Graph Explorer. You will do a short exercise on that as well.
Configure a JavaScript application to retrieve Microsoft 365 data using Microsoft Graph - lets you understand how app registration works in Azure AD with permissions for Microsoft Graph powered apps and closes with two exercises using MSAL - making authentication easy.
Access user photo information with Microsoft Graph - in this module, you continue with the application you built-in module 2 and learn how to retrieve a user photo and do an exercise about it.

The whole learning path is estimated to take us ~75 minutes. Let’s see how it goes :-)

To be very honest: I worked with Graph before - see my blog posts here: Microsoft Graph – M365 Princess - but it’s the first time I do this guided learning on Microsoft Learn. I will cover module 1 in this post and continue with module 2 and 3 in the following posts.

What is Microsoft Graph

In super short: Microsoft Graph is a set of APIs that lets you access data in Microsoft 365 and use it for custom coded and low code applications. With this, Microsoft Graph is your key to data. Here are three tremendous advantages of it:

across all Microsoft services, you can use one endpoint https://graph.microsoft.com - which makes development straightforward as you don’t need to learn all the different APIs for mail and calendar and files and so on
documentation is fantastic, and there is a ton of learning material - like this learning path or the upcoming Learn Together- Building apps with Microsoft Graph event
you can try out Graph in Graph Explorer - if you like to read more about that, read my blog post on how to get started with Graph Explorer
Microsoft Graph Toolkit (you will learn more about it later) makes authentication (my personal kryptonite) easy. It also provides you with ready-to-use components and reduces the time you need to develop.

Intro

For this module, you will need to be a global admin in a Microsoft 365 tenant. The easiest way to have this is to join the Microsoft 365 developer program and get a free E5 subscription. If you are not familiar with this, read Julie Turner’s article about it, at least some basic JavaScript understanding, and you should know what Azure Active Directory does. You will also need to have Node.js installed.

The learning module introduces you to a business scenario so that it is easier for you to imagine which kind of applications we are talking about. In this scenario, we want to bring together messages from chat, emails, attended meetings, notes, key contacts, and relevant files.

Our application could also grow later on and bring in data from more services like Windows 10 services or Enterprise Mobility and Security Services. We will not build this in total in this learning path, but we get a perspective, what we can develop based on our organization’s needs.

Understand Microsoft Graph Services

At the very heart of Graph, we will find users and groups. In our application, we will need to access data from a single user’s personal scope (mail, messages, events) and a group scope (teamwork).

The module introduces you to some Microsoft Graph API calls and shows you how the response will look. All API responses will be in JSON format - in case you want to learn more about it, read this article by Bob German on Introduction to JSON

The even more exciting part is that apart from making direct API calls, Microsoft provides us with the Graph SDK (Software Developer Kit). We can use the client Graph SDK client libraries to even more easily call the Graph API.

Access user information from Microsoft Graph using Graph Explorer

This chapter introduces you to Graph Explorer -easily access it at aka.ms/ge, try out some sample queries! My blog post on how to get started with Graph Explorer explains that in detail.

Exercise - Access user information from Microsoft Graph using Graph Explorer

Time to access your own data! I strongly recommend not playing in your production tenant- especially if you do not only want to read data with GET requests but also want to write, update, or delete data with POST, PATCH, UPDATE, or DELETE requests. Get yourself a Microsoft 365 developer tenant and use this.

This chapter teaches you how to modify permissions in Graph explorer and how tips help you.

You will learn how to send a message to Teams via Graph - this is not a test; it will really appear in Teams. 🚀

Let us 1’up this already fantastic experience. Besides using this beautiful UI, Graph Explorer provides you with:

Access tokens used for authentication (recognizing who a user is) and authorization (looking up the correct privileges)
Code snippets for three different languages so that you can copy-paste them into your applications
Microsoft Graph Toolkit components - most fabulous thing ever! If you are not familiar with MGT, go check it out
Adaptive cards snippets so you can quickly build UI components for your apps

You see, this is the ‘absolutely carefree package’ provided by the Microsoft Graph team.

Conclusion on Module 1:

Microsoft Graph is not only THE door opener to access all kinds of information and data across Microsoft 365 for developers and makers. They also provide us with this fantastic learning playground, aka Graph Explorer, in which we can try out, learn, explore and get snippets for all kinds of development scenarios.

After introducing you to some basic concepts on Microsoft Graph, you have learned on a real-world example how to use Microsoft Graph before continuing to access data via Graph in a JavaScript application. This learning module is fantastic! If you never heard about Graph, you’ll get everything you need to start right away with it!

How to get started with Graph Explorer

Fri, 26 Mar 2021 14:59:48 +0000

How to get started with Graph Explorer

Don’t know what the Microsoft Graph Explorer is? Or have you already heard about it, but were not sure, how to get started and how this would help you? This post will show you what Graph Explorer is, the benefits, and how to use it.

What is Microsoft Graph Explorer

Microsoft Graph offers us a single endpoint https://graph.microsoft.com to access data in Microsoft 365, Windows 10, and Enterprise Mobility and Security and can be used by makers and developers. To get started to use the Graph API, the Graph Team offers us a very fantastic tool called Graph Explorer.

What does it do? Well, it lets us explore Graph! It’s a learning playground where we can try out requests, get responses, learn about permission scopes, and more. To access Graph Explorer, visit aka.ms/ge and make yourself familiar with it:

Authentication

You can decide if you want to sign in or if you want to try out with sample data provided by Microsoft. I recommend ‘playing’ in your developer tenant; if you don’t have one, learn here how to join the Microsoft 365 developer program and get a developer tenant. The benefit of signing in with your (developer) account is, that you can execute all requests including POST and DELETE requests, which is not possible in the sample account.

When you click the gear icon, you will find a shortcut to the Microsoft 365 developer program website (to get your sandbox with sample data), and you can change the theme as it suits your needs best. I like dark mode most 🖤.

Sample queries

You will find sample queries below authentication - some may be disabled if you are not logged in. If you click on a sample, like I did in the screenshot below, Graph Explorer will send this HTTP request to Microsoft Graph - and get my joined teams. We can see this in the request area (upper part) and the response area (lower part):

We now want to create a channel called ‘Microsoft Graph’ in the Team ‘Insidious Word Domination Plans’. We first copy the ID of the Team from the response of that request and then use this ID in the next sample we try out, which is:

We then replace the {teams-id} placeholder with the copied ID value from the previous request and change the body to our needs:

In the Modify permissions tab, we can learn about - and consent to permissions needed to execute this request:

But the awesomeness of this tool doesn’t stop here - we get ready-to-use code snippets in different languages to insert them into our applications:

And for some GET requests, we even get Adaptive Cards:

We can also try out Microsoft Graph Toolkit components right here, although I would personally recommend doing this in the dedicated Microsoft Graph Toolkit Playground. If you are unfamiliar with Microsoft Graph Toolkit, you can read how I started to use it - in my blog series about MGT - I also recommend having a look at the beautiful Microsoft Graph component browser.

Last but not least: Documentation to every sample is nicely tied in - click on the pop-out icon next to the sample queries:

How does Graph Explorer help building apps?

I use Microsoft Graph in Power Apps with custom connectors or in Power Automate and Azure Logic Apps with the HTTP action to execute actions that are not present (yet). If you never did that but want to learn about it, here are two blog posts that will get you started:

To get from the rough idea to a working up, I follow this process:

Read the docs. I mean, seriously. learn, which endpoint you will need to call, which permissions you will need.
Try out in Graph Explorer; when it works, proceed to step 3, in case it doesn’t, go back to step 1 :’)
Register your application in Azure AD with the permission scope that was needed for the request in Graph Explorer
Try out the flow/the action of your custom connector in a basic sample flow/app.
Now replace all hard-coded values like a Teams ID with Dynamic Content from within your flow

You see, Graph Explorer is an amazing tool to learn and try out - it gets you a step closer to a working solution, but you do not need to worry upfront about app registration, permissions etc. It’s a cool way to do a proof of concept - trying out if you can get, post, patch, update or delete the resources you like to before you start building your app.

Feedback and what’s next?

I am curious - which other tools help you developing with Microsoft Graph? Recently, Elio Struyf published a VSCode extension, that auto-completes Graph URLs for you, read more about it here. Also, please share below what you build with Microsoft Graph? And how you use Graph Explorer? If you like to contribute to Graph Explorer, you can check it out on GitHub. I am looking forward to your feedback!

❤ Sharing is Caring

X things you should do before making an app

Thu, 11 Mar 2021 21:38:37 +0000

10 things we should think about before we build an app

With Power Apps, we can rapidly build custom business applications that connect to our business data in a low code manner. This means that not only professional developers can develop applications but that a lot more people will be able to make apps that fit their specific use cases.

But as development is not only writing code, there are certainly some things we should do before we hit make.powerapps.com. Many developers will agree that development is 20% about writing code and 80% about communications (meetings, gathering requirements, adjusting things).

If we now introduce ’low code development’, we work on these 20%, not on those 80%.

The issue with that is that the narrative of ’everyone should make apps’ doesn’t reflect that there is much content out there to teach business users how to use controls, components, connectors, and ask the community when in doubt which function they should use. But there is about near to zero guidance around making better decisions about how we should approach building apps. Regardless of by whom it is developed, every app needs to be documented, maintained, and supported. Pro-developers are very aware of this, as DevOps is what they live and breathe every single day. But apart from IT departments, who will need to care about governance, application lifecycle management, etc., there are some things on the business user side that we should consider.

This post will list ten things that we should think about before we start building our apps

1- which problem does the app solve?

This sounds obvious that one would first do a proper analysis of value proposition and if the app they have in mind is a must-have solution to a specific business case or if it’s more or less ‘yet another thing to use’, although there are working alternatives in place.

understand your market

Let us take some time to segment our market and understand who (even if we build for our colleagues) needs our app. There will be roles that will rely on our app, and it will become mission-critical to them. Others will have already found applications that do similar things, or the app doesn’t solve a relevant problem. We can specifically look at underserved groups, such as blue-collar workers, and see if we can address their needs. Becoming obsessed with solving specific needs without assumptions is critical here. This means that we will need to validate the market that we have in mind. Even if we consider ourselves a business user/power user /citizen developer, doesn’t necessarily mean that we are our user and precisely know what they need.

psychological strain vs. energy of change

To make users love an app, we will need to solve their pains or adress their needs and make it not too hard for them to change their behavior. If the energy they will need to change their behavior is higher than the psychological strain they face right now, they will not adopt your app. It’s unfortunately as simple as that.

2- calculate value

Now you have a fair idea of who will use your app for which use cases and also know what users are doing now:

abuse other tools
work on paper
purchase 3rd party tools
use unapproved shadow IT tools

and to which results this leads

be busy with tasks that don’t add value
lose information
cause additional costs
severe risks in terms of data security, governance, compliance etc.

tl;dr: it costs time & money

But we need to make an effort to calculate the higher costs in terms of money and time and make an estimation for the next 12 or 24 months in order. This will also help with any approval process/ get funding.

If the app we have in mind doesn’t create (enough) value, we can take this as a learning opportunity better to meet the needs of our (internal) customers.

The goal is to provide more value, not to deliver a poorly designed app that costs a little less. Of course, we can build apps ‘for fun’ or because we want to learn, or ‘just because we can’, but we should carefully distinguish those apps from apps that we want to pitch and ‘sell internally’.

3- scope

The mother of all questions: Does it scale? Will our app be something for our personal productivity? Ease a workload for a small team? Or do we talk about a mission-critical process? And even if we start with a small group of users to try out, is there a way where a broader audience could want to use it? We need to carefully identify our app’s scope, as this will impact many decisions.

4- data model

Let’s talk about our data model. Which data source will you need to get data, in which services will you write data? Which dependencies do you have, which other apps, flows, bots will be part of the solution? Of course, the consultant answer on when to use what will always be an ‘it depends’, but there are probably more reasons to look into different data sources as you are aware of:

licensing

As this is a pretty emotionally driven subject, we should handle this some more cool-headed. The idea of first understanding which needs your app solves, who would benefit from it, and how much money and time all users would save together by using it is the licensing discussion’s counterpart. Of course, organizations tend not to want to pay for additional licenses, but the idea that one could deliver excellent business value without any costs is somehow romanticized. Incorporate licensing fees for premium connectors (as you need them) in your calculation, and if the app still delivers more value than it costs, we will probably get approval/green lights for it.

If the app isn’t worth more than ~10$ per month and user, we should probably not be building it.

performance

The data sources we choose have not only impacted the licensing model but also our apps’ performance. For instance, if data needs to travel through an on-premises data gateway to a SQL server, most probably, our app will not be as fast as if the data sits in Dataverse. For an elaborated comparison on this and other data sources such as Excel, SharePoint, and more, please read this article about Considerations for optimized performance in Power Apps

developer and user experience

We can also impact the experience you as a developer will have while building the app, depending on the data source. If you ever ’loved’ to deal with, for example, lookup columns from a SharePoint list, you will agree that you didn’t choose the easiest way to build an app. If you need to find workarounds as a developer, this will impact your user, which means that their experience won’t be as good as possible.

5- delivery

Let’s say we are about to hit make.powerapps.com, and we have a fair idea of what to do there to make an app. We will publish our app, share it, and mentally move on to something different. Now, who cares for that app? Who will maintain our app? Things can easily change when we create apps on top of cloud services. This can quickly become a not to be underestimated workload, and probably we as a business user won’t have the capacity to cover that. And even if we are not talking about adjusting to things that changed: Who will support our app? Who will answer questions? Who will implement new features?

Delivery of software should contain code (and yes, this applies to Power Apps) and proper documentation. Sharing knowledge about our app (what we use, inputs, outputs, dependencies, licensing, data model, accessibility, features, etc.) very early by writing it down to enable those who need to maintain and support our solution is essential. Making it a habit to have a changelog, where we document which features we add, remove or change, is crucial. If we think that this is too time-consuming, we should be aware that someone will need to spend more time on fixing the lack of documentation for us.

A lack of documentation will create technical debt

6- what is your minimal l❤vable product?

Yes, I mean it! Define your minimal lovable product. If you only heard about a minimal viable product so far, please read this article How to Build a Minimum Loveable Produc. In essence? Which features will we need to make users fall in love with our app? We will build this. We will not fall into the rabbit hole of delivering the whole software in one piece but focus on the crucial parts. Once we published our first version, we gather feedback on how we can improve it. Becoming comfortable with a mindset that software is never finished can be a good idea.

7- mock-up your app

Finally- let’s talk frontend - how shall our app look like? It’s super tempting to start building screens and buttons and decide on colors etc., but we will get a better impression on the big picture of our app if we first do a mock-up. We may choose to use a professional app for that or if we will draw something (I personally do this in OneNote). Defining which screens and buttons and forms and galleries you will need will make the next steps easier.

8- componentize your app

Reinventing the wheel is always painful, and to avoid this, we can think about components in our apps so that we reuse what we (or even others in this environment in the component library) build before. While controls are an excellent way to start learning and understanding how everything works, components are the way to accelerate our process of making apps and make sure that we easily adjust them and don’t need to start over again for the next app we are making. It is also the low-code equivalent to the principle of ‘Don’t repeat yourself’. Thinking upfront about which controls we would repeatedly use and planning to componentize these will ensure that we don’t need to start all over again.

You can watch April Dunnam’s video about componetizing Power Apps to get up to speed.

9- accessiblity

Accessibility is nothing that comes on top of a ready-to-publish app but should be one of your core concepts straight from the beginning. The accessibility checker in Power Apps is a good start, but it’s always worth exploring even more ideas. We can find lots of guidance on ensuring that more people can benefit from our apps, Microsoft Inclusive Design is an excellent go-to resource.

10- build in Microsoft Teams

As we are more and more working in Microsoft Teams, we should not only build applications for teams, but for (Microsoft) Teams! Considering the context of apps gives you even more ways to satisfy user needs. Coming back to the scope of our app, we need to carefully think if this app is just for our team, or if we want to make it available for the whole organization. Staying in Teams also has an impact on licensing, as you can for instance use Dataverse for Teams, which is then seeded in you Microsoft 365 license.

Conclusion

As we could see, there are quite some things to do and think about before we hit make.powerapps.com and I put these together as an approach for good practices. What do you do before you actually start developing? What would you like to add to my list? Please comment below!

5 commands to try in CLI for Microsoft 365 to fall in love with it

Thu, 11 Mar 2021 19:48:08 +0000

5 commands to try in CLI for Microsoft 365 to fall in love with it

After I blogged about How to send Adaptive Cards with CLI for Microsoft 365 and also used CLI to compare different ways to create SharePoint lists, I found some more commands that made me fall in love with it. CLI for Microsoft 365 has three main benefits from my point of view:

💻 it’s platform-agnostic and even works on Azure Cloud Shell so that every browser can be my admin machine
💡 the syntax is easy and almost intuitive to use for me, although I only start to not use the UI for everything I want to manage in my Microsoft 365 tenant
🚀 documentation is clear and concise with excellent code samples.

Bonus: 💖 Caring maintainers and awesome contributors

In case you never used CLI for Microsoft 365 before, please first read how to get started with CLI Microsoft 365 where I explain how to install the CLI.

My screenshots will show that I work in PowerShell in Visual Studio Code, but you can use any other shell you like to use.

Get a list of Power Apps

Wouldn’t it be nice to get a list of apps? This is what I thought as well. We will look into the CLI for Microsoft 365 documentation find the command to list all Power Apps in this tenant, which gives us an idea, what makers are doing to be able to offer help and support as well.

After having installed CLI and logged in:

Run m365 pa app list

which will get you exactly that list - with internal names and display names:

Get an overview of custom connectors in an environment

If we allowed makers to build their custom connectors to fulfill their unique needs, we might want to look at that as well. If you never create a custom connector, you can read my blog post about how to build a custom connector.

Run m365 pa environment get --name Default-<name of your default environment>

Now, where do we get this <name of your default environment> from? This is your tenant ID, which you can obtain from the URL of any Power App running in this environment, or you can copy it from portal.azure.com, where you will find it in Azure Active Directory as Tenant ID.

Copy this Tenant ID
Replace <name of your default environment> with this Tenant ID
Run the command

Get a list of users

Obtaining a list of users on a specific SharePoint website will be helpful to get their IDs.

Run m365 spo user list --webUrl "https://m365princess.sharepoint.com/sites/m365princess"by replacing my webUrl with the tenant you are logged in and a site URL you want to query.

The response will be something like this:

Get a list of external users

Another cool starting point is to get a list of external users. As internal users tend to invite many guests, it could help have an overview of external users and see when these external users were created. You can also obtain the ID of users.

m365 spo externaluser list,

remove users

With

m365 spo user remove --webUrl "https://contoso.sharepoint.com/sites/HR" --id 10 --confirm

we can remove users.

Feedback & What’s next?

I hope that you now got an idea of how you can get started with CLI for Microsoft 365 :-) Shall I blog more about it and show even more commands? Still, I am curious, what would you use it for? Which are the commands that you use every single day? Please comment below!

How to create a (faux) table in Adaptive Cards with Power Automate

Sat, 06 Mar 2021 12:30:41 +0000

How to create a table in Adaptive Cards with Power Automate

In this blog post we learn how we can display a table in an Adaptive Card, pull data from a SharePoint list and use Power Automate to do that in one flow.

When I read in the documentation, that tables and headers are not supported, it was somehow a BUMMER 🙄, but then I asked the worlds laziest developer Hugo Bernier, if there was really now way to do it.

Our first idea was, to templatize an Adaptive Card, and then pass data into that template; but very unfortunately, this isn’t supported in Power Automate. Our second idea resolved the whole problem: We would build the JSON for our Adaptive Card like different LEGO bricks and then put them together.

We would need

1 brick (we will use variables in Power Automate) for the upper part of the Card, where we create a columnset,
3 bricks for the headers of our faux table
3 bricks for the rows over which we will loop
1 brick that contains our ‘Open Link’ button
1 brick at the end of the card to close all open { and [ with } and ]

To make things a bit more approachable, here is our little

use case

We want to display items of a SharePoint list in an Adaptive Card as a table. The result should look like this:

Purpose is to notify the Team each Monday about all Unicorns with a unicornibility index of less than 85 so that the team can take care of them. We do not only want to display 1 single item of our list with a factsheet but display as many items as match our query (unicornibility lt 85). We don’t want to hard-code any value in here to keep things flexible.

Let’s start building our Power Automate flow

recurrence Trigger

We start with a Recurrence trigger, set the interval to 1 and the Frequency to Week.

get Items (SharePoint)

Next action is getting the items from our SharePoint list. Set Filter Query to unicornibility lt 85 to only get those items, that match our query – this will ensure a better performance than first pulling all list items and then working with conditions later. You can also limit how many items you want to retrieve.

Preparations to bind data and JSON schema of the Adaptive Card

We want to get a table into an Adaptive Card, which is not supported natively, so we need to do a little trick. We will use variables to build the different pieces of the Adaptive Card JSON, that we will later need. The Code in total would look like this:

{
"$schema": "http://adaptivecards.io/schemas/adaptive-card.json",
"type": "AdaptiveCard",
"version": "1.2",
"body": [
{
"type": "TextBlock",
"text": "Hey Team- watch out! 🦄 need some extra 💖",
"wrap": true,
"weight": "Bolder"
},
{
"type": "ColumnSet",
"columns": [
{
"type": "Column",
"items": [
{
"type": "TextBlock",
"weight": "Bolder",
"text": "Name"
},
{
"type": "TextBlock",
"separator": true,
"text": "UNICORN1"
},
{
"type": "TextBlock",
"separator": true,
"text": "UNICORN2"
}
],
"width": "stretch"
},
{
"type": "Column",
"items": [
{
"type": "TextBlock",
"weight": "Bolder",
"text": "Unicornibility"
},
{
"type": "TextBlock",
"separator": true,
"text": "VALUE1"
},
{
"type": "TextBlock",
"separator": true,
"text": "VALUE2"
}
],
"width": "auto"
},
{
"type": "Column",
"items": [
{
"type": "TextBlock",
"weight": "Bolder",
"text": "Party Readiness"
},
{
"type": "TextBlock",
"separator": true,
"text": "PValue1"
},
{
"type": "TextBlock",
"separator": true,
"text": "PValue2"
}
],
"width": "stretch"
}
]
},
{
"type": "ActionSet",
"actions": [
{
"type": "Action.OpenUrl",
"title": "open here and care 💖"
}
]
}
]
}

Let’s break this into pieces:

First variable will be the upper part of the Adaptive Card in which we define the schema, a title and create a column set.
We initialize variables for the 3 Headers “Name”, “Unicornibility” and “Party Readiness Index”

We create an Apply to Each and loop over the values of our SharePoint list for each column by appending our variables.

We append the upper part of our card by the 3 columns (consisting of the headers and rows) and the actionset plus end of the card

In case you wonder why we needed to somehow unclean cut the JSON – this is a bug in Power Automate. Although we defined our variables as string, Power Automate asked us to provide valid JSON. We could not provide valid JSON though, because we needed to cut the JSON into pieces. We needed therefore to find a way to make Power Automate believe, that we are not storing JSON in a string variable, and apparently a { at the beginning was a trigger for Power Automate to check if JSON was valid (which was not, but on purpose!).

Our Code would look color coded like this:

And if we now lay the color-code blocks over the Adaptive Card:

Send Adaptive Card

You may choose if you want to send the Post as the Flow bot or as a user or if you want to send this into a 1:1 chat or into a Channel. The Adaptive Card is our card variable.

Conclusion and what’s next

Although not natively supported, we can actually display a (faux) table in Adaptive Cards and bind this to a datasource. Potentially issues could occure here, as our columns are independent from each other. The Adaptive Cards renders columns, bnit not rows, which means that if we have different heights, it could be problematic to make them look good and even. What’s next? Find the limit how many rows we can display and what else we could do with Cards :’) What would you like to figure out? I am curious, please reply below!

Should we use SharePoint REST or Microsoft Graph API in Power Automate?

Thu, 04 Mar 2021 08:30:58 +0000

Should we use SharePoint REST or Microsoft Graph API in Power Automate?

When working with Microsoft 365, we see many overlapping tools and features, and we will need (to provide) much guidance around ‘when to use what’ for users. While most comparisons address users, I want to cover some more IT-related scenarios in this blog post. Specifically, I want to compare two different RESTful APIs, which we can use in Power Automate and Azure Logic Apps to send HTTP requests. If you are not familiar with that, don’t fret; continue to read my blog post about how to get started with http requests in Power Automate, I will grab a coffee ☕ in the meanwhile.

Back again? Cool. Let me introduce you to our

use case

We want to create a new SharePoint list and add some columns based on the user’s input using Power Automate or Azure Logic Apps. When we look at the different available SharePoint actions in Power Automate, we will see that there is no ‘create a list’ and no ‘add column to SharePoint list’ action, but that we could try out something with ‘send an HTTP request to SharePoint’

Option No. 1: SharePoint REST

The ‘send an HTTP request to SharePoint’ action uses SharePoint REST API. To create a list, we can look up working with lists and lists items and see that we need to send a POST request to the https://{site_url}/_api/web/lists endpoint and specify in the body of our list how it should look like. We can define the title and description of the list and also set the Basetemplate (in case you want to do the same with a library etc.):

POST https://{site_url}/_api/web/lists
Authorization: "Bearer " + accessToken
Accept: "application/json;odata=verbose"
Content-Type: "application/json"
Content-Length: {length of request body as integer}
X-RequestDigest: "{form_digest_value}"
{
"__metadata": {
"type": "SP.List"
},
"AllowContentTypes": true,
"BaseTemplate": 100,
"ContentTypesEnabled": true,
"Description": "My list description",
"Title": "Test"
}

Now how do we do this in Power Automate without writing much code?

mobile flow button

To make things easier, I will use the mobile flow trigger with three text inputs:

You can also trigger the flow from a list, a form, an app, a bot, or whatever suits your use case.

Send an HTTP request to SharePoint - create a list

Now we need to add the ‘send an HTTP request to SharePoint’ action:

Select the site of your choice from the dropdown menu
Select method Post
enter _api/web/lists/ as URI
enter Headers as follows:
- Content-type : application/json;odata=verbose
- accept:application/json;odata=verbose
enter

 "__metadata": {
"type": "SP.List"
},
"AllowContentTypes": true,
"BaseTemplate": 100,
"ContentTypesEnabled": true,
"Description": "@{triggerBody()['text_1']}",
"Title": "@{triggerBody()['text']}"
}

as body- make sure you replace the placeholder with Dynamic Content:

Parse JSON

Now we want to add a column. Let’s have a look into the documentation, how we can do this.

POST https://{site_url}/_api/web/lists(guid'{list_guid}')/Fields
Authorization: "Bearer " + accessToken
Accept: "application/json;odata=verbose"
Content-Type: "application/json"
Content-Length: {length of request body as integer}
X-RequestDigest: "{form_digest_value}"
{
"__metadata": {
"type": "SP.Field"
},
"Title": "field title",
"FieldTypeKind": FieldType value,
"Required": "true/false",
"EnforceUniqueValues": "true/false",
"StaticName": "field name"
}

We need another ‘send an HTTP request to SharePoint’ action, and we need the list Guid. To get the list Guid, we need to add a Parse JSON action. If you are not familiar with that - I blogged about it: How to use Parse JSON action in Power Automate

Parse JSON

Let your flow run - just the mobile trigger and the ‘send an HTTP request to SharePoint’ action
Go to your flow run history
Copy the outputs from the ‘send an HTTP request to SharePoint’ action
add a ‘Parse JSON’ action to your flow
select body from the ‘send an HTTP request to SharePoint’action as Content
click Generate from sample
paste the copied JSON code in here
click Done

When we now have a look into our Dynamic Content, we will see many more options, also the list Guid, which is named Id here.

Send an HTTP request to SharePoint 2 - add a column

Now we add another ‘send an HTTP request to SharePoint’ action, which will create us a column:

Select the site of your choice from the dropdown menu
Select method Post
enter _api/web/lists(guid'@{body('Parse_JSON')?['d']?['Id']}')/Fieldsas URI (replace the placeholder with Dynamic content)
enter Headers as follows:
- Content-type : application/json;odata=verbose
- accept:application/json;odata=verbose enter in the Body:

{
"__metadata": {
"type": "SP.Field"
},
"Title": "@{triggerBody()['text_2']}",
"FieldTypeKind": 2,
"Required": "false",
"EnforceUniqueValues": "false",
"StaticName": "@{triggerBody()['text_2']}"
}

Please replace again all placeholder by Dynamic content

Should you stumble upon the FieldTypeKind, please find reference here - 2 means ‘single line of text’.

If you want to run your flow, please think about changing the list name because you already created a list!

If we now control our newly created SharePoint list, we will see that our new column doesn’t show up in the default view but that we need to enable the column- bummer!

Send an HTTP request to SharePoint 3 - add column to view

To have the column in the default view (or another view), we need to add another ‘send an HTTP request to SharePoint’ action:

Select the site of your choice from the dropdown menu
Select method Post
enter _api/web/Lists/getByTitle('@{triggerBody()['text']}')/views/getByTitle('All Items')/ViewFields/addViewField('@{triggerBody()['text_2']}')as URI
(replace the placeholder with Dynamic content)
enter Headers as follows:
- Content-type : application/json;odata=verbose
- accept:application/json;odata=verbose
Body is empty

Advantages of this solution

no need to register an application in Azure AD
send an HTTP request to SharePoint is not a premium connector, which means that you won’t need a Power Automate Standalone license

Disadvantages of this solution:

with an ‘http request to SharePoint’ action you have - compared to the power of Microsoft Graph API - limited options, as you can only send requests to SharePoint, but not to other services in Microsoft 365-
to add the new column to our default view, we need 3 HTTP requests - which makes the flow unnecessarily more complex

Option No. 2: Microsoft Graph API

Let’s see how we can create a SharePoint list or library and columns in it using Microsoft Graph. Microsoft Graph is a super powerful set of APIs that gives you a consistent experience for authentication, documentation, and samples. You can try it out on Microsoft Graph Explorer. For full documentation please continue here. If you are not familiar with using Microsoft Graph in Power Automate, please continue to read here… time for another coffee for me then :-)

mobile flow trigger

Again, to make things easy, we will use the same trigger as in Option No. 1.:

HTTP action

Now that we registered our app in Azure AD, we can continue with the HTTP action in Power Automate.

To create a list, we will look up documentation here and see that we will need to send a POST request to

https://graph.microsoft.com/v1.0/sites/{site-id}/lists

And that we will need to add permissions to be able to call this API. Our HTTP request requires authentication, which can be done via Azure Active Directory OAuth, but we will first need to represent our app (yes, this flow that calls Microsoft Graph is an application) in Azure AD.

We will follow these steps to register an app in Azure AD:

Go to portal.azure.com and log in
Click app registrations
Click New App registration
Give your app a nice name
Save tenant ID and Client(app) ID somewhere (notepad or similar)
Click API PERMISSIONS and select Microsoft Graph

Now look up the permissions needed for this action: Create a new list:

Permission type	Permissions (from least to most privileged)
Application	Sites.ReadWrite.All

Select all these permissions
Grant Admin consent
Click Certificates & secrets
Click New client secret
Type in a description
Click Add
Copy the value and save it in your notepad (you will need that later)

Initialize variables for Tenant ID, App ID and App Secret

Create three different string variables with the copied values of Tenant ID, App ID, and App Secret

HTTP action to create a list

Add an HTTP (not ‘send an HTTP request to SharePoint action) action to your flow and fill it out as follows:

Method: Post
URI: https://graph.microsoft.com/v1.0/sites/{site-id}/lists - You can obtain the site-id from a request in Graph Explorer: https://graph.microsoft.com/v1.0/sites?search=keyword
add Content-Type: application/json to the Headers
enter as body:

{
"displayName": "@{triggerBody()['text']}",
"columns": [
{
"name": "@{triggerBody()['text_2']}",
"text": {}
}
],
"list": {
"template": "genericList"
}
}

Replace the placeholders by Dynamic Content If you stumble off the genericList, please read here for reference about other list templates like libraries.

If you need to add more columns, you can do that by

{
"displayName": "@{triggerBody()['text']}",
"columns": [
{
"name": "@{triggerBody()['text_2']}",
"text": {}
},
{
"name": "@{triggerBody()['text_3']}",
"text": {}
},
{
"name": "@{triggerBody()['text_4']}",
"text": {}
}
],
"list": {
"template": "genericList"
}
}

and so on. Let’s go ahead and

Click Advanced Options
Select Active Directory OAuth
Enter https://login.microsoftonline.com as Authority
Enter the Tenant ID variable as Tenant
Enter https://graph.microsoft.com as Audience
Enter the App ID variable as Client ID
Select Secret as Credential Type
Enter the App Secret variable as Secret

When we now run our flow, we will see that the columns that we created are already visible in the default view.

Advantages of this solution:

We only need one HTTP request to Create a list, columns and have the columns in the default view
If our flow gets more complex over time and we provision more things in not only SharePoint, we can do this with Microsoft Graph as well and extend our permission scope in Azure AD app registration

Disadvantages of this solution:

Because HTTP is a premium connector, we will need a Power Apps Standalone license
We also need to register an app in Azure AD

Bonus Chapter: What about CLI Microsoft 365?

If you read one of my previous blog posts about How to get started with CLI Microsoft 365 and Adaptive Cards, you could read between the lines that I found CLI Microsoft 365 pretty cool. Although I wanted to compare SharePoint REST and Microsoft Graph API using Power Automate in this Post, I felt it could be a cool idea to check how things would go in CLI Microsoft 365.

If you are not familiar with it, please read my blog post first or head over to the full documentation. After you installed CLI Microsoft 365, open a shell that makes you happy (I use PowerShell inside Visual Studio Code Terminal).

Run m365 login
Copy the Login Code, click on the link
Paste the Login Code
Select the user you want to log in with from the list
Return to your shell window

Create a list

Run m365 spo list add --title Awesome%20List --baseTemplate DocumentLibrary --webUrl https://xxx.sharepoint.com/sites/yyy by replacing xxxby your tenantname and yyy by your sitename

Add fields and more

You can now run even more commands to add fields, make them required, add them to default view, and so on, feel free to try it out!

Conclusion

As always, the answer to the question “When shall I use what” will be a typical consultant ‘It Depends.’ Depending on your experience and skillset, the scope of your app, and how you approach it, you will prefer one tool over another - the purpose of this blog was to share some options to achieve the same thing - with creating a SharePoint list as an example. Please tell me - which solution would you prefer? Which are your use cases? Please reply below; I am curious!

How to build a FAQ chatbot for Microsoft Teams with Power Virtual Agents

Thu, 25 Feb 2021 19:39:25 +0000

How to build an FAQ bot for Microsoft Teams with Power Virtual Agents in minutes

In this blog I want to show you, how you can build, test and publish an FAQ bot for Microsoft Teams within minutes. We will use the Power Virtual Agents for Teams, which means, that you will not need any additional license to your Microsoft 365 license, for reference see also Power Virtual Agents for Microsoft Teams plan.

What is Power Virtual Agents?

Power Virtual Agents belongs like Power Apps, Power Automate and Power Bi to the Power Platform (wow, that was a powerFULL sentence 😇). You can create chatbots, which can interact with users in apps and websites, trigger workflows and more, without the need of writing code. You can choose if you want to use it in the Power Virtual Agents standalone web app or as app within Microsoft Teams.

Let’s build a bot

I will guide you how to create an FAQ bot. To feed our bot we will need some FAQ so that our can bot can learn them. I will use FAQ regarding licensing 🤓, but you can choose any FAQ from a website or PDF or even Word file that you like.

Open Teams
Click on the Apps icon
Search for Power Virtual Agents

Click Add

Select the Team you want your bot to join

Give your bot a name ans select a language that your bot shall understand (should be the same language as your FAQ)

Click Chatbots - here you get an overview of ALL your chatbots

Add topics from any website

Click Topics

You see, that some basic topics are already created for you. You can take a look later.

Click Suggested

Now we want to work on feeding our bot with the FAQ from the website that we selected.

Copy the URL of the FAQ website
Paste the URL into the Link to online content field

Click Add
Click Start

This may take now a couple of minutes. Grab a coffee in the meanwhile: ☕. Soon you will see the message that your new suggested topics are now in:

Review & edit topics

You can now review and edit each topic:

Click Save Topic

After you are done with reviewing and editing your topics, you will need to turn on the topics

Switch the toggle to on

Train your bot by entering more trigger phrases. This way, it is more likely that the Chatbot understands users asking questions even if they don’t exactly match the trigger phrases.

Time to test the bot!

You can now review and edit your topics until you are happy with the results.

Publish your Bot to Microsoft Teams

Click the Publish icon

Click Add

Click Add to Teams

Use your bot

Conclusion & what’s next

It took us only a few minutes to create, test and publish a chatbot, that now works inside of Microsoft Teams. Want to do some more? We could extend the capabilities of our Power Virtual Agents bot: Let’s say our bot can’t answer a question and needs to transfer the chat to a human agent, who will answer that question. What if we trained the bot with that answer so that our bot gets smarter over time? I will cover that in one of my next blog posts. What do you use chatbots for? Did you already try to make a 5 minute bot? Please share below :)

How to use a custom connector in Power Automate

Tue, 23 Feb 2021 21:08:19 +0000

How to create a custom connector in Power Automate

Power Automate is a super cool tool, which gives us a lot of options. But sometimes, the built-in connectors, are not enough. In one of previous posts, I showed you how to send HTTP requests to Microsoft Graph API. This time, I will show you how to connect to APIs outside of Microsoft 365 in Power Automate and even use an IOT button to trigger your flow.

Use case

To make things more approachable, here is a little use case for you:

I want to click an IOT button and this shall trigger a flow which tweets about the music I currently listen to on Spotify.

The result will look like this:

What we need

To achieve this, we will need a couple of things:

an IOT button - I use a Flic Smart button for that- that triggers my flow
a flow that connects to our Spotify and to twitter

So lets have a look at

IOT button

I use a Flic IOT button to trigger my flow. This button works with bluetooth, which means that we will need a bluetooth enabled device to work with this button- either a smartphone or an IOT Hub.

Set up your IOT button

download the app from your app store
install the app
register a new account
connect your folic button by pressing it for ~10 seconds

If you like to, rename this button - please keep in mind, that one button can be used to trigger several flows, as we have three different event types: Click, Double-Click and Hold.

Spotify

In this flow we want to trigger by one or any event of the flic button and then tweet the song we are currently listening to on Spotify. Turns out, that there is no connector for Spotify, so why not building our own custom connector?

To be able to build custom actions, you will need an API for this service. Lucky us, that Spotify provides us with that API so that we can use this to build our custom connector.

Of course we need to have at least a free Spotify account so that we can listen to music that then shall be tweeted about.

Before we can build the connector, we will need to register for Spotify’s Developer program - Once this is done, we can retrieve Spotify content such as album data, playlists and more though Spotify Web API. To get user-related data (like the song our user is playing right now) we need to authorize our application so that we are allowed to retrieve this information.

Register our application on Spotify

Log into your brand new Spotify for Developers account
Go to your Dashbaord
Click Create an App
Give your app a name and accept T&C

Click Create
Copy the Client ID and the Client Secret

Build the custom Connector

Go to flow.microsoft.com
Click Data
Click Custom connectors
Click New Custom connector, Create from blank
Add a name for your connector
Click Continue
If you like to, you can upload a connector icon, this step is optional
enter api.spotify.com as Host

You can find the values you need to fill in here in the Spotify for developers documentation, but to make things easier for you, I will provide them for you.

Click on Security
Select OAuth2.0
Select Generic Oath 2 as Identity Provider
Paste in your Client ID and Client secret
enter https://accounts.spotify.com/authorize as Authorization URL
enter https://accounts.spotify.com/api/token as Token URL and Refresh URL
enter user-read-currently-playing as scope
Click **Create connector
Copy the Redirect URL
go to your Spotify app
Click Edit settings
past the Redirect URI into the field for Redirect URIs
Click Add
Click Save

Now go back to your Custom connector

Click on Definition
Click New action
enter something like GetSong in Summary
enter a description
enter an operation ID like getssong - please note, that this ID shouldn’t start with an upper case letter

Click import from sample
Select verb Get
paste in https://api.spotify.com/v1/me/player/currently-playing as URL

(For reference: https://developer.spotify.com/console/get-users-currently-playing-track/)

Click Import
Click Update connector
Click Test

To test our new connector, we need to select from an existing connection or create a new connection.

Click New connection

A new pop up window will appear and promt us to Agree - you as a user authorize your Spotify app to retrieve data related to your user account - such as the song currently playing.

Click Agree
Click Close

Use the custom connector in our flow

Now it’s time to build our flow

Trigger flic

As already said, we want the flic button to be our trigger

You can choose, if you want this flow to be triggered by any event type or if you want to save the two other event types for other flows.

Now we want to get the current song from our shiny new Custom connector:

Get current song

Click on Insert a new Step
Click on Custom
Select the new custom connector for Spotify

Our intention now is to tweet something like “I am currently listenintg to {songname} by {artistname}, check it out {spotify URL}.” But from our custom connector, we don’t get the name of song and artist per se, we will need to first parse the JSON output. If you never heard of that before, don’t worry, go read this article about how to parse JSON in Power Automate, I will just wait here for you and drink a coffee.

Back again? Cool! ☕

Let your flow run
Go to your run history
Copy the output of the Get current song action
Insert a Parse JSON action
Click Generate from sample
Paste into the new field
Click done

Magic 🦄 - Now we can see all the output from our custom action as Dynamic content. Next thing up is to send the tweet. We can use the twitter connector for it, but Buffer works fine as well.

Add the post a tweet action

provide your tweet text with Dynamic content as you wish from your Parse JSON action. Don’t be afraid when the flow adds Apply to each loops! Unfortunatley, both artist-name and -song-name are named name, so you will need to figure out which is which.

save your flow

Run your flow

Open your flic app and select the new button, set the action that is triggered by the click event to Microsoft Flow (watch out, this is the old name of Power Automate, which is not refelcted in the Flic app). When you now click the button, this will trigger our flow, that listens to the Click event of that button, get the current song and tweet about it!

Conclusion and what’s next

In this post I explained, how you can create a custom connector and call an API outside of Microsoft 365. You learned how to define actions and how to authorize your application so that you can retrieve the requested data. Which use cases do you have in mind? What would you like to build a custom connector for? Please share!

How to get started with CLI Microsoft 365 and Adaptive Cards

Wed, 17 Feb 2021 16:13:39 +0000

How to send Adaptive Cards with CLI Microsoft 365

In this blog post I want to explain how you can send an Adaptive Card with CLI Microsoft 365. I will guide you from zero to hero 🚀, so even if you don’t know anything about the CLI Microsoft 365 or about Adaptive cards, don’t stop reading, you will be able to do that in a few minutes- I promise!

What is CLI Microsoft 365?

Lets first get us all on the same page and clarify, what CLI Microsoft 365 is and why we should use it: It is a CLI (Command Line Interface) which let’s us manage Microsoft 365 from any kind of OS: It doesn’t matter if we work on Windows, MacOS or Linux. Previously, some configurations were only possible by PowerShell for Windows, which limited a lot of admins. But even if you work on Windows and are pretty fine with using PowerShell, CLI might be a nice alternative to try out.

How to use CLI Microsoft 365

I will now describe your first steps:

Install Node.js

To use the CLI MIcrosoft 365, you will need to install Node.js - Please follow these steps:

go to https://nodejs.org/en/
download the LTS version of Node.js
install Node.js

If in doubt, if you have the correct version installed or if you need to use different versions of Node.js, pleas read Use Node Version Manager to develop your SPFx apps by Toni Pohl

Install CLI Microsoft 365

Now that you have Node.js installed, we can continue with installing the CLI Microsoft 365. You can choose any shell you like: If you want to, you can use PowerShell or PowerShell in the Terminal in Visual Studio Code or whatever makes you happy. I like to use the PowerShell terminal in Visual Studio Code, because links render to be clickable and this saves me copy/pasting links into a new browser tab. But if you like to any other shell, that is perfectly fine as well. To install CLI Microsoft 365, run the command:

npm i -g @pnp/cli-microsoft365

In case you wonder:

the i is an alias for install
the -g means that we want to install this package globally
it will take about 2 minutes

Now that we installed CLI Microsoft 365, it’s time to actually do something here. But before we can get or post anything, we will need to log into our tenant. Pro Tip: You can use your your Developer tenant for this. If you don’t know, what this is, please go read What is a “Dev Tenant” and why would you want one? by Julie Turner. Run the following command:

m365 login

In response you will be asked to open a webbrowser and login with a code. If you are using Visual Studio Code, you can click on the link, please copy the code upfront.

After you pasted the code,

click Next
pick an account out of the list of accounts

You will be seeing this message and can close this browser tab- we won’t need it anymore.

Yay! You successfully logged in! You don’t believe that? Let’s check with CLI Microsoft 365 and run this command to get your status:

m365 status

and it will get your status for you:

If you want some inspiration, what you could do now, run this command:

m365 help

which gives you a list of things you can try, these are called command groups, as each of them can contain several commands. When you now choose one of the command groups and run for example this one:

m365 outlook

you will get the commands, that are available to you in this command group. Sometimes, you can go several levels deep-Just try them out!

What are Adaptive Cards?

Next thing we need to know is, what are Adaptive Cards and why would we want to use them? When we look at adaptivecards.io we can read the definition ‘Adaptive Cards are platform-agnostic snippets of UI, authored in JSON, that apps and services can openly exchange. When delivered to a specific app, the JSON is transformed into native UI that automatically adapts to its surroundings. It helps design and integrate light-weight UI for all major platforms and frameworks.’ This means, that we get a nice method to share and display information without needing to know how to use HTML/CSS to render them correctly in different host applications. If you like to know more, please read Get started with Adaptive Cards by Tomasz Poszytek

How do we send an Adaptive Card with CLI Microsoft 365?

Now that we know what is an Adaptive Card, let’s have a look on how we get this sent by CLI. The documentation provides us with a sample and this sample needs to have a URL. Where do we get this from? This depends on where you want to send this Adaptive Card to. In this example, I want to use Microsoft Teams as host application and therefore we will need to create an incoming webhook in Teams.

Create the Webhook

If you have no clue what is a webhook, no problem, Rabia Williams got you covered with How to configure and use Incoming Webhooks in Microsoft Teams.

Open Microsoft Teams
Click the ellipsis icon on the Teams channel that you want to send the Adaptive Card to
Click Connectors
Search for ‘webhook’
Click Add
Click Add (yes, yet again)
Give your webhook a name
If you like to, you can upload a picture- messages sent via this webhook (our Adaptive Card) will have this image then as Profile Pic - this step is optional.
Click Create
Copy the generated URL
Click Done

This URL is the URL we will need in the command later - If you want to, paste it into a notepad or similar.

Author your Card

Now it’s time to author your card. You can do this in a lot of editors, I use either the Adaptive Cards Designer or the Adaptive Cards Viewer Extension in Visual Studio Code, but recently also found Adaptive Card Studio. You can also use one of the provided samples and use them as-is or adjust them to your needs.

If you feel like authoring your Card in Designer or Visual Studio Code is fine for you right now, go ahead with this, otherwise you can also use the examples that are provided in the documentation of CLI Microsoft 365. I used the last one, ‘Send custom card with card data’.

For everyone not very familiar writing and understanding code: We can make more sense of the snippet by copy/paste this into Visual Studio Code, and then press Alt+z to soft-wrap this and then separate the Adaptive Card from the rest:

Select JSON in Language Mode
Insert somenew lines right before the first {
Delete the ' at the beginning and the end of the snippet
Format with Shift + Alt + f

Now go ahead and adjust the sample to work in your environment:

replace the URL in the code with the URL that we copied when we added the webhook connector to Teams
copy the whole code
run it

⚡ Turned out, that there are some differences how to use quotes ' or " - please consider which shell you are using before you copy/paste the code from CLI Microsoft 365 documentation.

Congratulations 🚀- you sent your first adaptive Card with CLI.

Feedback and what’s next?

I hope you liked this little post on how to get started with CLI Microsoft 365 and learning how to send an Adaptive Card with it. I would like to learn, for which usecases you would do this? Please comment below!

Why I blog or Why Sharing IS caring

Fri, 12 Feb 2021 22:00:51 +0000

Why I blog and how

I run this blog for a few years now, and sometimes people outside of my filter bubble ask me why I do this, as no one pays me for that, and I don’t have any ads on my website. Instead of explaining this over and over again, I decided to write a metablog post on why I blog. If you come across my website for the very first time today: I mostly blog about Microsoft 365 and Power Platform; sometimes, I throw in some more personal posts as well. I write not only here, but also

on Community Docs
took lead of the Microsoft 365 PnP Community on TechCommunity
run my own food blog and
write the stories for PYOD news, the blog of the sticker business that I run together with Elio Struyf

You can say that writing is an essential part of my life. I strongly believe in the Sharing Is Caring mission, which most of you will heard about in the context of Microsoft 365 PnP and I feel it’s important to understand why blogging incorporates so much of #SharingIsCaring for me.

Why do I blog?

It seems we already covered the first reason for me to blog: If I know something that could potentially be valuable for others, it will be smart for me to write it down and make it accessible to everyone. Some people then wonder that if I share my professional knowledge for free, that this would weaken my position, there will be less demand to hire me or others as consultants or developers. But I think that the opposite is true: By showing my knowledge and even sharing my learning journey in public, potential customers see what I am capable of, and they don’t need to guess if I have the right skillset nor if we have the right fit on a more personal level. Being open and sharing my knowledge has always been a significant driver in my career; running this blog is part of it!

Solidifying my knowledge

If we need to explain something we know to someone else, we will likely try to find examples, analogies, and metaphors that our audience will find relatable, which will increase their understanding. The same happens when we blog about a solution or write a how-to guide or elaborate on thoughts regarding a product or a specific behavior. We need to slow down our thinking and try to see our topic with different eyes. Changing the perspective will enable us to see the whole picture and will complement what we already know. It will allow us to flip sides and perceive our knowledge from a new view. And it will force us to get familiar with the ‘hows’ and the ‘whys’ of best practices or different approaches as we will need to explain everything in detail. This applies even more when we want to write bias- and assumption-free, beginner-friendly content.

Blogging helps me solidifying my knowledge and broadening my view.

Exploring new areas

Sometimes, we write about what we already know, but verz often, we write about topics we want or need to explore. The fact that we need to understand the nitty-gritty details leads to discovering more and more levels- and very often, we will be surprised that the post took us more time to write, covers this topic in more depth, and that we learned so much by writing it. Of course, if we happily jump into a new rabbit hole, we can’t know how deep this is and how much time and effort it will take us to understand it. Perhaps we will notice half-way through, that our previous assumptions, where this post will lead to, were partially or entirely wrong, or we will learn how our freshly gained knowledge connects to and relates with the things we already know. This is very rewarding for me: not only learning facts but also connecting the dots and making sense of subjects that I didn’t (fully) understand before. As the world (and tech) gets more and more complex, it’s essential to understand the impacts of new features, changes in licensing, product launches, etc.

Writing blog posts makes me more comfortable and more sustainably understand new things and connecting them with my existing knowledge

Extending comfort zone

But there is another aspect of writing what we know or what we want to explore. It is about being open about our learning journey and finding joy in being a #LearnItAll. I don’t think that stepping outside of our comfort zones (and then returning to it) is something we should look for. I instead aim to extend my comfort zone so that once I managed to do the thing outside of my comfort zone, my comfort zone (and me within) grows.

Being a content creator allows me to grow both personally and professionally while sharing my passion with the community

Reuseability /Repurposeability

Once I wrote a blog post, I can repurpose the gained/solidified knowledge easily: I can give sessions, workshops, talks about it, participate with my perspective in panel discussions, TweetJams, or interviews, and do not need to limit myself to the fact that this is a one-time-publishing event. Reusing my content makes me aware of how much I already know and what is still not addressed to everyone. As we know, new people start every day, and we overestimate a lot of what people know. Therefore, it’s a good idea to reuse what we already published because it will expose us to new audiences and help them find their way into this community and pay it forward as well.

(so called) Soft Skills

Sometimes, I hear people saying, “Oh, I couldn’t write that often/about so much,” or “I wouldn’t know where to start” or even “wait, you write after you already finished a long workday?”. Writing taught me some skills that I need in my day-to-day life:

Persistence

I want to write 50 blog posts for this year, which means ~1 blog post per week. This doesn’t sound that much, but actually, I need to find inspiration for a topic I want to blog about, and it does not only take the time to write down your thought, but to think, explore, try something out, talk with others, learn, exchange views, learn even more, etc. Being persistent and writing one of my habits that I nearly do every day helps me with that: I get more easily in the mood of writing, which means that my mind talks more easily to my typing fingers eyes are reading what I am writing. When I am in the zone I perceive this feeling of being in the flow: I forget time, I am highly focused on the topic and too relaxed. This feeling makes me feel good, and I get somehow a little bit addicted to it. Sometimes during the day, when I am stressed because of too many meetings or much task-switching, I am already looking forward to my writing session in the evenings.

Critical Thinking

As I write so often, I do not only think about writing when I write, but I see everything also with the lens of: “Could this be something that I should elaborate on in a blog post?”. And by seeing, I mean all phases of critical thinking like

Remembering
Understanding
Applying
Analyzing
Evaluating
Creating

It is not enough to remember knowledge or understand it or use and implement it, but I also aim to organize, structure, and check what I learned. And then, of course, I love to create by designing and building solutions.

Blogging gives me more opportunities to do new things

Empathy

Changing perspectives and figuring out how others feel about something not only broaden my horizon but also affect my decision-making process and make me communicate better. As a result, empathy makes my content more accessible, more inclusive, and more bias-free.

Creating Content makes me even more empathetic and lets me even more understand the real value of a holistic diversity of backgrounds and skills

Creativity

This one sounds too apparent. When I create a new blog post, this is about creativity. It is about the act of making something out of nothing. I do not only modify something, but produce something unique that represents my knowledge and beliefs and serves my purpose. Some people fight against the fear of the blinking cursor. But I managed to turn this uncertainty and my sometimes occurring doubts if my thoughts are worth reading into the freedom to express myself how I want it. I enjoy being a content creator and doing this on my terms on conditions. I don’t have any deadlines (although I set a goal on frequency), no topics to cover, no specific amount of lines to write. My blogs are an invitation for others to learn and feel inspired to share what they know.

My blogging habits make me feel more confident about my skills

How to I blog

After the significant why of blogging and why this represents so much of Sharing is Caring for me, here is my

setting

I write my blogposts as markdown-files in a public repository in GitHub.

GitHub

Some people might think about code or open-source at first when they hear GitHub and wouldn’t recommend this as a blogging tool in the first place, but for my purposes, it is incredible. Collaboration with others on blog posts works like a charm, and the commit history is an excellent visual representation of my blogging (and other) efforts. I do not do this to get more green tiles, but the green tiles show me my persistence, and it’s more comfortable to reach my goals then. Looking at my commit history is one part of keeping me motivated.

Public

But why on earth do you write in public? people ask me. You could set up a private repo; once you commit, the whole world can see your ~~shitty~~ non-mature first drafts, your rough ideas, your typos, and broken links.

Yes, that is true. But also, there is nothing wrong with not being perfect or about showing work in progress. I feel very comfortable with that. Plus, if someone finds a typo, they invited to PR that :-)

Markdown

This allows me to focus on my content instead of being distracted by a UI that gives me too many options to format my text. Concentrating on writing lets me get into this flow-feeling more easily, where words and thoughts seem to directly from my mind into my fingers.

Publishing

I publish my posts mostly on this website and my recipes on ThatKitchenPrincess.com, which both run on WordPress. I use the Documents by Git plugin to publish my markdown files on WordPress sites directly. The plugin uses the GitHub’s markdown API to render HTML. and is easy to configure:

install the plugin
activate it
Get a personal access token from GitHub (you can find this in Developer Settings in your GitHub account
open config.json and insert values for user and token.
save config.json file

To publish a post, I need to insert [git-github-markdown url="{url of my blogpost from GitHub}"] in the body of my post and add a title

I also take care of the featured image and the Twitter Card preview Text.

Marketing

To share and reshare my blog posts, I add them into a queue so that they get automatically republished on Twitter and LinkedIn, I blogged about how to do that here.

Conclusion and What’s next?

How do you feel about blogging? What’s in it for you, and what is rewarding and challenging for you? I would love to learn from you!

#SharingIsCaring

How to get started with HTTP requests in Power Automate

Wed, 10 Feb 2021 21:50:09 +0000

How to get started with HTTP requests in Power Automate

If you ever wondered what is an HTTP request and why you would want to know how this works - this post is made for you.

What is a HTTP request and why would I need it?

HTTP requests are a super powerful thing - not only in Power Automate! We will first need to understand what this is in order to determine why we would like to know how to use them. But wait - HTTP?

What is HTTP?

Let’s first get us all an the same page. HTTP is the acronym for Hypertext Transfer Protocol. Its purpose is to structure requests and responses over the internet (yeah, you heard of that one 😇) - Data needs to be transferred from Point A to Point B over the network.

The transfer of resources (like html files, images, videos etc) happens with TCP - which again is acronym, for Transmission Control Protocol. When you read this blog post, TCP manages the channels between your browser (hope you are using Microsoft Edge) and the server. TCP is used a lot for scenarios in which one computer sends something to another. Now what has TCP to do with HTTP? Think of HTTP as the command language for both computers so they are able to communicate.

When you type a URL like https://www.m365princess.com into the address bar of your browser, your computer establishes first a TCP connection and then makes a request. We will call your computer now client. The request is a HTTP GET request, as we nicely ask to retrieve the website that the browser shall display. And as we send a (nice) request, the server (site that you requested) will send a response and close the TCP connection afterwards. Of course, there are more methods than just the GET method, you will learn later more about methods POST, PUT, PATCH, DELETE.

Now that we know what an HTTP request does, we want to learn what it could do in Power Automate

What can HTTP requests do in Power Automate?

Power Automate offers you a huge variety of connectors and within those connectors, many actions which you can use to automate your processes. But although we have so many options, this won’t cover everything you need or that you might want to build in Power Automate, which is why we have an HTTP action in Power Automate as well. With the HTTP action we can invoke a REST API.

What is a REST API?

Wait but what? Ok, let’s slow down a little bit. What is a REST API and would we want to invoke that?

API is -yet again- an acronym for application programming interface and it is a set of rules and mechanisms. By these an app or a component interacts with others. RESTful APIs (REST means representational state transfer) can return data that you need for your app in a convenient format (for example JSON or XML). By using the HTTP action in Power Automate we can invoke/call an API by using methods GET (read), POST (write), PUT (update), PATCH (update, but only partially) or DELETE (remove). The same way as our browser made a call towards a website and getting a response using HTTP, we now use HTTP to send a request to a service. In my example, I will use Microsoft Graph. Microsoft Graph is a RESTful API that enables you to access Microsoft Cloud service resources. It is literally THE way to read, create, update and delete resources (like files, teams, meetings etc.).

💡 Microsoft provides us with an amazing tool to try out Microsoft Graph, it’s the Graph Explorer.

How to create a HTTP request in Power Automate

Now how do we create an HTTP requests in Power Automate? First let me introduce everyone to our little

Use case

We want to use Power Automate to create a Team with some predefined content in it. To make things easier, we will use the mobile trigger and ask for Team Name, Team Description, and if a user wants a channel for Learning and wants to pin training material (a website) as a tab to this channel (Of course, we would do that later in a form, an app, or a bot, but for understanding the logic of HTTP requests in Power Automate I will keep this as simple as possible)

We will now add actions to create the team and then we add a condition: If user wants learning material, we want create a chabnnel called Learning and want to pin a website to it.

Unfortunatley, there is no action “pin a website to a channel in Teams” in Power Automate. Fortunately, we can still do this by making an HTTP request towards Microsoft Graph. This is why I added the HTTP action into the flow:

You can see a lot of fields in that HTTP action, so I will make you understand them.

What do we need to make a successfull HTTP request?

💡 It is a very good idea to open documentation on docs.microsoft.com while buiding your flows that call Microsoft Graph. You will find in nearly all pages four things, that we need to consider when doing an HTTP request:

Endpoint

First things first, if we want to call an API with HTTP, we need to know the right endpoint. Think of an endpoint like a phonenumber that you want to call. You need to know it, because otherwise you won’t reach the right person.

An endpoint is a URL like this: https://graph.microsoft.com/v1.0/{resource}?[query_parameters] and we will later use https://graph.microsoft.com/v1.0/teams/{team-id}/channels/{channel-id}/tabs to create this tab.

Method

Second thing we need to know is which method we want to use. As already explained,

Method	Meaning
GET	📖 read
POST	✍ create
PUT	📰 update
PATCH	✒ update
DELETE	🗑 remove

If we now open the dropdown menu for the Method field in the HTTP action, we will see a representation of that:

As we want to create a new tab in a channel, we will use POST.

Headers

Headers are not mandatory for all requests, but look like this: Content-type: application/json - If they are needed, documentation will tell you.

Data (or body)

If we call an endpoint, it’s not enough to specify the URL the request needs to make to, but we will also need to post some additional info into the body of our requests. Most GET requests though don’t need information in the body, as they will only list the requested resources.

Fill in the HTTP action

If we carefully follow the Docs, we will see that we should do this:

POST https://graph.microsoft.com/v1.0/teams/{team-id}/channels/{channel-id}/tabs

{ “displayName”: “M365Princess Blog”,“teamsApp@odata.bind” : “https://graph.microsoft.com/v1.0/appCatalogs/teamsApps/com.microsoft.teamspace.tab.web", “configuration”: { “contentUrl”: “https://m365princess.com”, “websiteUrl”: “https://m365princess.com” } }

Some remarks on that:

Choose Method POST - we already figured that out
https://graph.microsoft.com/v1.0/teams/{team-id}/channels/{channel-id}/tabs is our URL, but we will need to replace {team-id} and {channel-id} with the actual dynamic content
Choose a displayName for the Tab as you wish

"teamsApp@odata.bind" is “https://graph.microsoft.com/v1.0/appCatalogs/teamsApps/com.microsoft.teamspace.tab.web"
Both websiteUrl and contentUrl are the full URL of the website you want to pin including https://. If your website is only http:// you can’t use that inside of Teams.

In total, this looks like this:

Authentication in Azure AD

We are almost there, but some critucal parts are missing. As you can see in the last image, there is a Show advanced options link in the HTTP action and we need to click on it. Our HTTP request need authentication. We can authenticate via Azure Active Directory OAuth, but we will first need to have a representation of our app (yes, this flow that calls Graph is an application) in Azure AD.

We will follow these steps to register an app in Azure AD:

Go to portal.azure.com and log in
Click app registrations
Click New App registration
Give your app a nice name
Save tenant ID and Client(app) ID somewhere (notepad or similar)
Click API PERMISSIONS and select Microsoft Graph
Now look up the permissions needed for this action: [Add tabs to a channel(https://docs.microsoft.com/en-us/graph/api/channel-post-tabs?view=graph-rest-1.0):

Permission type	Permissions (from least to most privileged)
Application	TeamsTab.Create.Group*, TeamsTab.Create, TeamsTab.ReadWriteForTeam.All, TeamsTab.ReadWrite.All, Group.ReadWrite.All, Directory.ReadWrite.All

Select all these permissions
Grant Admin consent
Click Certificates & secrets
Click New client secret
Type in a description
Click Add
Copy the value and save it in your notepad (you will need that later)

Write the IDs into variables

In our flow, we will now initialize three variables at first level (before any condition) and set their values the copied values of Tenant ID, App ID and App Secret. All three variables are of type string.

Complete the HTTP request

Now we will fill in some more information in the HTTP request:

Authority: https://login.microsoftonline.com
Audience: https://graph.microsoft.com

Besides that, we will use our three variables for Tenant ID, App ID and App Secret.

Our flow should look like this:

Celebrate

If we now run the flow and take a look at the new team in Microsoft Teams:

we can spot our freshly created tab with the the content we wanted to provide!

Conclusion

HTTP requests re a super coo method to achieve a lot of things that are not actions in Power Automate, but can still be executed using Microsoft Graph (or other APIs!). What are you using HTTP requests for?

How to use Parse JSON action in Power Automate

Mon, 08 Feb 2021 23:15:04 +0000

How to use Parse JSON action in Power Automate

We can see a a lot of JSON in our Power Automate flow run history, and if you wonder, how you can parse JSON to make Dynamic Content (which is selectable) out of it so you can more easily make use ob an object, then this post is made for you.

If you want to know what exactly is JSON and what you need to know about it, please read this great article by Bob German in the Microsoft 365 PnP Community at TechCommunity or watch this cool video by April Dunnam first, I will just wait here for you.

a little use case

Back again? Cool. Now that you know what JSON is, here is a little use case. Let’s say we wanted to post a random item from a SharePoint list to twitter each day using Power Automate. This is a screenshot of my list:

and this is the overview of the flow that we are going to build:

Trigger

First things first, our trigger needs to be the Recurrence trigger, in which we specify, in which rhythm this flow shall run.

SharePoint Get Items

Now our flow needs to get all items from the list that we want to randomly pick one item from.

Compose

We need to do some magic so we get a random item, I used the following expression for that:

body('Get_items')?['value'][rand(1,length(body('Get_items')?['value']))]

We use the rand() expression to get a random list item from that list. The arguments inside of the expression 1,length(body('Get_items')?['value']) mean that our flow needs to pick a random number between 1 and (as this value could change over time) the amount of list items (which is expressed by our length(body('Get_items')?['value']))expression. The output of this Compose action will reflect a random list item.

Parse JSON

Now to the interesting part of this flow: We want to exactly post this random list item but we if we look into our Dynamic Content, it gives us only content from the Get items action, but that is before we get a random list item, and as we do’t want to tweet ALL list items, this isn’t a good idea. How do we solve this now? Well, we parse JSON, which means that we turn the code into objects again and those objects are then reflected in the Dynamic Content in Power Automate.

Before we add the Parse JSON action, we need to find out, WHICH JSON we need to parse. As already mentioned, we can see the JSON code in our run history, which is why we save our unfinished flow and let it run. Then we open the run history, and have a look at the Outputs of the Compose action and copy everything inside of that box.

Now we edit our flow again, add the Parse JSON action, add the Outputs from our Compose Action as Inputs to that action and click the Generate from sample button. We will now paste the copied JSON into the Insert a sample JSON Payload box and click Done. What we did with that is telling the flow which objects it needs to parse. If we now look at this action, we can see the JSON inside of our Parse JSON action, but all values from the run history are replaced by placeholders: “string” (if it was text), “boolean” (if it was a yes/no), etc.

Now that this action knows what to parse, we can proceed with the next action

Send a tweet

We can now see a lot of new Dynamic Content which comes from our Parse JSON action.

We can now select all values we need in that tweet, plus some more or less generic hashtags (Pro’s will add hashtags into a dedicated column in SharePoint.) If we now save and run our flow, it will first GET all items from the list, then identify a random list element and send out a tweet with the Title and URL auf exactly that list item.

Conclusion & What’s next?

The Parse JSON action can help you turn Outputs from previous actions into Dynamic Content which you can then use in your flow. I’d love to know what you do with Parse JSON, let me know!

If you are now hungry because of recipes in the list: ThatKitchenPrincess.com

How to add a simple preview in libraries in SharePoint

Mon, 08 Feb 2021 19:52:42 +0000

#M365Hack - How to add a simple preview in a library in SharePoint

After my last #M365Hack where I showed you how you can create a Dynamic preview for documents in SharePoint a few people reached out and asked about an easy way to just have a simple preview of a document or image in a library.

Although this trick isn’t new at all, many of my customers found it valuable, which is why I want to share it here as well.

❓ Question: Luise, can you build…

a preview for images and documents in a SharePoint library?

❗ Answer: Yes of course, we need…

an additional column (single line of text will do the job) and name this column Thumbnail - thats it. #Magic 🔮

Works with .docx, .pdf, .pptx, .xlsx files.

How to let people love metadata in SharePoint and Microsoft Teams

Thu, 04 Feb 2021 20:27:43 +0000

How to let people love 💗 metadata in SharePoint and Microsoft Teams

I’ve been told since I started to work with SharePoint, that people hate metadata. They don’t understand why information architects need them, feel it’s too time-consuming to maintain them, and feel uncomfortable with using them as a method to retrieve the information they need to find.

The fact that people only think about finding documents works, when they desperately need to know where THE MOST IMPORTANT FILE OF THE UNIVERSE is saved, is not helpful. This leads to “let’s stick to what we already know,” aka “we’ve always done it like this before” thinking. And this means:

the evil trinity of lousy information architecture

copies of copies of copies of copies…

We know that most organizations have redundant content: copies of copies of copies of the same document in different locations. This originates in a massive abuse of email as a document management system. People attach copies without even realizing that those emails cause a bigger problem:

Let’s say Person A sends an email with an attachment to Person B so he/she could change it and send it back. How many different copies would we now have created? Let’s count:

1 Original
2 A’s Sent Items folder in Outlook
3 B’s Inbox folder in Outlook
4 B saves the file in her/his file server
5 B makes changes to the file and saves it as a separate file on her/his file server
6 B attaches the file to an email and sends this back to A
7 A’s Inbox folder in Outlook
8 A saves the file as a separate copy on her/his file server

1 file - 7 additional copies. What if we don’t play this ping-pong game with 2, but with 5 people and not one time back- and forth, but 3 times? You see, this is the ugly truth of “have been sitting in documents and email the whole day”. Which one is the valid one? What is the final one?

awkward files names

To cope with that, people get creative and invent super awkward file names, like

ProjectDeathstar_MasterplanGoLive_DV_21-02-04_V3_final2_FINAL.docx

I mean, wow, what is that? Shouldn’t they stick to a naming convention?

What are people trying to do? They add some attributes of a file to its name to more easily know what this document is about before they need to open it. Versions, status, name of people who created/modified the document (but maybe that’s the name of a Project Manager, a role that needs to approve something?! We don’t know), and, almost mandatory, a date. Is this a due date, the date of creation, or the last edit? Again, nobody can know. We guesswork, we compare, we track changes, and send even more emails.. Could you please send me the LATEST version of that file?!

To be able to cope with these awkward file names, they try to segment information so that there are fewer items to scroll through:

cascading folder structures

Creating a gazillion of cascading folders seems to be the holy grail in some organizations. They are used to working with folders when it comes to paperwork and applying the working methods back then to their digital work. They did not evolve in their working behavior in the last (at least) 30 years. This is why they didn’t find approaches that support retrievability of information, but that map working with papers and that imitates as if they were still working on paper:

A folder allows only one attribute for a file, and people need to pick one out of several attributes and prioritize precisely this. Let’s say our document belongs to Project DeathStar, is a Plan, and is still a draft? Should we then file it under the Project folder, the Plan folder, or the Draft Folder if they happen on the same level?

What if we nest folders into other folders? Will this solve the problem? Well, let’s see: An accounting department needs to store invoices, purchase notices, and contracts. Shall we group those by type or by year?

How does this lead us to people out of a sudden loving metadata?

Most of them know that we can use metadata in SharePoint and Teams, but they will insist that it takes too much time to fill in columns with data to describe what a file is about. But once we explain the evil trinity (copies of copies of copies, awkward file names, cascading folder structures) and show them how time-consuming this behavior is, they will open their minds and get it:

Yes, it WILL take some time to maintain metadata, but this will save everyone even more time because we can better filter and therefore faster retrieve what we were looking for in the first place. Plus: we will not have to deal with this tremendous amount of copies anymore, as SharePoint offers us version history.

Please note that a folder per se isn’t evil, but that if we overdo (3 levels and more), we will create insane chaos.

Feedback and what’s next?

I would love to know what you do to convince people to choose metadata instead of folders? One of the blog posts could be around version history- what do you think?

Create a dynamic preview for documents in SharePoint

Wed, 03 Feb 2021 15:57:12 +0000

Create a dynamic preview for documents in SharePoint

Blew some minds at customers with SharePoint List formatting and Power Automate flows (read here Part 1, Part 2, Part 3) but the preview of an image was not, what they had in mind.

❓ Question: Luise, can you build…

a dynamic preview, so that we can click through our PowerPoint presentations?

❗ Answer: Yes of course, we need…

a page, a library and 2 webparts for that :-)

Here we go:

Create a new page
Clean up the page, we don’t want to display text here
Insert the document library in the left column
Insert the file viewer web part in the right column
Cancel the dialog that asks which document you want to preview
Click the Pencil Icon on the file viewer web part
Click the Ellipsis Icon at the top right corner and select Connect to source
In the Dropdown Menu select your document library
Publish your page

💡 You can now click through presentations, scroll through lengthy Word files and preview Excel spreadsheets.

Conclusion

Sweet little #SharePoint hack 🚀

How to spend less time organizing your agenda with Bookings, FindTime, Cortana & MyAnalytics

Tue, 02 Feb 2021 21:07:55 +0000

How to spend less time organizing your agenda

Keeping our calendars as a representation of our daily agenda is crucial, especially when we have more meetings than ever before. In this blog post, I will give you some ideas on how to let smart tools integrate with Outlook so that you need to spend less time scheduling meetings and have enough time to get the work in between your meetings done.

Use Microsoft Bookings to schedule meetings with customers and the community

Included in my Microsoft 365 license comes Microsoft Bookings, a service that lets externals book appointments via a website in free slots depending on your availability without letting them see your actual calendar. It automatically sends invites, confirmations, and reminders and integrates perfectly with Microsoft Teams meetings. Bookings is available for all customers with

Microsoft 365 Business Premium
Microsoft 365 Business Standard
A3
A5
E3
E5

licenses, and you will need Outlook on the web or Outlook mobile have enabled, which requires your mailbox to be in Exchange Online. The bookings calendar will create a new calendar in Exchange Online and a related entry in Azure Active Directory. You can add scheduling policies and define time increments to be able to book, lead time upfront of a meeting, and if you need to have time in between of meetings.

I added a link to my bookings page to my Outlook signature and told my customers about it. Whenever a new customer-to-be or someone from the community wants to schedule a meeting, I reply with this link, and bookings does the rest for me. It reflects my availability, and I can exclude times from it as well. The beauty of it is that I do not need to send emails back and forth about scheduling a meeting anymore. This makes scheduling fast and effortless and looks very professional as well. Find more information here.

FindTime to schedule meetings with larger groups and let them vote for a date

FindTime is an Outlook Add-In by Microsoft, which let’s sends some proposals for meeting times to one or more persons. You need to select those times by yourself and that the recipients will vote on the times if they can make it or not and what of the options would be their preferred time slot to meet. This way, you can create a poll and see which time slot you should pick because all or at least the majority of invitees confirmed the upcoming meeting.

Use Cortana to schedule time for weekly meetings

I use Cortana to schedule 1:1 weekly meetings that do not need to be on a predefined time/weekday each week, but can be handled flexibly, and also use it for (virtual) coffee meetings.

After clicking on the tile, my Outlook client opens a new email with cortana@calendar.help in cc and a message to Cortana to book a meeting for 30 minutes every week. You can, of course, change the value and the default value as well. Cortana will now send email an email to the recipient and propose three different free timeslots and get back to you after the scheduling was successful.

You might have noticed that you can also book focus time with Cortana, but I prefer to do this with Insights/My Analytics:

Use My Analytics/Insights to increase awareness, protect your time, and don’t miss staying on track

I use a service called My Analatics to protect my precious time, makes me aware of unhealthy working habits, support me in staying in touch with people relevant to me and increase my reach

How does My Analytics work?

My analytics is a personal productivity tracker. Think about it as your Smart Watch, which tells you to go for a walk, stand up regularly, or measure how fast you run (when you go for a run) to establish healthy habits.

My analytics works with 4 elements:

MyAnalytics dashboard - which is where you can see how you spent your time over the four weeks across four different plans: focus, wellbeing, collaboration, and network
Insights Outlook add-in - gives you suggestions based on your working behavior
Digests - This is a summary of the last week with actionable insights
Inline suggestions in Outlook - recommendations to improve your work patterns

Ever wondered how it can already be 5 pm and how the heck you spent your day? Have you been busy all day long but can’t tell how 9 hours could have passed, but you still couldn’t check off your most important tasks? Well, we all know those days and even weeks. The reasons are pretty obvious:

poor planning and prioritizing of tasks / unclear commitment which tasks need to be completed today
too many meetings that don’t add value to your work
things get into the way of your planning, and it’s hard to stay on track
it’s challenging to change habits

To tackle these, I do the following:

All my tasks will be reflected in Microsoft To Do:

personal tasks
tasks that live in planner but can be accessed via To Do
emails from external people that contain task, which can be accessed via To Do

Within To Do, we can find a very interesting feature called “My Day,” in which you daily commit to the tasks you want to work on today. Learn more about it in my blog about reasons why I fell in love with Microsoft to Do. If you feel like having already too much on the plate, it can be useful to dig a little bit deeper into How to stop overcommitting

I decide very carefully which meetings I attend. If I can’t learn something in a meeting that I work towards my team’s objectives or if I can’t contribute in a meaningful way, I will not participate. If you want to know more about why and how I do this, read my blog post about digital clutter and how we use our time

To protect my focus time, I use My Analytics:

The Focus Plan gives me an overview of what happened in the past four weeks and encourages me to change what didn’t go as planned. It lets me schedule my focus time (which will automatically set my Microsoft Teams status to DND) and review overlapping events in my calendar, not to double-book.

The Wellbeing Plan gives me insights into my ability to disconnect and recharge my inner batteries. It calls me out on working crazy hours and suggests taking real breaks. Being confronted with real numbers instead of just guessing is very valuable because I am very hesitant about taking time off.

Ever wondered if the time you spend with meetings is adding value? The collaboration plan confronts me with my meeting habits. If I joined on time, got distracted by writing emails during meetings, if I added a Teams link or if my meetings overlapped. This report is gold because it reminds me that I am responsible for getting the most out of the very precious time when I meet with others. If we try to multitask, need to join late, and leave early, I will probably prioritize other things. I find it very helpful to readjust my commitments and make more informed decisions on what to work on.

Networking plan makes sure you don’t stay in your filter bubble only but expand your network.

Things that get in the way

Now that My Analytics/Insights is protecting my focus time, evenings and nudges me into healthy meetings, it is less likely, that things conflict with how I planned my time. Of course, we all know those emergency cases, but they don’t occur every single day.

Habits

Well, changing your habits is hard. Patterns are not only well-trained and familiar; they also originate in some common beliefs/ mental models. If you want to learn more about those, read the article about Why Microsoft 365 adoption projects fail on docs.microsoft.com - collaboration with Michael Roth

If change is that hard- how can we still master it?

We need to stick to a process:

set a specific goal Without a clear purpose, you can’t improve and can’t track your progress. Set a goal like “Over the next two weeks, I will batch process my emails at 10 am and 3 pm.”
plan

It would help if you were very clear and concise about why you want to do that and what drives you to set up this goal. Our example could be that it reduces your stress level, leads to fewer interruptions, and more focused working hours.

practice

Now comes the most challenging part - DOING what we planned. And now My Analytics comes into play: For example, with its Outlook Add-in, that prompts me to make an appointment with myself and book focus time. I can also book focus time regularly in the Dashboard, but it comes very handy in Outlook, where we still receive and process our mails and do lots of meeting planning.

celebrate

Celebrating the small wins is essential - we can reflect on our journey and feel what’s right for us! It is also an excellent opportunity to share what helps us to inspire more people.

Feedback and what’s next

Using a combination of different tools for different workloads helps me getting the most out of my day - which can be quite busy. I would love to know how you schedule your meetings, protect your focus time and manage to get your work done! Which tools do you use, which approaches help you?

How to create a Content plan for your Social Media activities in a calendar view in SharePoint lists & automate all the boring work

Tue, 02 Feb 2021 13:50:47 +0000

I love SharePoint and I am amazed by lists - regardless if I use them standalone as Microsoft Lists, in SharePoint or in Microsoft Teams. One thing, all my customers want to know, are calendar views. I run, together with Elio Struyf a sticker shop and we both do not only aim for delivering amazing stickers, but also continuesly improve our business. You could read in my last posts about list formatting Part 1 and Part 2, how I automated some social media activities. In this post I will show you how to create a content calendar and also automate creating actionable tasks from that as well.

Create a list with calendar view

I created a list in SharePoint and added columns for date, tweettext, hashtags URL and additional actions. Important: The Column, that contains the date needs to be a date column. I created some list items and created a new view:

Click All Items
Click Create New View
Give your view a nice name
Click Show as Calendar
Click Create

automate creating tasks in Microsoft Planner

We use Microsoft Planner for our tasks, which is why I want the additional tasks, that come along with an event in this calendar to appear in our Planner board. Instead of copy-pasting everything manually, I built a flow that does exactly that for me automatically:

This flow is triggered when a new item is created or modified and then checks if the column with additional tasks is not empty. If that condition returns true, it creates a task with a due date and assignes me to that task. After that, the flow updates that task with a description and a Link to the list item.

automate tweeting about the content from calendar

As I already have content in the list to be tweeted, I now want to post the tweets automatically on value in my Date column. I created a scheduled cloud flow, which runs every day and gets only the items from my list where the Date equals today’s date.

To achieve this, I used a Filter Query in the Get items action: Date eq 'utcnow('yyyy-MM-dd')' and then created and shared an update in Buffer:

Conclusion & What’s next?

With a list, a view and 2 flows I could automate another piece of content management and daily marketing in this small business scenario. I would love to know what you like to use calendar view for and what you want to automate.

How we use SharePoint list formatting and Power Automate at PYOD to ease our marketing

Sat, 30 Jan 2021 23:49:13 +0000

How we use SharePoint list formatting and Power Automate at PYOD to ease our marketing

Together with Elio Struyf, I run an online sticker shop called PYOD - pimpyourowndevice.com. Elio described, how we use Power Platform and Azure Functions to keep the store up-to-date and to print the labels for our envelopes to send out the stickers. This blog post shows, how I use SharePoint and Power Platform to market our products and make our day-to-day work even easier. We strongly believe that low-code and custom code complement each perfectly and that we can achieve more together.

Posting a random sticker

We use a SharePoint list for our inventory. This means, that each sticker is an item in the list and that we have dedicated columns for all attributes like price, dimensions, material in that list. These attributes are of course reflected in the store. To automate sharing our stickers on socials, I added some more columns like twitter text, twitter hashtags, and a shortlink to this sticker in the store. I experimented a bit with Buffer to automate posting on Social Media, but I was not happy with it, as I couldn’t find an easy way to post stickers in a certain rhythm. My solution: building a Power Automate flow, which posts a random item from said SharePoint list.

The flow looks like this:

How does this flow work?

It is a scheduled cloud Power Automate flow, which runs every 15 hours and gets all items from the inventory that are for sale. The compose action will get a random item, because I do not want to post every item but only one. The expression is:

body('Get_items')?['value'][rand(1,length(body('Get_items')?['value']))]

I use the rand() function to get a random value between 1 and the amount of list items in this list.

In the next step, I parse the JSON code from the Outputs of my compose action so that I get all keys as dynamic content in my flow. Now I will create an update in Buffer, with the title of my item, description, hashtags and the link to the shop. Finally, I share the created update from Buffer. The Flow automagically 🦄 creates an Apply to Each loop for me, as it could be, that there is more than one update created.

why does this run every 15 hours?

Well, there are timezones, and as this shop sells and ships worldwide it’s beneficial to not always post at the same time to reach different people. I recreated the same flow for our different social media accounts and let each of them run with a delay of a couple of hours to maximize reach and visibility of the brand.

Ooops, something went wrong

Sometimes, we make mistakes, like broken links because of a typo in our list, for example. As this doesn’t look good, I created a oops, something went wrong column in our SharePoint list and associated a flow with it:

How does this flow work?

This flow is very similar to the first one. I used the For a selected Item trigger, get the item of the list that matches the ID of the selected item and then update and create my update via Buffer as shown before.

How does this flow work in the SharePoint list?

To have a nice trigger in the list, I formatted the oops, something went wrong column with this sample. To learn, how you can apply column samples to your SharePoint lists, you can read my blog about SharePoint list formatting made easy

This particular sample will create a button in each row of your list which executes a flow. To know, which flow it needs to execute (as you can run several flows associated to the same list), you will need to provide the ID of the flow that you want to run. You can find it in URL of the flow. You can change text, backgroundcolor, icon next to the text and more, please use Fluent UI Icons for reference.

Of course, we do not only use that for typos, but also if we get a question on socials about a certain sticker to easily tweet it. I created this flow two times for our different social media profiles and formatted the list columns accordingly:

News by RSS

Blogging for me does not stop with my own blog and my foodblog, but I also write stories on PYOD News. Because I want to automatically tweet these micro blog posts, I build another flow to do exactly that, after Elio prepared an rss feed for the news site.

Ideation and Decision making progress

Running a sticker business means, that all cool ideas for new stickers need to have a decent home. That’s where our Ideas lists comes into play. Each idea is an item and we work each week through a defined process that is reflected in the Status and Next Step columns. We define, if we need to still work on the idea until it is ready to be printed, who will design the sticker or if we will defer the idea. To determine, how much we believe in the sticker, we use 3 columns: Rating Elio, Rating Luise and Rating.

RatingElio and RatingLuise are Number Columns, with a nice rainbow-heart-effect formatting. The column expects values between 1 (not very convinced) and 5 (super convinced) and shows emoji hearts instead of a number:

{
 "$schema": "https://developer.microsoft.com/json-schemas/sp/v2/column-formatting.schema.json",
 "elmType": "div",
 "children": [
 {
 "elmType": "span",
 "txtContent": "💛",
 "style": {
 "display": "=if([$RatingElio] >= 1, 'inherit','none'"
 }
 },
 {
 "elmType": "span",
 "txtContent": "🧡",
 "style": {
 "display": "=if([$RatingElio] >= 2, 'inherit','none'"
 }
 },
 {
 "elmType": "span",
 "txtContent": "💖",
 "style": {
 "display": "=if([$RatingElio] >= 3, 'inherit','none'"
 }
 },
 {
 "elmType": "span",
 "txtContent": "💜",
 "style": {
 "display": "=if([$RatingElio] >= 4, 'inherit','none'"
 }
 },
 {
 "elmType": "span",
 "txtContent": "💙",
 "style": {
 "display": "=if([$RatingElio] >= 5, 'inherit','none'"
 }
 }
 ]
}

Rating is a calculated column and will sum up RatingElio and RatingLuise

You can find a similar sample here: conditional format

Conclusion & Feedback

I love to automate everything AND to have awesome looking lists with rainbows, unicorns and special buttons that make my life easier as I don’t need to care about all day-to-day tasks, but can focus on ideation and growing the business. I am curious for which use cases you use lists and flows?

I would love to hear from you!

#SharingIsCaring ❤

SharePoint list formatting made easy

Thu, 28 Jan 2021 01:02:52 +0000

Modern SharePoint list formatting

This article shall give you guidance and inspiration on how to turn your classic boring lists into interactive modern list experiences, which will wow your users, let them get information at first sight, and increase overall productivity. This post is not about the Microsoft 365 list templates; I will cover them in one of the next blog posts.

If you never heard anything about modern SharePoint list formatting, don’t worry; I will guide you through this.

Why would we use SharePoint lists

First things first: Why should we use SharePoint lists and not use - for instance - an Excel spreadsheet? Because we don’t need to hide information in cascading folders, that should be at the user’s fingertips. The beauty of lists lies in their simplicity and flexibility to organize work and track the information that matters most to our businesses.

Creating, sharing, and tracking lists is easy and available on any device; everyone stays in the loop, and we can use lists for all kinds of purposes like tracking issues, assets, routines, contacts, inventory, and more. Lists can easily be customized to make them visually more appealing.

How can we turn on modern experience

Now that we are teased into modern lists and libraries in SharePoint, it’s time to turn on modern experiences. We can do it like this in the classic experience:

select Library Settings or List Settings on the ribbon
select Advanced settings and select List experience
select New experience
save with Ok

How can we change the look and feel of a list in the UI

Lists can contain different columns, and each column has a certain column type, depending on the kind of value we want to store in that column like text, numbers, dates, choice, persons, locations, links, or images. As lists can contain much information, its brilliant if we emphasize crucial parts by formatting them in a way that they are

easier to read
give a grasp on what is going on
are mobile-friendly

Already built-in, we will find options to format columns and views. Formatting a view means modifying the way the entire list is displayed. Formatting a column means changing the way this particular column looks like.

Formatting Views

We can change the format view

and also display a gallery view

Formatting columns

If we want to change the column’s appearance, we can do that very end-user-friendly directly in the UI:

* and even with rules like if - then - else:

How can I apply conditional formatting, aka rules

Rules are a powerful feature to determine how a column should look like. Let’s say we want to apply a background color depending on a number value. If the number is below 30, the field should be red; between 30 and 70, it should yellow, and above 70, it should be green. Let’s see how this looks like:

How can we change the look and feel of a list with JSON

Sometimes, even if those options are already cool, we need some more flexibility.

There is a way to format both columns and views beyond what is already offered, as seen above. Perhaps you might have noticed the little link Advanced mode? This is where we will find the cool tools to play with!

This field expects you to put some JSON code in it to format this column. If you never heard about JSON, you can quickly get started with Intro to JSON by Bob German, this video, or you can learn more at w3schools.

Samples

We will browse to the Microsoft 365 PnP List formatting repository on GitHub and open the folder column samples. In here, we will find free-to-use samples to make our lists look fantastic.

Instead of having a list like this:

we can now look at a list like that:

How can we apply a sample?

Get familiar with the samples that are available on GitHub
regularly check for new ones / pin the repo
select the one that is interesting for you
read the readme.md file to know the requirements for your column. Some samples only work with choice, text, or number columns
open the JSON file
copy the code to your clipboard
go to your SharePoint list
go to column settings –> format this column
click on Advanced mode
paste the code
click Save

One more example how amazing a list can look like? I run a the PimpYourOwnDevoce.com sticker store together with Elio Struyf and we use a SharePoint list as our inventory (Elio blogged about the whole architecture here. With this sample we can hover over our images to have a big preview:

That’s it!

We will find view samples in the same GitHub repository.

Want to learn more?

You can find helpful resources to learn more here:

Have fun and happy Modern SharePoint list formatting - #SharingIsCaring ❤

PS: Did you like this post? I wrote even more about list formatting

digital clutter and how we use our time

Sun, 24 Jan 2021 14:11:36 +0000

Digital Clutter and how we use our time

Do you sometimes have that feeling of being busy and under pressure for the whole day (or even the entire week) and still couldn’t check off all tasks from your list? Do you have the presentiment that although we all focus on productivity, efficiency, and getting the most out of everything, we still scratch the surface and even get in our way with how we structure our workdays? Well, welcome to the club; you are not alone.

This is the 3rd part of my series about digital declutter - you can catch up with Part 1 Digital clutter is evil and Part 2 digital clutter and your 168 open tabs before you continue reading.

focus time & meetings

Collaboration is critical; we are better together in achieving goals, and teamwork is our reality. But sometimes, it seems as if we forget that there are not only teamwork-oriented periods but that we also need focus-time to prepare, process, and evaluate content as well as leverage ideas. How often are our days full of back-to-back meetings, how often do sessions overlap? How often do we feel that we do not even have enough time to eat, go to the restroom, get a fresh coffee? Not to mention taking a break or get some fresh air? I know, we are all swamped, our days are all tightly timed, even lunchtime needs to be productive.

But why do we attend all these meetings without taking the time to capture and condense the insights, process information, and reevaluate decisions? How intense is our commitment towards these meetings’ goals if they only consume our time, but we don’t make time to reflect on them? How do we decide if we should be part of a meeting? Because we’ve been invited to it? Because a particular process requires the attendance of the role that I incorporate? Because we noticed a lack of information flow and want to talk with a group of people synchronously? I like to apply the ‘rule of two feet’ from the Barcamp approach: If I can’t learn nor contribute in a meaningful way, I will leave (or not even accept the invite) respectfully - and no one feels upset. Why? Because my presence is not required in all meetings and a good summary sometimes is more valuable than trying to squeeze in another meeting.

These days, it sometimes feels as I was talking 8 hours straight into my webcam, which is energy-draining not only because I miss meeting people in reality but also because quickly switching contexts and needing to focus on the next bunch of people is exhausting. No time to take a moment and work through what happened in a meeting makes many meetings pointless. Good meetings add value to our work, and we can add value to other’s work. And: in good discussions, every attendee is present.

If you zone out, leave

Heard your colleagues saying: “I will mute myself because I need to work on something aside, but I still listen with one ear”? Please ask them to leave in these cases. Multitasking is an illusion, and if some participants can’t fully commit to contribute, it’s instead a waste of time than adding value in a meaningful way.

Sometimes, people zone out not on purpose; it just happens. This is a coping mechanism to deal with information overload. Meetings all day long, all week without time for ourselves result in our minds going elsewhere, which again means that we joined a meeting but are not present in the moment.

Throwing Tech solutions on people problems

Working in tech and loving all things Microsoft 365 would be easy to search for technical solutions to solve these issues. And of course, some features assist us to maintain a healthy work behavior:

notification in Microsoft Teams that the meeting will end in 5 minutes, to make everyone aware, to not go over time
setting in Outlook to end meetings a couple of minutes earlier by default so that we at least have time to grab a coffee.

the real issue

But as much as I appreciate a hot coffee, these 5 minutes in between are more cover the problem that we don’t take time to reflect on and force every colleague to come up with a workaround how to solve that instead of working on an organization-wide healthy strategy how to avoid mental overload and aim for a corporate culture in which having focus time is as important as collaboration time.

Don’t accept meetings by default

To determine if you should attend a meeting and then also commit to be present, you can ask yourself:

What’s the meeting’s purpose?
What value can you can add?
What is the most critical information you want to deliver, and what more do you like to contribute?
Do you have an essential role to play?
What exactly do you hope to learn from the call?
Which specific questions do you have?

Once you can answer these questions, even jot down your answers, you can more easily make a better decision whether to attend or to decline and still be prepared to continue collaboration. Taking time to clarify intent is a step that we should consider to do before taking action.

structure your work

The best life advice I ever became, was from the flight attendant in any plane: “Put your own oxygen mask before you help others.” Some suggestions:

No back to back meetings, schedule half an hour upfront and after a meeting to prepare/postprocess to reflect and note down which impact the content of the meeting has on your work and about which implications you need to think
Beyond that, schedule focus time. I use Cortana for that and I never postpone my focus time to squeeze in a another meeting.
Don’t read or process your emails as the first thing you do in the morning, but reserve a slot for processing mails. To enjoy my inbox zero, I follow this process
schedule your breaks. This is even more important when working from home.

If we first schedule breaks, processing time and focus time to actually get work done, and then see, if meetings fit in our calendar as well, we will establish more healthy working habits as if we want to be everywhere and block ourselves because we can’t get anything done anymore. My post on how to avoid overcommitting relates to this.

What does this mean in the context of this series to digital declutter?

Conscious decisions on how to spend our time will improve our focus and minimize distractions. It’s of course not the goal to exclude ourselves from collaboration or all meetings, but once meetings and a fragmented calendar eat up our time, we will need to find balance and ways to protect our productivity. Awareness of our goals and of which commitments will work towards them can help us to select those meetings which are important to us in the context of a shared vision with our coworkers and teammembers.

How to start and what’s next

Start to elaborate on your personal goals and the goals of your team
work out, which committments work towards these goals
go over your calendar and get rid of jour fixes and similar events, that don’t support these goals
eliminate as well meetings that are usually poorly prepared , lack of an agenda or tend to go over time

What are your strategies to feel connected and get work done? How do you plan your days, weeks, months? Or do you more have that feeling, that other plan work for you? How do you perceive that in terms of sovereignty and being in control and charge? Curious to learn what you think, please let me know.

Templatize a Collaboration Contract workshop and provision teams that organizations will love

Mon, 11 Jan 2021 21:52:40 +0000

intro

In my day to day life as a consultant, my customers need a lot of guidance on HOW to work with Microsoft Teams. After I educated them in what is Teams and everything in Microsoft 365 is interwoven, they ask:

which channels do we need?
which apps and services should we pin in our channels?
how many libraries do we need in SharePoint? And with which additional columns?
how about lists?
and buckets in Planner?
who should be a Teams Owner?

My answer, as a consultant, will always be a “it depends”. It depends on their objectives. To get them going, we would do a workshop to define their collaboration contract. In this workshop, I would provide them with knowledge about tools and working behavior in Microsoft 365 and then give them some options what to do. We would write down everything and then someone would need to not only create the team and invite the members, but also:

create channels
create additional libraries and lists
create columns
create views
pin the libraries to the teams channel they belong to
create buckets in the Planner board
pin learning resources for beginners into the channel general
pin the collaboration contract
delete the wiki tab

These workshops are very effective, as people

gain knowledge
reflect on their working behavior
are enabled to make better decisions

But those workshops are not efficient as well, as they

are time consuming
don’t scale
are expensive

Also, I got tired of asking and answering the same questions over and over again. Especially in this pandemic-driven world, which worked as an accelerator on Teams rollouts, I just got bored. And whenever I get bored to do a certain thing, I will automate it.

This blog post is about a work in progress.

solution & team up

My idea was to templatize those workshops as an app. The app should:

educate users about everything they should know to make decision that we would typically do in a collaboration contract
get user’s input on channel names, team members, metadata etc.
store all inputs in a list (SharePoint)

(You can also use a table in Dataverse for Teams or even an Excel Table (although I wouldn’t recommend it)).

To keep the app simple and adjustable I want to keep the whole logic in a flow (either Power Automate or Azure Logic Apps). For that, I teamed up with a rising star in the community, Carmen Ysewijn. Carmen is a PowerPlatform Architect working at Qubix, Belgium and I met her last year in Warsaw at a Power Platform conference. I was more than impressed by her conciseness and #learnitall mindset. Carmen will help to transition my Power Automate flow into Azure Logic Apps – she wanted to learn something new and we thought that an open source project would be a good idea to contribute to.

a simple PowerApp

Our Canvas App should be a simple interface to provide knowledge and get user’s input, which is why we will have info-screens, which will display knowledge around a certain topic, like “What are channels” and process-screens, which will ask users with a form, what they want, like private or standard channels and which apps and sites and files should already be pinned to these channels.

As this is a longer process we also want

to guide users so that they know at which point of the app they are right now
them to be able to go back and forth between screens and edit what they already put in
show them a log which input they already gave

This makes sure that users stay motivated to proceed in the app. This gif illustrates what users will experience:

For each thing, we need to have a decision, I will follow these steps:

provide knowledge
ask users in a form what they want to do
store input in variables

At the end of the whole process, I will update my SharePoint with a new item.

a complex system of flows

Now that I described the very straightforward app, it’s time to have look at the logic. For my minimal lovable ♥ product, I decided to use Power Automate, but as already said in the intro, the goal is to transition to Azure Logic Apps.

Power Automate or Azure Logic Apps?

Both systems have their pros and cons, but as much as it it easy to automate your personal work challenges in Power Automate, you shouldn’t use it for organizational, business critical processes. Power Automate flows run in the context of a user, which means that we have the same challenges with files stored in OneDrive. People get different jobroles, leave the company or simply abandon this lovely pet project (which outgrew the sideproject level by far and should have been handed over to someone who can take better care of it). Also, we have better options to have the run history of a Logic App.

Carmen had the very neat idea to split the huge flow (with 20+ API calls) into one parent flow and several child flows to make it easier for everyone to exactly pick what they need.

This is only an exerpt of the flow to give you an idea that for most of the things I wanted to do, there are no predefined actions in Power Automate (nor in Logic Apps) but that we needed to define our http calls:

HTTP request to SharePoint or Graph?

In our minimal lovable product, we use the SharePoint list item creation as a trigger and create channels, libraries, columns, views as requested by our user. I worked with both “send an HTTP request to SharePoint” actions and HTTP action towards Graph API (which I find better documented). The advantage of the HTTP request to SharePoint is, that you do not need to register an app in Azure AD, but as we need that for all calls via Graph, this is not an argument anymore.

in complex flows, follow these steps

Read the docs. Seriously.
Try out your call in Graph Explorer. In case you don’t know what this is, check out here:
Try in a test flow
if it doesn’t work, write a test protocol

Next steps & Open Source approach

Next steps to evolve from a minimal lovable product to a good solution?

Put some more work into the UI of the app
finish the Azure Logic Apps part

As we want to open source this solution, we will

export app and flows
document everything and share it on GitHub

This way, everyone can use it, share it, learn from it, and adapt it to their needs. We are open for all kind of feedback from you!

Call to action

follow Carmen Ysewijn and myself on twitter
stay tuned, and give us feedback, we highly appreciate it!
If you want to watch me explaining the solution, you can do this in episode 109 of PnPWeekly

#EverythingIsAwesome 🙂

#digitalclutter and our 168 open tabs -Part 2 of #LetItGo series

Wed, 06 Jan 2021 21:24:49 +0000

Ok, we made it to Jumanji, Part 2, Level 1. By the time I write this, it’s still early January 2021 (and this is the first time I wrote 2021 ), and I promised to write a series about how to declutter your life and work digitally. This is the second part; if you need to catch up on WHY we keep digital stuff and why it is so difficult (but also most rewarding) to let digital things go, you can read the first part here: https://m365princess.com/digital-clutter-is-evil/

This part is about the tabs in your browser. A lot of our work these days takes place on websites, which means that we live in our browsers and open tabs over tabs to research, procrastinate, get work done, distract ourselves, contact information, log into different platforms, search for stuff we searched already 96 times before and so on. This results in *SOME* open tabs.

Ok, but what does it matter?

Why should we care if we have 4 or 40 tabs open? Because whatever is open, unresolved, undecided, pending or active, keeps our minds busy. It increases our mental load and sets us under stress, even if we are not aware of it. If we deal with overload for a more extended period, we perceive it as overwhelming as our normality, which means that we drive with the handbrake.

Don’t we all

rely on all these open tabs?
buy decent machines with a tremendous amount of RAM so that they don’t overheat?
love those posts about mental health and letting go and digital detox?

Oh right, the latter was just about me 🙂 Let’s have a look into this working habit of having A LOT of tabs open. Some categories would help us first see what they are to determine if we need them, harm us, or only a better solution to achieve the same goal. In my day-to-day life as a consultant, I never focus on tools but use cases. Let’s try this approach here as well:

tabs we have open while blogging/research

When I researched for and wrote this blog post, I had these tabs open:

my website m365princess.com, to be able to refer to older blog posts in this blog post easily
GitHub, as I write my posts in GitHub these days
Twitter (to be able to make a poll and search what others already said about ‘too many tabs open’ )
one other tab to do research, like searching for the right image or a quote or googling a fact I can’t remember anymore.

It turns out that I always use this set of tabs when I write a blog post.

tabs we have open to learn

Well, learning, of course, is a good thing. When I learn, I open

the content site (YouTube, MSLearn, Pluralsight, etc. )
a website to try out what I learn (Power Platform, Graph Explorer, Azure Portal)
Twitter to quickly ask questions or express my moments
one other tab to research, like googling when I don’t know a specific thing that seems to be mandatory to understand the tutorial I am following

tabs we have open for bug fixing

I think this tweet explains everything I could write in a whole paragraph.

tabs we have open because we stumbled upon them and might need them later

Well, we are now entering the *just in case* phase. While we were browsing, researching, and looking for inspiration, we found a site that would be helpful- later. We can’t take advantage of it right now (because we need to focus on that other thing we need to get done eventually, but perhaps, in the future, we will get back to that site). We keep it, just in case. Do we recognize that this is the same thing as keeping other digital stuff? Do we realize that even keeping this tab open will keep at least a part of your mind busy? These open tabs distract us, similar to people interrupting our focus work. Does this sound familiar to you?

I get it; we want to keep this URL, but we do not necessarily have this tab open.

But what would be a better solution?

Before we can throw tech solutions on people problems, let’s investigate what happens:

Event: On top, there is the event that is visible to us and attentive to others. In our case: We deal with a tremendous mental load and are easily distracted
Pattern and trends: underneath the visible event, we could look into the patterns and trends that lead to these events. Here that would be: the more different workloads I need to manage, the more overwhelmed I am
System that supports these patterns: Let’s now have a look into the system: We need to react quickly to whatever happens, and this reactive working mode puts us in a kind of emergency/attention position which also causes stress and leads to more ineffective work styles
What is the common belief that holds this system in place: If we now dive deeper into our beliefs, we will conclude that although we are praying that “always-on” is not a solution, that mental health is essential, that it is crucial to set boundaries and that you should have your focus work time actually to get stuff done, we merely don’t act like that. We reply on emails and messages almost immediately, we have all websites always open to quickly jump to other tasks and put tremendous pressure on us with that. But: _Busy ain’t productive!_

If we now consciously think about how we want to work (and let’s assume we want more “productive” and less “busy”), we will have some principles:

we will only have a few priorities
we will distinguish between our different hats/workloads/use cases
we will not try to multitask nor to quickly task-switch
we will be conscious about our commitments so that we can still handle our workload

If we now only have a few priorities, we will be more easily able to let stuff go, or in this case: close a tab, even if it MIGHT be a useful resource for later. We will learn to focus on the essential things.

We will use smart tech to group the tabs that we need for the different workloads, which will also prevent us from multitasking:

I work with Microsoft Edge browser, and I love collections. If you don’t know what a group is, here is the quick intro: A collection is a set of websites that can be opened in different browser windows.

Once you are done with a workload represented by this collection, you close the whole window. When I need to explain collections on a non-technical level, I always say: These are desks with all the working material you need to accomplish a specific task or group of tasks (similar to a Microsoft Teams channel). I have many collections, but for the sake of an example: one is a collection for managing the sticker-store, that I run together with Elio Struyf.

newsletter tool
SharePoint site
order management tool
shop itself
social media tool

Why I organize my workloads in collections? So that I can consciously decide which kind of task I want to spend time on instead of chaotically jump from task to task and from tab to tab. The consciousness is the crucial part of that. I work with Microsoft To Do for my personal task management, and I commit each morning to just a few tasks. During the day, I will only open those tabs (organized in collections) to accomplish the task. Whenever I randomly open other sites, I can be sure that I am procrastinating what I should do right now and take a break.

Two more cool things about Edge collections: They are stored in the user profile and sync – when you are logged in – across your devices. If you now combine this with the multiple profiles feature you will turn your browser into a focus-machine! As a consultant, I work in different tenants of my customers and profiles make it easy for me to switch between them. When I now sync the collections in my profiles to my phone or second laptop, I can really work seamlessly.

When I stumble upon a site that MIGHT be interesting, I put it into a collection “review” and I have a weekly task on reviewing that collection. Nothing is allowed to stay there: either the site becomes a valuable content resource – then I will store it in another collection, or I can let it go. This ensures, that I don’t hoard websites just because I can.

Conclusion & What’s next

There is no short tour to let stuff go, but we can use tech to stay focused, prioritize easier and be productive instead of just busy. I would love to hear how you manage your tabs and thought and digital clutter. As this is part 2 of a series about digital clutter, please stay tuned for the next part!

Let it go – digital clutter

Sun, 27 Dec 2020 18:18:03 +0000

Apart from dresses and shoes, I don’t like to own much stuff; I prefer to have only things that relate to who I am as a person, and I can easily detach emotionally and get rid of things.

Reading and watching Fight Club was one of my eye-openers here, and I can never forget the very famous quote:

The things you own end up owning you

By no means am I a minimalist; I don’t count my things, nor do I raise the question, if a pair of socks is 1 or 2 items or if a complete drumset is 1 or 21 or 68 items. I do not find value in those discussions. But I think it’s worth investigating the impact of things in my life. And when I do so, I realize that apart from the things I have and heavily use, there is also clutter, AKA stuff.

What is stuff?

Stuff is every item that you keep for the sake of having it. Perhaps it served a purpose when you bought it, found it, or when someone gave it to you, but now you don’t have any use for it any more than just owning it. Some examples?

the ugly mug that was a present from a college friend – you keep it because it reminds you of that friend. Last contact? 14 years ago.
the nice mug that doesn’t fit all your other mugs, and you stopped drinking coffee – last use of that mug? Well, you first needed to dust it off…
the books you bought that only serve as a credibility bookcase for your Zoom calls

This list could be a lot longer, but I will leave it by that as I think you got the idea of what I am talking about.

negative impact of hoarding

Technically, we know that clutter isn’t good for us. Clutter, both analog and digital, keeps our space, money, energy, and focus. It draws our attention from the things we want to DO to the things we HAVE. While a bit more space makes up room for new experiences and where we want to grow, a full space makes change and growth impossible as all areas are already occupied. Clutter shifts our drive from acting and growing to having and hoarding. And this represents living in the past or unrealistic mental images of yourself:

You own a lot of sports gear but don’t exercise with them regularly? Then you just fell in love with the idea of being a sporty person, but you aren’t sporty.
You have a whole collection of musical instruments but never play them? Then it is more your idea of being a musician that you like to become a reality than it represents who you are.
Is your bookshelf full of books you never read? Well, still a great scene for your virtual meetings, but other than that: You fill up space in your surroundings to fill the void inside of you.

As clutter takes much space, there is less space for the things you love, which truly represents who you are. Why do we give things that don’t relate to our lives so much room?

Why do we keep everything?

Just in case. In case of what? In case we need it.

Although most of us grew up in the great luck of not having to experience any deficiency or lack of things they desperately needed; still we were raised with some beliefs, like ‘keeping stuff even for unlikely events is a good thing.’ We even have dedicated rooms in our houses for ‘stuff that we don’t regularly use’ like attics and basements. Storage room seems to be a significant advantage, even bigger than having room for yourself. All this represents your past, which you still want to hold in your hands. I am not talking about precious memories like family photos or practical things you need and use a few times a year (like a waffle maker or a drill). I am talking about the stuff we keep because something in us isn’t ready to let it go: We keep stuff:

for ourselves (in case I ever fit again into that jeans from 1992) –> represents an unrealistic mental image of yourself and shows that you didn’t let go of what’s already past
for others (these baby clothes will someday be for a kid in my extended family) –> projection
when we can’t admit that we failed in doing something (in case I restart to play chess which I lastly did in 1992 (you know, when that jeans fit))
to remind ourselves that we didn’t always suck but also achieved some cool things (keeping that trophy of the 3rd place at the Junior District Championships)
because we fear deficiency
to impress others (bookshelf/zoom calls)
to impress ourselves (mostly related to things we would like to do but don’t execute)

And yet again, a Fight Club quote comes to my mind: We buy things we don’t need with money. We don’t have to impress people we don’t like.

You will probably say: But I don’t care about the stuff in the basement, about the things I keep for others, or about the 691 little things in drawers (your cable box? your lonely socks? your old phones?). Then I need to tell you that

you just learned to ignore stuff, but it still impacts you whether you like to admit this or not
whatever you ignore will somewhen return and miscue you, so it’s better if you care.

the perverted approach

Our idea is no longer ‘having something to do something with it,’ but ‘having something until it bothers me so much that I need to get rid of it.’ And we do a lot not to get bothered. We buy new shelves, new drawers. And then we buy decorations because the new stand looks so empty. And then we buy another rack, because all the decoration doesn’t fit anymore. And then we move into a bigger house. And we need a bigger basement, because of the stuff we need to outsource, and then we rent a storage room outside of the city… Or we build a carport, so that more stuff fits into the garage after the car moved out of it. Even if you didn’t need to buy new stuff to give other stuff a place to be, you would see that stuff seeks your time and attention. Every item needs a place to belong to (or you will be busy putting it from left to right and from right to left again), and it needs to be cleaned and maintained. Having a thing is always a commitment. Before I buy something, I do not only think if I can afford this, but how much time it will take me to act according to its purpose. Buying a book is easy, but how likely will I spend 10-20 hours in the next three months on reading it?

digital stuff

This brings me to some thoughts about stuff that doesn’t take much physical space but still increases our mental load. Enrolling a new course to learn something? Wow, it’s free. CLICK HERE. Yes, subscribe to the newsletter. How likely is it that I will not only not read this newsletter but also defer unsubscribing from it? How often will this draw my attention while it’s already hard for me to stay focused? How likely will I not just watch the intro of the new course? And how probably will this book, course, podcast end up in that pile of guilt? There are more examples:

the app you never use
the accounts that announce their blog posts on Twitter, I do not remember you finding time to read
your 42 open tabs (but!)
16 variations of the same photo
your email trashbin
chats with your ex
abandoned side projects

How do we declutter

This shouldn’t be a full list of where you can find clutter on your phone or computer. But once you are aware of WHY you unhealthily keep stuff, you will more easily recognize where you waste space and focus. Apart from the examples that I already gave you, it could be that

– you still have a lot of Bluetooth devices in the list that you don’t use anymore,
– you follow too many accounts on social media to follow what they post,
– you have contacts in your contact list you don’t even know who that is

You will find many how-to blog posts once you start to google ‘digital clutter’, but the key is to understand what triggers you to collect more and why it is hard to let things go: I am on my phone a lot. Some would say that I have a deep relationship with it. If you are a little like me, you will merely not use it as a phone, but as a remote control for your whole life (and with a remote control for the remote control aka Apple Watch. We quickly have 100+ apps installed, and because we need to record 4k video, have thousands of songs on our phones, and hoard all kinds of other data, we need phones with an insane storage capacity. And now that we have that capacity, we hoard even more. And then we pay cloud services to outsource apps and files… Do you recognize a pattern? We repeat the behavior we show in our analog lives in our digital lives. So would it help if we asked ourselves why we keep the digital stuff? Why do we not delete chats of people we are not in contact with anymore? Why do we still maintain that domain we once registered but then never worked on it again? Same reasons as you keep physical stuff: JUST. IN. CASE.

Not that this case will EVER occur, though.

What happens once we dig a little bit deeper into what triggers us to keep and hoard? We will gain clarity about what drives us- and what holds us (back). Because, if we own everything, our hands aren’t free, we can’t hand-le anything anymore, literally. The perfidy of digital clutter is, though, that we can more easily hide it. But once we know if we want to impress ourselves, still live in the past, or want to produce a specific image of ourselves, it’s easier to get rid of that, be honest, and truthful with ourselves. It’s relieving to toss stuff that weighed a lot. And once you did, you feel alleviated and calmed.

Where do I start?

Well, I am a consultant, so the answer needs to be It depends. Here are some tips:

Don’t just organize apps on your phone in groups.
Ask yourself, which value an app, a contact, a chat, a connection still offers you. And if this is about lost hopes or reality.
What’s the worst-case scenario if you delete something?
this blog post is the first of a small series of posts around digital clutter. Read next week, how I tame my alerts and notifications

Feedback & What’s next

If you liked this post, leave a comment and tell me what resonated the most to you. How do you deal with digital clutter? Does it bother you? Do you have the feeling that stuff consumes too much of your attention? T I would love to hear your feedback.

my 2020 or jumping into the next rabbit hole

Mon, 21 Dec 2020 16:24:11 +0000

2020-WHAT. A. YEAR.

This was a special one for me, like for so many of us. When we were still traveling and making big plans in the first weeks of 2020, no one had a clue that we all would be sitting at home (office) for most of the time and struggle not to meet people nor see other places. But as this is a recap of my year 2020, I won’t focus on the pandemic side of events but on how I perceived this year. If you want to catch up first with #2019recap, you can do this here: 2019 or how I started to believe in myself

I run my own one-woman-army and offer Microsoft 365 consultancy. In the last years, I used to say that I do the ‘non-technical’ part of a project, focusing on adoption and communications and making excuses for my non-traditional background. I stopped doing this, and I developed my perception of myself and grew into a different role. This happened not by coincidence, but because I was focusing on some topics. As this will take some time to tell, you should grab a coffee; I will wait here.

How it all started

Got a coffee or a drink? Cool, let’s continue. Everything started in this pandemic- and lockdown situation. Remember when I was giving away stickers and send them around the world in 2019? That was a huge success, and I quickly needed to develop an excellent solution to handle and automate it. I used Power Automate to make the process of printing envelopes easier and faster. During the early phase of Covid19 lockdown, I teamed up with Elio Struyf and together we founded our startup pimpyourowndevice.com which is an online sticker shop. Both of us were designing and sharing stickers before, and it seemed to be a logical step. As both of us wanted to learn from each other and explore what we could do with our skills, we did not go with a standard approach of having a decent out-of-the-box solution to run a store but developed our way to handle things. We both love to tell our #BetterTogether story- me as a maker, he as a developer. You can read more about how we run this business in Elio’s blog.

FusionDev & developing my maker skills

As I now had a real-world project with real products, real customers, and real issues, I wanted to step up my Power Platform game. I’ve already been quite familiar with Power Automate, gave many sessions at conferences, blogged about it, and of course, enabled my customers to simplify their processes as well. I also used Power Virtual Agents in some cool solutions; you can watch one of them in this video: Power up Teams with Power Virtual Agent with Luise Freese | #LessCodeMorePower | Channel 9 (msdn.com)

But for some reason, I did not have any experience with Power Apps. Time to change that. I released my very first Canvas App on 2020-05-04 (the Star Wars nerds will get it ). It was an app to help kids practice calculating; you can read more about it here: [May the force be with me). This app was somehow a breakthrough for me, as I learned to make apps in Power Apps and needed to find a way to make a math app while I have dyscalculia. If you are not familiar with that term, dyscalculia is a learning disorder, like dyslexia. People with dyscalculia struggle with maths and numbers in general. I use to explain it like that:

*Every time I see a math problem, it looks like this:*

*”If I have 10 ice cubes and you have 11 apples, how many pancakes will fit on the roof?*
*Answer? Purple. Because aliens don’t wear hats.”*

Sounds perhaps a Lil funny, but in fact, it affects me every single day- So I chose my ‘end of the level baddie’ to make an app. I did not only learn how to use the different controls and how to low-code, but also took all my knowledge from consulting clients (understanding the problem that needs to be solved, envisioning a solution, building a ‘minimal lovable product’ and adapt it again and again after reviews) into my app making process.

This led to more and more apps and sessions, where I explained how to get started with Power Apps. The fact that I got quite some visibility and exposure led to customers asking for Power Apps development and empowerment. And while I designed training and workshops for them, I learned different approaches to solve problems and explain everything so that it made sense to different target audiences. Some of my workshop attendees are end-users, some of them are experienced citizen developers who were not familiar with Power Platform but already built solutions on other platforms, some of them are web developers looking into faster ways to achieve their goals, and some of them were looking for a more institutionalized way to solve issues in their organization. As I learned in my startup, that #FusionDev, the mixed team of makers and traditional developers, is beneficial for a project, I could show and tell first hand how makers and developers could team up to achieve more together.

As a result, I successfully shifted my own business from being a business consultant in Microsoft 365 universe to a more technical role as a Low Code developer and consultant. How did it happen that fast? Because I enjoy growth and problem-solving. When I want to learn something, I immerse myself in that topic. I follow hashtags and people on Twitter, watch YouTube videos, read blog posts, and of course, tell anyone that I want to learn that thing. And then, I start exploring and building—basically, I #DoTheThing -thanks Dona!

Microsoft Graph & Dev Community

I knew this from my Power Automate journey in the previous year – if I wanted to do cool stuff, I needed to use Microsoft Graph. In 2020, this did not only mean extending my knowledge of using the Graph API in my Power Platform solutions but also learning about Microsoft Graph Toolkit (MGT). I blogged a whole [series about my experiences as a non-traditional developer with MGT and had quite some AHA! Moments when I realized that there is so much more for Low Coders like me beyond Power Platform and that people spend too much energy distinguishing between makers and developers instead of looking deeper into what unites us and how we could benefit from each other.

After I started blogging about MGT, I got invited to the team of the fantastic group of people that ran the Lap around Microsoft Graph Toolkit. And I learned some things that would be very important to me:

DevCommunity is a fantastic place to be, and everyone nicely ‘adopted’ me while I love to advocate for this #BetterTogether
My not-code-centric perspective was helpful for others and helped them gain a different angle
I extended again and again my comfort zone and decided to never return to it anymore. Growth, to me, means keeping on boldly going.

One way to learn were the 3 Microsoft 365 Developer Bootcamps that I attended under, let’s say, ‘special conditions’:

* 1* at my hairdresser’s, with tin foil in my hair while coding

* 1* at my nail artist’s – working temporarily handicapped, as I only could use one hand

* 1* at 4 am after my own ‘in-Lockdown-Birthday-party.’

I like to tell this because it shows that I can gain skills and grow but still stay the same multidimensional person – who loves to joyfully jump into the rabbit hole and enjoys life (even in a pandemic).

Microsoft 365 PnP

After I’ve been a guest in PnP Weekly ep. 71 I started to join Microsoft 365 PnP calls because I loved to gain more knowledge about low-code and coded solutions in Microsoft 365. Later, I participated in the SharingIsCaring initiative. My friends David Warner and Hugo Bernier let me tame this GitHub monster for me so that I am not scared anymore. As a result, I became a contributor to Microsoft 365 Community Docs which happens to take place in GitHub. 4 weeks ago, I had the great honor to become a member of the Microsoft 365 PnP core team – My mission is to emphasize that we can achieve more together. I will be taking the lead of initiatives to make this community a virtual home for everyone who wants to extend Microsoft 365 regardless of technical background.

Mental health and clarity

Like most of us, I struggled with being at home a lot, and I established some bad habits. After I finished my ‘work work’ (this is how I call my billable hours), I started to do ‘work’ ( this is how I call community work, such as writing blogs, preparing sessions, recording podcasts, etc.). I worked crazy hours at night, didn’t take breaks, and was just happy to be busy enough not to feel alone. This led to overcommitment, which was grounded in a false belief that ‘more is better’. You can read more about it in my last blog post about How to avoid overcommitting I solved that not by ‘learning to say no’ but by taking a more in-depth look into the root of the cause. When I wrote my list of contributions in this blog post’s preparations, I got slightly shocked. In total, I

attended 13 events
delivered 39 sessions at virtual events
wrote 22 blog posts
co-organized 4 conferences

all while living 24/7 on Twitter 🙂

I was shocked, because I did not imagine this amount of contributions, but when I reflected this thought with two close friends, they were not surprised at all – which means that my perception and how others perceive me don’t match.

It took me a whole afternoon to make this list, and yes, I know, I should update my list after every contribution. But as this simple thing so far didn’t ‘just happen,’ I asked myself why I refused to update a list. As I was already working on understanding what drives me, I took some time investigating that. When I felt #comfortablynumb with being busy, I tried to avoid clarity about what I was already doing regarding community work – and a list would have led to clarification. Now that I regained control and overview of all initiatives that I am running, I have an intrinsic interest in knowing what I do and succeed. So I will update my list of contributions and take time to reflect on what I learned (about tech, community, and myself).

Sounds like a plan – read in my #2021recap how this turned out.

Please #staySafe, hope to meet you in 2021!

How to avoid overcommitting

Thu, 10 Dec 2020 21:46:54 +0000

Intro

Besides my work as an independent consultant and low code developer, I do a lot of community work. I am an active Microsoft MVP, new member of the PnP team, run a blog, am a speaker at conferences, live on Twitter, record podcasts, draw sketchnotes, mentor fellow members of the community and support many initiatives that make tech a welcoming and inclusive space for everyone.

For my (paid) day-to-day job, I exactly know how much time I will spend on work with my customers. I have my due dates and deadlines, organize everything very clearly, and if I see, that I won’t be able to do something in the requested time, I will tell my customer upfront—everything under control.

This does not apply to my community work. Someone will ask me to work together on something, and because I am interested in many things AND get distracted easily, I can lose my focus. This leads to saying ‘yes’ way too often, losing track, and having that feeling of juggling too much at the same time, I found myself drowning in my community activities.

Impact

Overpromising leads to bad quality of results, because you need to work through things in a rush or it damages your reputation because you do not meet the expectations of others. You will also most likely blame yourself and feel bad about it which could lead to a vicious circle of feeling guilty, trying to compensate that with the next commitment and not achieving what you had in mind in the first place. And then you feel bad about feeling guilty. Sigh. We all joke about abandoned side projects and domains we would never put into use, there are even websites on which you can trade abandoned side projects-but in reality, this is just the tip of the iceberg of overcommitment.

Source: https://twitter.com/ThePracticalDev/status/792730113158868993

The core of the problem

So what is overcommitting?

To prepare for this blog post, I googled a bit, and I found two fascinating definitions: Of course, the Merriam-Webster Dictionary gives us an obvious explanation of what is overcommitment, and I will refer to that in this post: obligating yourself beyond the ability of fulfilment.

Source: https://www.merriam-webster.com/dictionary/overcommit>

But as I work in tech, ‘Memory overcommitment’ came to my mind as well: It is a concept that allows a virtual machine to use more memory space than the physical host has available. And this made me think: ‘Do we try to act like VMs, which can just use MORE memory space than it has allocated?’ If you still read this, then chances are high, that you will answer this question with a ‘yes’.

Source: Memory overcommitment – Wikipedia

Although we know that we only have limited capacity to work on things, process information and focus to on spend on, we try to behave like machines to make still it happen. We cut on sleep, to even make it work, which won’t lead to a better outcome. We lose overview about the things we want to do, or we promised to do. And if we suffer too much, we will question ourselves, why we cause so much stress and what we could do about that. And then we read something like ‘learn to say “no”‘. But that is easier said than done, because it is only curing the symptoms, but doesn’t go to the root of the cause.

Systemic thinking.

If we approach that with systematic thinking, we can have a more in-depth look on that: We will be able to see several levels

React

we only focus on the events, that happen, like ‘I am catching a cold’ or even ‘I feel stressed’. This top-level is visible to us and noticeable to others very quickly. It is how we react to circumstances and decisions.

Anticipate

The layer underneath those events would be anticipating and reviewing patterns and trends, like ‘I’ve been catching a cold more often when sleeping less’ or ‘I felt more often stressed when I lost the overview of what I already committed to’. We now make a guess, that if we sleep less, this will lead to getting sick more likely, we anticipate, that no overview will result in stress.

Design

If we still want to go a level deeper, we will seek the underlying structures of the patterns we identified in the last level like ‘what has influenced the patterns?’ And ‘how are the patterns interwoven’, ‘what does their relationship look like?’. In our cases, this could lead to considerations like ‘more stress, lack of healthy food, challenging times led to a lack of sleep which resulted in catching colds more easily’ and ‘saying automatically “yes” to all kinds of community activity without checking your availability, mental load and capacity or even energy and focus on achieving things, will make you feel stressed more likely’.

Transform

Our final level will be the mental models that sit underneath and support the structures described in level 3. Which assumptions, beliefs and values do people hold to keep this system in place where you feel forced to behave in a certain way? In our examples, it would be ‘career is the most important thing, even a higher priority than getting enough sleep to stay healthy’ and ‘the more you contribute (and not say ‘no’ to an opportunity), the more you are valuable to the community’.

How does the model now work in our case?

The mental model of ‘the more you contribute, the more valuable you are’ (intensified by the fear of losing your MVP status or losing credibility as a leader) will lead to feel a constant pressure of creating content, getting involved and seeking for opportunities. And although we all love to do community work and strongly believe in the sharing is caring statement, chances are high, that we at some point overcommit. And as you are STILL reading this article, it’s very likely, that you found yourself overcommitting as well.

Approaches to solve this

If we only work on the first (few) levels, we are just scratching the surface, which means that we won’t sustainably solve. Of course we could cure some symptoms like ‘taking some more vitamins against catching a cold’ or ‘booking a massage against feeling stressed’, but this isn’t a solution as it doesn’t work sustainably. We will very likely still catch colds because of a lack of sleep or feel stressed because of unhealthy working ethics.

Learning to say no?

If you strongly believe in ‘the more you do, the more value you add’, you will not learn to say ‘no’. Of course, you will neglect some asks after you decided to ‘learn to say “no”‘, but very soon you will return to your old patterns – because you didn’t change the mental model. And yes, it is tempting to fulfil asks – because it means, you count. And your work is valuable. YOU have been asked.

Food for thought

Let’s reverse the model that led to unhealthy community work ethics:

Mental model

What if ‘less is more’ is true in this case? What if focusing on some things rather than trying to be everywhere would be the key for you? Think again about what you wanted to achieve with community work: being recognized for helping others? In that case, specialization and scaling could be a good idea:

Structure

Sharpen your profile to be the expert and master of a few things instead of being the Jack of all Trades. This will also condense your brand and will lead to let you work in the community on your sweet spot. You will still have more than enough opportunity to grow and extend your comfort zone.

Trends and patterns

If you change your mind towards the Marie Kondo method ‘If it doesn’t spark joy, toss it’, you will surely adapt to be more selective of your commitments and be more likely only to commit if you mean it because you analyzed impact, costs and investments.

Events

This will lead to you not overcommitting again, because you solved the issue at its root and didn’t just care about a symptoms.

But what if you now know about the impact of your mental model but still need to deal with your previous choices? How can we gain control over our own desire to be recognized as a helpful leader?

Visualization

A good starting point to regain control and to be aware of what you already committed to, and which activities depend on other activities and how everything is interwoven would be visualizing everything. You could make a list; I chose to put all my commitments (the things I promised and the things I want to do, all my rough ideas, that I want to elaborate on) in a Microsoft Planner board. The tool itself doesn’t matter, make sure that you make everything visible. Collecting everything from different lists, conversations, notebooks, whiteboards etc. could take some time, but it is worth it. When I did that, I felt a bit scared, how much was going on in my mind (and task lists) and how heavy my mental load was.

Clarify Impact

Now that you pulled out everything, it’s a good time to think about the impact each task (in my case, it was a card) has. Determine the effect of DOING the thing and of NOT doing it for you and community. What happens community-wise, if you don’t write THAT blogpost? If you don’t participate in THAT tweet jam or if you won’t co-organize THAT conference? Probably, you will allow someone else to do it. Now think about what happens to you, if you skip that task: Will you still be a valuable member of the community? Of course? Will you improve because of caring for yourself and better mental health? Sure!

Pick one thing that is very close to your heart

As we do not only make reasonable decisions, but are of course emotionally involved, it is now a good idea to pick one thing, that you are passionate about. This is your ‘feel good commitment’.

Estimate your costs

Try to estimate now, how much time you need to invest for each commitment and compare the desired outcome (support others, solidifying your knowledge, proving you are a valuable member of community/thought leader) with the actual impact of not doing it and the time you will need to spend on it.

make decisions

Little impact but colossal investment? Please don’t do it. Conflicts with your values of family, self-care, being thoughtful, inclusive etc.? Please don’t do it.

Better choices

To make better decisions for the future, I collected some things that I started to do, which could be helpful for you as well:

Everything needs to be on the board of commitments

Have your list/board/visualization at hand. Whenever you get asked ‘can you do x’ or ‘would you like to collaborate with me on y’ and even if you think ‘I should blog/vlog about z’, have a look on your board of commitments and oblige yourself to put everything on it. Sometimes, already this will lead to saying ‘no’ or putting that on your backlog. But watch out that your backlog doesn’t grow to a pile of guilt.

No last minutes

Don’t commit to last-minute duties. Consider to check your calendar. If it looks like this, don’t do it!

Source: https://twitter.com/DugarToGo/status/1333676357512028163?s=20

Don’t say yes immediately, think about: costs, impact and consequences, if you don’t do it. Then decide without pressure. This will even sound reasonable, if you tell: ‘I feel honoured /flattered/appreciated to be asked, but I first want to consider, if I can deliver that in a given quality without getting into trouble. I will get back to you on Monday.’

Even small commitments add up!

Even if you think, that a commitment is just a tiny thing: Consider your mental load and that you can focus only on a few things.

Follow the process

Make it easier to follow your process of balancing mental load and commitments than working around it. Have your board/list at hand and write down everything. Also put your estimated time investment plus impact on the card/into the list and separate ‘having an idea’ or ‘being invited to collaborate on an idea’ from ‘deciding actually to do that and commit to it’. Once you committed, think about a due date. Check your calendar and block the time dedicated to this thing. If you don’t find a free slot, (not extending your working hours to work nightshifts, too) consider to do it later (change the due date) or not at all. Then put the card into your backlog (if it is still a good idea for you) or sponsor someone else in the community with a good idea. #SharingIsCaring

Feedback and what’s next?

What do you think? What helped you to be aware of overcommitting and how did you stop to do that? Would love to host a panel discussion around that – what’s on your mind?

Announcement: Luise is now member of PnP Core Team

Tue, 01 Dec 2020 18:06:59 +0000

Absolutely thrilled to announce that as of last week, I joined the Microsoft 365 PnP Core Team as a member and will help to expand Microsoft 365 PnP to be truly inclusive for everyone. I will be leading initiatives to make this community become a virtual home for everyone who wants to build something on Microsoft 365 regardless of technical background, or toolset they use. Rather than distinguishing different approaches to reach the same goal or separating people from each other, I aim to unite people no matter which kind of service, app, automation, or extension they want to build. I want to break down siloes, which will lead to better connectiveness, understanding and also improved solutions.

My mission is to emphasize that we can achieve more together and that we all belong to this community, where everyone supports and cares for everyone. This community helped me so much on my way and I love to give back as well.

I could not feel more blessed to be part of an awesome team, in which everyone strongly believes in spreading the word for the #sharingiscaring movement.

I will use our new hashtag #m365pnp for Microsoft 365 PnP Community related tweets and would love if you join me! Not sure what is Microsoft 365 PnP? Start here: PnP | Microsoft 365

How to deploy Microsoft Teams app templates in your tenant

Wed, 28 Oct 2020 18:39:51 +0000

This blog post shall guide you through the process of App deployments with Microsoft Teams App templates.

Microsoft Teams is an excellent hub for collaboration, and the most fantastic thing about it is its extensibility. Custom development can close some gaps between out of the box features and specific business needs. But we do not always need to reinvent the wheel completely. You can find amazing ready-to-deploy app-templates. Of course, as a developer, you may want to tweak those templates, but they are ready to use in production and, of course, great to understand how deployment works in Azure.

https://m365princess.com/wp-content/uploads/2020/10/Step2DeployTemplate.mp4

⚡ Please don’t test in your production environment. If you are new to this, get a free Microsoft 365 developer tenant, it’s way safer for you.

As an example, I will use the Groups Activity App to show the steps that we usually need to do to deploy an app in our tenant.

You can get the complete documentation, including all files, deployment guides, and architecture overview on GitHub. In this article, I will make you aware of some essential steps, which you might forget or give you some context.

Register an App in Azure AD

First, you will need to register an Application in Azure AD, create an app secret and enable GRAPH API permissions.

Remember to save your App secret immediately after creating it – you won’t be able to read or copy it as soon as you click on something else in Azure Portal.
To know which permissions you need, read the documentation of the app template.
Don’t forget to grant admin consent for the permissions

https://m365princess.com/wp-content/uploads/2020/10/Step1RegisterApp.mp4

Deploy template

As we deal with One-Click-Deployment, you will need to click that magic deploy to Azure button in the deployment guide and

create a new resource group
paste Tenant ID, AppID, App Secret into the form,
be a little bit patient. It can take a while. You don’t need to stay on that site. You can check later on as well.

https://m365princess.com/wp-content/uploads/2020/10/Step2DeployTemplate.mp4

Add authentication

Azure AD can easily manage authentication, connect our bot with it, and set the scope as in our app registration.

https://m365princess.com/wp-content/uploads/2020/10/Step4AddAuthentication2.mp4

Package App

Now it’s already time to create our App package. For this, we will need the manifest.json file and two .png files as App icons which we will find in the GitHub repo.

In the manifest.json we will replace placeholders for

developer name,
URLs for
- site,
- privacy,
- terms of use,
BOT ID (our App ID),
validDomains –> [BaseResourceName].azurewebsites.net,

and zip this manifest.json with outline.png and color.png from GitHub repo in a GroupActivities.zip file.

⚡ Watch out, sometimes the outline.png provided on GitHub are not transparent, and then your app won’t pass App validation. If this is the case for you, make it transparent, add it again to your .zip file.

https://m365princess.com/wp-content/uploads/2020/10/Step5Package.mp4

Publish

The easiest way to publish your app is via Microsoft Teams App Studio – but you can also do it with Visual Studio Code Teams Toolkit.

If you choose App Studio, upload your .zip file and select publish and then app catalog.

If you choose Teams Toolkit, you can see potential error even before trying to publish, and the error/warning notifications give you more detail about what was wrong, while App Studio just returns a ‘Something went wrong.’

Time for a happy dance!

https://m365princess.com/wp-content/uploads/2020/10/Step6Publish2.mp4

M365 Developer Bootcamp

Mon, 19 Oct 2020 18:35:41 +0000

Being volunTOLD

Early October, I saw an announcement on twitter regarding #M365Bootcamp, a global virtual event, consisting of 2 different labs to build solutions with Microsoft Graph, Teams, SharePoint, held in 3 different timezones across 2 days.

My dear friend Dona Sarkar assigns homework to nearly everyone and I got volunTOLD to build more. Encouraged by Waldek Mastykarz to join and trust that the labs will be doable and that there is also support available, I registered for both Bootcamps, and this was literally me jumping into the rabbit hole.

a fantastic experience

After registration, I got a confirmation email and another email as well with a new account, as these Bootcamps are held in a special tenant from Microsoft for those community events. You become a member in that Microsoft Teams team, which gives you more permission as if you were joining as a guest. I attended both Bootcamps in EMEA timezone and they were both incredibly well organized and executed. Bob German (Lab No. 1: “Build an Emergency Response solution with Teams and SharePoint”) and Ayca Bas (Lab No. 2: “Build “One Productivity Hub” using Microsoft Teams and Microsoft Graph Toolkit”) did amazing jobs as they:

designed real-world scenarios, completely doable for all developers regardless of their previous experience or level of expertise
provided excellent material on GitHub: detailed, bias-free, accessible and inclusive for every developer
explained the overall architecture of the solution we wanted to build
contextualized the solutions to developers new to the Microsoft 365 ecosystem without overwhelming them
gave enough room for an awesome group of proctors who helped answering questions and keeping motivation high
made this whole bootcamp a very interactive hands-on experience

As everything was prepared, documented and structured in a way, that we learnt and built bite-sized, it felt as easy as building something with LEGO bricks- while it was still tricky enough to do it right, but fun enough to stay motivated. It was the kind of work you LOVE to do: You are neither underwhelmed nor overwhelmed, you immerse yourself into a challenge and totally don’t realize how time flies, while you are surrounded by like-minded #LearnItAlls.

Bobs’ and Aycas’ investment to prepare everything really paid off, because it meant that they (and of course Microsoft Graph) already did the heavy lifting for us. They also provided an atmosphere that all questions are welcome and valid feedback.

Build an Emergency Response solution with Teams and SharePoint with Bob German

After housekeeping, some gamification and presentation of the solution to build we actually started:

Lab setup – Day 1

a developer tenant (YAY! it’s free and you should have one as well!)
enabling of Teams App upload ( just a toggle!)
a SharePoint app catalog
a Microsoft Teams team (I promise, from now on I will just say “Team” )

and this was already the first exercise. Bob checked frequently, if everyone reached the next exercise and proctors offered help, support and nerdy jokes to keep up the good moral.

SharePoint News

First steps, to build our solution:

connect with SharePoint News in Teams
add some news to the SharePoint site
add News tab to Teams

SharePoint List Tab

Next steps were

create a SharePoint list
change column formatting with JSON code snippets that were provided (copy paste FTW!)
add the list as a tab to Teams
use APP STUDIO (this will become your favorite app for Teams, I promise) to create a “real” Teams app.
fill out a form which is called manifest editor
upload two images which are provided for you
change a URL
install the app
optional: install and pin the app using App policies

Until now, this whole thing was taking place in nice UIs, nothing too scary, and my success on doing this relied on my ability to carefully read exercise instructions and my experience in SharePoint, Teams and App Studio as I already built a lot of (low-code-) applications and bots. Now off to new adventures with

SharePoint Framework Tabs

Before we could start we needed to make to have

Node.js version 10.x to run the dev toolchain and
yeoman

so we could proceed with the download of the source code and building the project (HOW EXCITING!). I could have used SharePoint public CDN to make it work regardless which computer I want to use for it, but as I love my Surface Laptop 3, I decided to work on a local web server.

After that, it was time to

upload the bundle to the SharePoint App Catalog
approve permissions
install the app in the Team

One more thing to do: For bing maps you will need a bing maps key, for which you need to register, sign in, find this key, copy-paste it. Detailed instructions on this were available in the exercise, but Bob just provided temporary keys in the Teams chat- Thanks, that’s what I call service! Next step was already last exercise in this lab:

Calling the Microsoft Graph

After cloning the repository we

write a `sendToChannel` function (we need that later on)
import a reference to Teams JavaScript SDK
get the context of the Team from this SDK
send a message to the current channel with Graph

All code snippets were available to copy-paste, I took my time to read them 3 times to understand what was happening there. Next steps were updating the `getMapPoints` function and adding an item for the correct permission (`channelMessage.Send`) in the package-solution.json file.

After each step, Bob linked to how the could should look like, for self-assessment and of course, if you failed doing on step, you could still proceed.

Final steps:

Re-Deployment of the SharePoint solution package & approvement of permissions (repeating previous steps!)
test – and celebrate – YAY IT WORKS!

Build “One Productivity Hub” using Microsoft Teams and Microsoft Graph Toolkit” with Ayca Bas

After Bootcamp seems to be before next Bootcamp and on the very next day, I aimed to build a ‘One Productivity Hub’. Very confident because of my experience that I made in Bob’s, I joined Ayca’s session – and to put the spoiler first: I was not disappointed! We started with housekeeping and sweet Kahoot! gamification and got an awesome introduction into Microsoft Graph Toolkit. To be very honest: I didn’t need to hear that, because I already worked with it and blogged a whole series about it, but it was still good to hear everything by Ayca. She encouraged everyone, that it will be totally doable to build an app in a short amount of time , yet again, Microsoft Graph Toolkit reduces complexity as it provides us with web components, easy to use but still adjustable with custom attributes, properties and CSS.

Lab setup -Day 2

To be able to complete this Bootcamp, we need to

have a developer tenant
have enabled upload of custom Teams apps
have Visual Studio Code installed

which I already had so that I only needed to

have Microsoft Teams Toolkit installed
have Node.js installed
have setup Ngrok

I installed the software, signed up for Ngrok, got my auth token and ran the 4 commands to set it up.

Custom Teams Tab

After signing in (dev tenant), I created a new Teams app with capability TAB and ran `npm install` and `npm start` in Terminal. Couple of minutes later () I created a tunnel by running `Ngrok http 3000` and replaced a placeholder base URL with my NGrok URL so that I would able to test my app later on.

Initialize MGT and auth page

I registered my app in AAD (for everyone who never did that: this is literally 5 clicks plus copy-paste of the Ngrok URL for redirect URI) and copied my client ID which I would need in the next step.

Add MGT and build an auth pop-up page

To add the MGT I needed to add references to the Teams JS client SDK and the Teams provider (no worries, just copy paste two lines of code). After that, I initialized the provider and replaced a placeholder ID with the AAD app client ID.

For the pop-up page I created a new `auth.html` file and copy-paste the code provided to call the `TeamsProvider.handleAuth()` method.

Design my tab

Now it was time to already add the components (remember, LEGO bricks!) to my `index.html`

After creating three columns, I added provided CSS code to my `index.css` file. In those 3 columns I added the components for agenda, tasks (from planner) and mails (with the placeholder component `get`- code provided in MGT Playground – with which I played a couple of weeks ago already).

I like pink, which is why I changed some box-shadows in the `index.css`

Test my app in Teams Studio

Before I wanted to upload my app, I wanted to test the `manifest.json` file using the `validation` tab in App Studio – it returned with 0 errors- YAY!
To build and run my app, I ran `npm start` and imported my app in App Studio and installed it.

Time to try it out!

Click in the Left rail on `OneProductivityHub` app (this is the one I made – how cool it that?!)
Click the SIGN IN button in the pop-up page and sign in with m username/password and consent on behalf of my organization. BOOM! I see my agenda, planner tasks assigned to me and my mails!

Conclusion of attending 2 Bootcamps

Yes, I built 2 apps, but more than that happened:

community spirit

This Bootcamp was absolutely outstanding, as it was not “yet another online-conference”. I really felt connected and in the middle of co-workers, who all wanted to achieve something cool together. I can totally recommend this experience. This was truly amazing, not only because of the good and well-prepared content, the very responsive teams of Bob & Ayca and their proctors, but also because of the community-spirit.

learning

Not only did I learn a ton (speaking of it; I learned a lot about myself, my problem solving skills, my ability to focus and unstuck if I am stuck) and gained experience in building real-world scenarios (both Bob and Ayca put all those learning nuggets together into solutions that really makes sense!) but I also connected with other M365 Developers who shared their struggles, learning, journey so that we were already peers when it was time to celebrate success! THAT feeling when Bob and Ayca asked in the chat, if anyone already completed the last exercise and I saw more and more confirming messages coming in until I finally could say: YES! I made it as well.

4 Fun Facts:
- I attended the (first) BootCamp working on my 13″ Laptop while sitting at my hairdresser
- I finished the 2nd BootCamp way ahead of time
- I am not a developer, but I can obviously develop apps
- 2 days after Bootcamp, one of my customers asked me to help deploy some Teams applications – feeling confident enough to do that!
Why is this important to you?

If you are Maker/Citizen Developer wondering, where is the limit for you, I can tell you out of experience, that the limit is not Power Platform. You can build apps for Teams & SharePoint, if you feel comfortable with low-code development. You can expand your expertise with Microsoft Graph Toolkit or with Teams app templates. These solutions use the same approach as Power Apps – they reduce complexity because you stand on the shoulders of giants who give you ready-to-use bricks which you only need to put together. There is a lot of fuzz about how we distinguish between no-code, low-code and pro-code. I think it doesn’t really matter where we draw lines and if we really need to do that or if we evolve into a thinking to empower every developer regardless of their technical background or experience. Those Bootcamps are very beginner-friendly, but will still get makers out of their comfort zone to extend their comfort zones. I think this is a good thing, because at the end of comfort zone is where the magic happens. Probably I would not have needed these Bootcamps to get started with building real-world scenarios. All inputs needed were already available on docs.microsoft.com but this guided experience was a good start for me. Get more info on M365Bootcamps on twitter and M365 Bootcamps. Recording of Bob’s workshop is also available here.

Power Platform Licensing QnA – Key take-aways

Fri, 09 Oct 2020 12:58:56 +0000

Early October 2020, I hosted together with Elio Struyf a QnA session about Power Platform licensing. As experts, we invited Ryan Cunningham and Chris Huntingford. Upfront, we asked Tech Community on twitter, what they don’t understand in terms of licensing, because we couldn’t explain it in detail as well. Session was scheduled to be ~ 60 minutes, but we extended to 90 minutes – thanks again to our speakers!

Here are our key-take-aways which shall make it easier for you to get an overview about licensing in Power Platform:

We distinguish between Power Apps for Office 365 and Power Apps Standalone licensing.
- Power Apps for Office 365 means customizing and extending Office with low code. We can build and use unlimited amount of apps using SharePoint, Excel and dozens of other standard connectors. New to this party: Project Oakdale in Teams (CDS light)
- Power Apps Standalone means enterprise LOB applications backed by enterprise data. We get the FULL CDS, all premium connectors and on-prem gateways.
- Standard license includes all things on the Microsoft 365 platform. If you want to go beyond, it’s premium and you will need the Standalone license.
The ‘all you can eat buffet’ approach = Per User = 20 USD per user per month
- The à la carte menu approach = Per App = 5 USD per user per app per month
  For Power Apps Standalone we have two options:
  
  Discounts available at scale

No user needs to worry to not have the right license – if they don’t have a premium license but it is required to run an app or a flow, this will prompt a message for a 30 day trial. Admins get reports about those trials
Any flow that’s working on the same data as the app, doesn’t require an additional license for the flow: We don’t need multiple licenses just to run one use case.
It’s so friggin’ expensive because it has WAY more power than we understand – time to educate us! Although it provides a lot of value in the long run, lots of customers start small, and do not eat the whole cake at once.

Dataverse for Teams is basically Dataverse speaking of database and environment but with a more simple security model, but it’s the basic structure of a really high scale relational database with tables and the ability to use them in an app.
For AI Builder, there is a gorgeous calculator! [https://powerapps.microsoft.com/en-us/ai-builder-calculator/][2]
Power Platform is a maker platform, but it is a good place for developers to explore. Licensing for HTTP triggers will likely not change, which might keep most developers away as they will need Premium for simple things they want to automate. Dataverse for Teams solves a part of this licensing issue, but when not working within Teams, you still have to pay.
Multiplexing is not a drinking game, but an approach to get around an (expensive) Dynamics license. If you don’t have Dynamics, you don’t need to worry about it!

About Me

Thu, 24 Sep 2020 11:07:10 +0600

I help organizations with Azure & Power Platform - but without the fluff!

Getting started securely
Building and shipping solutions that are performant, secure, accessible and intuitive to use
Understanding and making the best out of licensing
Extending low-code with code-first approaches when needed

I’m not your usual consultant

If you want to work with me, we will work radically - meaning we will always get to the root of the causes instead of just treating symptoms. I am accurate and creative, a serial critical thinker and professional learner. A princess, punk at heart and advocate for doing the right things in the right way. Half-baked solutions aren’t my thing. I do what I say and say what I think.

If you are interested in getting to know what exactly I can help you with: Here are some ideas: work with me.

What are you waiting for?

Please don’t “hello” me! Why “hello” in Microsoft Teams isn’t polite!

Tue, 04 Aug 2020 12:46:14 +0000

I recently stumbled over nohello.com and aka.ms/nohello, which refers to https://github.com/sbmueller/nohello/blob/master/index.md#please-dont-say-just-hello-in-chat by https://sbmueller.github.io/. The author states very clearly, that just saying “hello” in a chat (at work) and then waiting for the other one to reply is not the best way to act.

After tweeting about it, I found myself in a quite controversial discussion and thought it could be helpful to explain my thoughts in a more persistent way-and with more than just 280 characters.

Why do you “hello” people?

Which purpose could it serve? I asked on twitter, got following answers and I would love to dig a bit deeper into them:

Being polite/ first greeting the other one
Seeing if they are available for synchronous chat
Control, if their status represents their actual work situation
Control, if you are still on their “VIP” list of people to be always answered first
Jump the queue, similar to “did you read my email?
Control if it’s a good time to share confidential information

Let’s have a look why all of them are bad and how there are better alternatives

Being polite

I am sure, you want to be polite. But in chat tools, there is no need to greet the other person like there is no reason to add your signature / contact details. To understand, why we used to do this and why it is not only mot necessary anymore but also harming our colleagues, it’s quite good to understand the roots of this behaviour – as the intention “being polite” seems to be valid and just good.

Greeting is a relict of times in which we tried to translate our analogue world (writing letters) to a digital world (writing emails). We all know, that this worked quite good for communication with customers and partners (externals), as email is just a simple way to exchange text and files if you don’t work together in a collaboration solution (like Microsoft Teams). It evolved into a nightmare within companies (internal), as we developed quite unhealthy habits which were the result of an information hiding culture. As everyone made themselves a bottleneck of knowledge and with glorifying busy (and confusing busy with productive), we came into the habit of forwarding the pressure that we got to the next one in the chain of commands by the devilish trinity of bad behaviour in the workplace:

1. “Did you read my email?”

Throw a stone, if you never said that to a colleague. “Did you read my email” doesn’t mean “Did you read my email”. It can be translated to:

“I gave you a task. And I know that you received it as our mail servers work. But I want you to confirm when you will care about me. So basically, I am jumping the queue and bring you into the position of justifying why you didn’t reply YET.”

Pro Tipp: You can even add some extra flavour when hitting the send button WHILE calling a colleague “did you already see? I sent you an email. What? Didn’t arrive yet? Just refresh!”. It’s the ultimate way to put pressure on others and its totally unproductive at the same time as you interrupt others and force them into task switching, which is energy draining for our brains and leads to slower work while more mistakes occur. Please don’t say it. Don’t even try to “did you read my Teams message?”. Thank you.

2. Checking inbox up to 100 times a day

A lack of purpose in work (we feel disconnected and don’t see the whole picture) leads to a misunderstood sense of duty which results in living in your inbox (doesn’t matter if you call your inbox Outlook or a chat in Teams – if you just put your old ways of working into a new tool, you didn’t win at Digital Transformation!) and checking for new mail in an insane frequency. Of course, this is supported by a default setting in Outlook which gives you a desktop notification for every single mail that you receive.

(ICYMI: you can turn that off:

File à Options à mail àuncheck “display desktop alert” – #EnjoyTheSilence ). Constantly interrupting others and expecting fast response times didn’t help with productivity, just with staying busy.

3. Being the bottleneck / abusing mail /messages for task management

The “my knowledge is my power” approach doesn’t come at no costs. Not only that sharing knowledge is beneficial for the whole company, it’s just time consuming, if we try to hide information and act like the gatekeeper to – for instance – a project status. If we don’t share information, we will always be busy with individually answering questions. I wouldn’t call this very efficient working behaviour. You can see, that a lot with people abusing mail or messages (again, doesn’t matter if you show this behaviour in Teams!) for task management, because they misunderstand what “polite” means. It’s is not polite, to “ask” your colleagues to accomplish a task that they are responsible for. It gives them – additionally to their task, the task to manage this task accordingly. Assigning the task in a task management system (like Planner) handles responsibilities quite effective. A task has some properties which can easily answer the most common question around this task like

“whom is it assigned to?”,
“which category does it belong to?”
“in which bucket will I find it?”
“when is the due date?” and
“what is the status of this task?”

WITHOUT sending mails/messages back and forth. So your so-called politeness resulted in more work for you and others. I would call that a waste of time. If you now say: “But what if we need to exchange our views and really have a conversation?” Then, please consider that a synchronous scheduled conversation (in chat or call) might be the better approach.

Polite to means:

Not causing extra work
Not putting pressure on me
Sharing your knowledge

As this behaviour will be beneficial for me. Sticking to old behaviours and not being willing to transform and evolve how we work is not polite, its just very yesterday and fa sign of a mixed mindset.

Looking, if the other one has time for a synchronous chat

Asking “Hey, do you have 10 minutes to give me an update regarding Project Deathstar” is at least a bit more specific, but please keep an eye on a small detail: Those closed questions (that can be answered with yes/no) come often with an expectation to be answered immediately (as it is assumed that it doesn’t take a lot of effort to type 2,3 letters), but we all know, that an interruption will steal way more than just the few seconds of seeing the message and answering it with “no”. It will take up to 20 minutes until you are as focused on the thing you wanted to do before you got interrupted. This lack of focus and the quality of your work and your wellbeing are tightly connected

Means: The more interruptions, the less stuff you get done and the more tired you feel.
The more time you can spend on deep work, the more you accomplish and the better you feel.

You already interrupted the other one and perhaps they know that they now need to time to re-focus and give in, answering: No, I wanted to do something else, but as you already interrupted me, shoot”. And perhaps, you already knew this…

If you ask an open question: “when do you have time to talk about Project Deathstar” you will end up with writing back and forth messages about the best time… If there only was a good way to schedule meetings… Oh wait, there is!

Outlook Calendar can show the availability of your colleagues, you can also use FindTime and Microsoft Bookings (this is what I do and it works like a charm!)
You can learn a lot about your co-workers availability by just reading their status. It works like a traffic light, a concept that we are already familiar with.

Control, if their status really represents their work situation / if you are still their VIP

If my status is “busy” and you ask me, if I am REALLY busy, this won’t improve our relationship. It reminds me a bit about sleeping and being asked if I am already/still sleeping. Its an expression of not respecting and not trusting, which is both toxic. Even worse, if your colleagues /managers? Just want to control, if you are still on their “VIP” list of people to be always answered immediately. Leadership doesn’t mean micro-management. As we don’t want to repeat mistakes that have their roots in processes from 1910 ( Henry Ford), we also need to evolve leadership and learn to trust our employees. Especially in #wfh times its just disrespectful to check, if your team members are “still” working.

Jumping the queue

You possible wrote your question – even @ mentioning them in a channel, perhaps you assigned them a task in Planner or wrote them an email – and now you really think that it is a good idea to write “Hello” in a private chat to check if they respond and if so – ask them when they will answer your question? Please mind, that you are part of the problem and not part of the solution. Jumping the queue is not only disrespectful and showing your colleagues that you don’t trust them, its also counterproductive as it leads to the next interruptions, which… nah, I won’t tell you again… You got this! Just break this vicious circle.

This one surprised me the most. If I share or duplicate my screen, I am automagically on DND, which means, that I don’t get notifications and don’t expose information unintentionally to my audience. If it’s very common to me, that someone else shares super high-confidential information with me, I don’t let others take a look over my shoulder. I think it’s the recipients responsibility to secure what happens on their screen like we expect everyone to lock their machines once there are not sitting in front of them.

Conclusion

Talk with your team members on a regular basis about the right tools to use and how you want to use them. Educate each others and learn about different expectations regarding working styles and response times. Just because I work crazy hours, doesn’t mean you should as well! A good starting point towards excellent teamwork is to have a collaboration contract. If you are not familiar with that – as your Microsoft 365 Consultant about it – or read this article by my MVP colleagues Loryan Strant and Sue Hanley. Please also read Darrell as a Service’s post about availability– he might have a different approach but I highly recommend it!

TL;DR?

What should you do?

Don’t “hello” people.
Setup your status message in Teams
Share this blog post as often as you can

Lego & Community – Interviews about building and learning

Wed, 10 Jun 2020 11:24:57 +0000

After some blog posts about Power Apps and my personal Microsoft Graph challenge, I am excited to announce that I will run a Community interview series about Lego.

I noticed that there are a lot of Lego addicts in my filter bubble, and I found it interesting to know how they think about Lego.

So I asked on twitter whom I should know – apart from the usual suspects that were already in my mind.

Meet my interview partners here and answer the questions as well:

https://bit.ly/LegoAddicts

Meet Elio Struyf

When did you start playing with Lego as a kid? Did you stop at a certain point?

As a kid, I did not play so much with Lego. I wanted to, but I was not in a fortunate situation where I was able to just choose what I wanted to play with. Luckily, I do not have traumas from this, but I now might have an urge to catch up with things I missed in my childhood. Now that I have kids myself, it is fun to share the same hobby. Although my kids know that the Lego from daddy is different from theirs. They can play/break/recreate with their own Lego, but the sets that are in the office, stay in the office.

Did you re-discover Lego? When and How? I always loved Lego, but when Lego started with the Brickheadz series. I just had to collect them all. During the Corona/COVID-19 crisis, I started to watch Star Wars (I know that I’m late to the game). After the first movie, I knew that this was a bad idea. Now I have an office full of unopened Star Wars Lego sets and various minifigs. Every time I make a set from Star Wars if feels like it was created especially for Lego. It all fits so nice together.

What is the build you struggled the most with?

Struggle is a big word, but the Bugatti and the new Lamborghini are two sets where you need to keep focused. The engine consists of so many parts that you can easily miss a step or accidentally put something wrong. One thing you do not want to do is break a Lego Technics set apart.

Do you build alone or with a partner / in a team?

Most of the time I do it on my own. Sometimes I get help from my kids.

Do you think it’s a coincidence that we know a lot of tech folks & developers who love LEGO?

Don’t know, Lego is just so cool, and there is no age limit on creativity. Think that brings us all together, finding solutions for problems, and start building them. This process is also what you apply to Lego. I also love it sometimes to open the Bricklink Studio app and start creating Brickheadz from scratch. Always cool to order the bricks and start building it in real afterward.

What did you learn from building LEGO for your job?

Coming up with creative solutions for issues you face during your work, but more important is the calm Lego gives me. I can use it to free my head and look at how brick by brick it comes together. Once I a set finished a set, it goes to my office. Sometimes I walk in my office to take a look and smile. It gives me internal joy and happiness. Think that is what matters the most, and a happy person results in making other people in your team happy.

What will be your next set?

At the moment, I am building the Lamborghini. The next set will probably be the Star Wars Stormtrooper Helmet (actually a really cool series).

Meet Jess Dodson

When did you start playing with Lego as a kid? Did you stop at a certain point?

Really young age – I remember having Lego in the house from the time I was about 5. I’m a twin and my brother (lucky!!!) got the Black Monarch’s Castle (6085) and I remember LOVING playing with it – the drawbridge, the dungeon, the knights on their horses, the winch to pull up the gate. As I got older, I got some of the “girlier” sets – my first memories of sets that were truly “mine” were of the Paradisa series. I was given Poolside Paradise (6416) and loved the new shapes and the smaller details. The parrot!

I’m not sure when I stopped – probably in teenage years? I don’t remember there being a specific point, I just don’t remember having Lego around.

Did you re-discover Lego? When and How?

I rediscovered Lego in a really unusual way. A fellow geek friend was in hospital in 2010 and I didn’t want to do the boring thing and bring him flowers or chocolates. I knew that he’d be itching to DO something. So, knowing he’s an engineer and he likes motorcycles, I bought him a Lego Technic motorbike (8051). I got to see it when it was built and thought it looked amazing. So I went and bought the same set. And I was hooked. Started off with Technic, moved into Lego City and then got drawn into Lego Star Wars UCS after I went to a Lego Expo and purchased an Imperial Shuttle (10212) UCS set that I fell in love with building. And I’ve been collecting ever since! I collect Lego Star Wars UCS, Expert Creator & Lego Ideas, as well as few limited run series like Monster Fighters & Lego Movie – I’m a huge Unikitty fan

What is the build you struggled the most with?

The Millennium Falcon UCS (75192) was probably my longest build. My daughter was only 3 months old when I first got it so it took me just over 2 months to complete…with her “helping” of course! A full photo set of the build:
https://photos.app.goo.gl/mhxS8MVpei2BFDu42

I also had some issues with the R2D2 (10225) set – I put his legs on backwards so I had to completely take him apart and start again, which was incredibly frustrating! Lesson learned!

Do you build alone or with a partner / in a team?

I build alone, because I love knolling (https://makezine.com/2016/12/07/zen-and-the-art-of-knolling/) and that’s half the fun of some of the larger sets! I use it as my escape, as my wind-down. My husband supports me (and spends way too much on me for birthdays and Christmas!) but he’s not a Lego addict like I am.

Do you think it’s a coincidence that we know a lot of tech folks & developers who love LEGO?

Not at all. It’s a physical manifestation of the things that we do – building things! It doesn’t surprise me in the slightest that so many tech folk are into Lego. There’s also the fact that Lego series tend to be of the “geeky” variety – Star Wars, DC Comics, Marvel, Harry Potter, Minecraft – that we can’t help but be drawn to it!

What did you learn from building LEGO for your job?

Follow the instructions CAREFULLY. Read ahead and don’t rush. Plan things out. Break things down into smaller segments and it’s easier to manage a big project.

What will be your next set?

I’d like my next set to be the Haunted House (10273) or Pirates of Barracuda Bay (21322), but I think it’ll like be Duplo Frozen Ice Castle (10899) for my little one, because of course I’m going to foster my love of Lego in her!

Meet Captain Daggers McTimbers

When did you start playing with Lego as a kid? Did you stop at a certain point?

I started playing with Lego Duplo when I was really young. Probably around 2 or 3? I then moved onto the more adult sets when I was about 5. I played with it until I was about 11 and took a break, as I was in my teenage years and had other things to focus on.

Did you re-discover Lego? When and How?

I rediscovered my love of Lego around 4 years ago, when my ex partner got me the Lego Yellow Submarine set for Christmas. I had so much fun building it I’ve made a point of having at least one set in reserve to build whenever I was to!

What is the build you struggled the most with?

The ship in a bottle, hands down, is the hardest thing I’ve built. I have long and pointy natural nails so building all the tiny little pieces of the ship was a challenge!

Do you build alone or with a partner / in a team?

I usually almost always build alone, though my partner does like to lend a hand sometimes.

Do you think it’s a coincidence that we know a lot of tech folks & developers who love LEGO?

Not at all! I think software engineers love Lego because they’re building something up that will be a satisfying final piece. I’m a hardware engineer so I love how practical it is, much for the same reason. There’s fun in following instructions for a lot of people in our industry.

What did you learn from building LEGO for your job? What will be your next set?

Lego has taught me patience. You can’t rush it because if you miss one piece, the whole build is ruined and you have to try and work back or start over. It’s a solid lesson to be learnt.

What will be your next set?

Well, I’m hoping to purchase the Pirate Bay set but I’m currently out of work so can’t afford it. But I have the Milano from Guardians of the Galaxy already, so that will likely come first!

Meet Waldek Mastykarz

When did you start playing with Lego as a kid? Did you stop at a certain point?

Ugh, tough one. I don’t know the actual age but it was early. I recall I had this police station set with a helicopter and an officer on a motorcycle. And I think you could turn the helicopter into a police station. I had so much fun with it!

Did you re-discover Lego? When and How?

When we got my son, we gave him duplo and later lego. As he was working on his sets I started to look more into it again and thinking, I want to build something too. Obviously I’d need my own set for that 😉

What is the build you struggled the most with?

Nothing really so far, but I haven’t built overly complex sets. I think the biggest struggle was trying to rebuild all sets my son has after he took them them apart. Starting of course with finding the right bricks in all the boxes, drawers and cabinets 😉

Do you build alone or with a partner / in a team?

Me and my wife built together a few houses I have on the shelve in my office. It was a lot of fun especially as we combined building with a nice glass of wine. We liked a lot not only the building itself but also discovering all the different pieces of the house, the rooms, architecture and hidden features. Lego has a great attention to detail!

Do you think it’s a coincidence that we know a lot of tech folks & developers who love LEGO?

I love to build something out of nothing. I think that’s why I code and it could very much be that it’s while I love lego!

What did you learn from building LEGO for your job?

I’d say patience and accuracy. Also, with the bigger sets, the idea that it will take a while and I don’t need to get it all done in one go.

What will be your next set?

I’m on the fence here. There are quite a few things I’d love to build that I have on my list, like more houses but also I like a lot the Bugatti and Lamborghini. And I’d like to try one of the Technic vehicle sets as well

Meet James Callaghan

When did you start playing with Lego as a kid? Did you stop at a certain point?

Started with the Duplo blocks when I was probably 3-4. Never stopped although the building and playing stopped in my mid/late teens the appreciation and joy didn’t.

Did you re-discover Lego? When and How?

When my daughter arrived in my mid 20’s it was the perfect excuse to unbox all my old models I had saved for such a day. Since then I realised you don’t need to be a kid to still enjoy building. The joy and experience my daughter has when we took a trip to Legoland is unforgettable and sparked unbelievable memories from my trip when I was young. I’ve since brought myself a number I always admired.

What is the build you struggled the most with?

I don’t recall struggling. I had a strange ability to translate the instructions with ease and had pretty nibble fingers! My recent challenge has actually been down to a number of lost bags from a really big model.

Do you build alone or with a partner / in a team?

All of the above. Building on your own is calming and peaceful but building with my partner and daughter is also lots of fun. There is a kind of Lego language – any one see a flat, 4×2, in blue?!?

Do you think it’s a coincidence that we know a lot of tech folks & developers who love LEGO?

I’d be interested to know if this is a tech thing or just a life thing. Lego is so globally accessible and known. This can only have increased as they’ve extended their range and their kits which are more inclusive then ever.

What did you learn from building LEGO for your job?

Firstly, everyone sees things differently. Simply put the same pile of blocks in front of different people and ask them to build you a car without them seeing what others have created. Secondly, requirements and agility. That same example could be achieve with flat 8×2 and two sets of wheels so know your requirements and your MVP. Lastly, use your imagination. Take time to step back and consider things in a different perspective. There is always a solution out there.

What will be your next set?

My daughter has a real joy for boats. She has rebuilt some of my kits and even a kit my brother passed down to me. For her birthday I may get her a pirate ship so she has her own memories to cherish. I never got into the Technic kits and would love to tackle something like a crane and teach my daughter about gearing and motors etc.

Meet Laura Graham-Brown

When did you start playing with Lego as a kid? Did you stop at a certain point?

Had Lego as a child, can’t remember not having it. When I left home at around 19 my Lego didn’t move out with me.. 3

Did you re-discover Lego? When and How?

Re-discovered Lego as my children got old enough so about 15 years ago

What is the build you struggled the most with?

I find the mindstorm robotic stuff slow to do, I just need to spend time learning the details.

Do you build alone or with a partner / in a team?

often its a family team effort, we buy sets to celebrate things, happy to build alone though

Do you think it’s a coincidence that we know a lot of tech folks & developers who love LEGO?

Tech people like procedures to do things and getting a finished solution, Lego instructions are just like a good blog post. Although we all claim to be radical and non-conformist we like things that do what they say they will do, and using known items in a slightly different way.

What did you learn from building LEGO for your job?

How step by step instructions work, how to write good to-dos. The Lego manual steps that are unclear drive us nuts.

What will be your next set?

possibly https://www.amazon.co.uk/LEGO-Ideas-21318-Tree-House/dp/B07W3YZ7SY/ to celebrate end of university year for the kids

Meet Marc Duiker

When did you start playing with Lego as a kid? Did you stop at a certain point?

I guess I was 6 years old. Also played with Duplo before that. I stopped when I was a teenager.

Did you re-discover Lego? When and How?

I got back into Lego in my 30s. I had the opportunity to go to Lego Land in Denmark for work and bought a Technic Lego set there.

What is the build you struggled the most with?

The Saturn rocket took quite some time and I had to redo some small parts because I didn’t read the instructions well enough

Do you build alone or with a partner / in a team?

Sometimes I build with my two daughters.

Do you think it’s a coincidence that we know a lot of tech folks & developers who love LEGO?

No, I think developers like to build things. And it’s a nice contrast with the virtual world.

What did you learn from building LEGO for your job?

RTFM and patience

What will be your next set?

Technic Dodge Charger

Meet Andrew Connell

When did you start playing with Lego as a kid? Did you stop at a certain point?

I started playing with LEGO at a very young age… so young I can’t recall! It was definitely before I was 7 years old because my first set was released when I was 7. In fact, I recently started rebuilding that set after finding the instructions and all the pieces at my parent’s house! I think I “grew out of it” around the time of middle school when I was between 13-16. Looking at the age of my kids (15 & 10), I see that happening to them around the same age.

Did you re-discover Lego? When and How?

I think it was about the time my kids started getting into the more complicated sets around 7-10 years old…so that would be about 8 years ago. You made me think about this… this means I took about a 23-year break from LEGO. That makes me sad… But… seeing them work on sets like Star Wars & the City themes got me interested again. I bought my own set so I could work on one with them. Now as they grow out of them, I’m really enjoying building complicated sets as it’s a form of therapy… LEGOtherapy I call it.

What is the build you struggled the most with?

Ah… easy answer. It’s the one I’m working on now: the Technics Bugatti! I’ve realized I’ve made a mistake a few times and gone back to fix it… like from step 430 to 360!

Do you build alone or with a partner / in a team?

Always alone… I did build a set with my son once. It was one I was really looking forward to building – the Saturn V Apollo moon rocket. I didn’t realize how much I liked the process of building and watching him build my set drove me crazy.

Do you think it’s a coincidence that we know a lot of tech folks & developers who love LEGO?

Not at all… I tend to see makers as the ones do like LEGO more than non-makers. Why? You create something which is what makers love to do. Plus, we get to use our hands and see the results of our output. We don’t normally get to do that in our day job.

What did you learn from building LEGO for your job?

Patience & to enjoy the process. I love the process of building not just LEGO, but in work, LEGO has helped me with patience and to enjoy the building process.

What will be your next set?

Either the Technic Lamborghini Sian or the Porsche 911 RSR

Meet Ryan Maclean

When did you start playing with Lego as a kid? Did you stop at a certain point?

I started with Lego Duplo when I was 2-3 years old and migrated to Lego when I was a bit older and had more dexterity (and I could be trusted not to try and eat the pieces…) I played with Lego for most of my childhood and adolescent years, but I stopped playing with it when I was a teenager (15-16 years old)

Did you re-discover Lego? When and How?

I rediscovered my love for Lego about 6-7 years ago; whilst I’d never really fallen out of love with it, I hadn’t engaged with it for a long time. I was browsing eBay and saw a really good deal for a set that looked interesting (42006 – Excavator/Claw Grabber) so I bought it and that reignited my interest.

What is the build you struggled the most with?

I recently built set 42082 – Rough Terrain Crane, and it was challenging as there are six different functions powered by a single motor, so the integration and orientation of the gears is very important to get right

Do you build alone or with a partner / in a team?

for the Technic builds I generally build them myself. If I am building any of the system brick sets (e.g. Harry Potter, Friends Central Perk, etc.) then I tend to build them with my wife.

Do you think it’s a coincidence that we know a lot of tech folks & developers who love LEGO?

I think Lego is probably appealing to tech folk/developers because it is a logical system that can be used to create complex solutions

What did you learn from building LEGO for your job?

The creativity in developing complex solutions with simple Lego elements has parallels to my job. I can use some of the simple elements of the Power Platform in creative ways to develop solutions for difficult problems

What will be your next set?

I have two sets I picked up recently to build: 42096 – Porsche 911 RSR, and 9398 – 4×4 Crawler. After those, I’d like to buy set 42100 – Liebherr R 9800 Excavator

Meet Daniel Christian

When did you start playing with Lego as a kid? Did you stop at a certain point?

My first Lego set was a Technic at the age of 5 and I haven’t stopped yet.

Did you re-discover Lego? When and How?

I was very focused on Technic and MindStorm sets that I completely missed the other series. When my boys were young I discovered a whole new series which I had heard of but never played with. The Mixel and Brickheadz were the two new ones.

What is the build you struggled the most with?

Building something out of your own imagination. We built our very own Easter Egg decoration kit using Lego Technic

Do you build alone or with a partner / in a team?

Team. Myself and my two boys. One is 6 and the other 9.

Do you think it’s a coincidence that we know a lot of tech folks & developers who love LEGO?

Nope, not a coincidence!

What did you learn from building LEGO for your job?

Do a small POC first before going big. You can substitute one part for another.

What will be your next set?

The Star Wars Falcon!

Meet Angelique Grootenboer

When did you start playing with Lego as a kid? Did you stop at a certain point?

As a kid i did sometimes at school but i was never in to it. And i started this year to like it much more.

Did you re-discover Lego? When and How?

This year i started because my husband wanted to do some builds. But I’m now the main LEGO builder in the house ;P.

What is the build you struggled the most with?

With my last build for the engine. That was the Land Rover Jeep.

Do you build alone or with a partner / in a team?

I build alone and ask sometimes help from my husband.

Do you think it’s a coincidence that we know a lot of tech folks & developers who love LEGO?

No because my husband pulled me in to meet tech folks & developers. In the group I am actually the outsider, because I don’t work in IT at all.

What did you learn from building LEGO for your job?

Nothing, i’m just doing it for fun. And to build some amazing builds.

What will be your next set?

I think from Architects Las Vegas or the new build the Lambogini

Meet Billy York

When did you start playing with Lego as a kid? Did you stop at a certain point?

5? maybe. sometime in my teenage years

Did you re-discover Lego? When and How?

my parents brought over all my old Lego in a box and my 5 year old loved them

What is the build you struggled the most with?

correctly putting the plates together on pirates of barracuda bay

Do you build alone or with a partner / in a team?

5? maybe. sometime in my teenage years

Do you think it’s a coincidence that we know a lot of tech folks & developers who love LEGO?

What did you learn from building LEGO for your job?

not sure, i already had my job upon rediscovering lego.

What will be your next set?

purchase? assembly square, build? birches books

Meet Mike Martin

When did you start playing with Lego as a kid? Did you stop at a certain point?

pretty early if remember correctly. I don’t remember the exact year , but … i do remember the exact set the The Lego Classic set 374-1 Fire Station https://brickset.com/sets/374-1/Fire-Station (originally from 1978!! but i think i got it in 1984 ..)

Did you re-discover Lego? When and How?

i never stopped loving Lego (i still have every catalogue from each year still somewhere …). But i do admit that i started playin again with thanks to my kids… great excuse uh 😉

What is the build you struggled the most with?

the Lego Technic car from the 1980’s : https://thelegocarblog.com/2011/11/20/lego-technic-8860-car-chassis-review/

Do you build alone or with a partner / in a team?

today alone or with my kids

Do you think it’s a coincidence that we know a lot of tech folks & developers who love LEGO?

nope, it stimulates creativity 🙂

What did you learn from building LEGO for your job?

thinking outside of the box

What will be your next set?

dunno, but I’m hoping for more UCS series on Batman :-p

Meet Rainer

When did you start playing with Lego as a kid? Did you stop at a certain point?

Started with Duplo in the age of 2-3, Lego at about 7, stopped at about 17, restart with 41, hopefully will never end

Did you re-discover Lego? When and How?

About four years ago due to my twins

What is the build you struggled the most with?

The Saturn V last weekend was challenging.

Do you build alone or with a partner / in a team?

Started with Duplo in the age of 2-3, Lego at about 7, stopped at about 17, restart with 41, hopefully will never end

Do you think it’s a coincidence that we know a lot of tech folks & developers who love LEGO?

Yes-best time to come down in a useful way.

What did you learn from building LEGO for your job?

You can build a lot with the right pieces – but not every piece fits everywhere

What will be your next set?

To be bought: Lamborghini in August OR a Speedchampion set from the new summer 2020 models OR the Crocodile train. To build: many waiting for me (Aston DB, Harley, Forrest Harvester, Ducati…)

Meet Martin Geuss

When did you start playing with Lego as a kid? Did you stop at a certain point?

I don’t remember exactly. Lego was just always there

Did you re-discover Lego? When and How?

In 2013 I rediscovered my love for Lego Technic at the age of 43. It was pure coincidence, I discovered a discounted set and bought it spontaneously.

What is the build you struggled the most with?

I found the Bugatti Chiron very challenging, because the assembly was sometimes very complicated

Do you build alone or with a partner / in a team?

Alone

Do you think it’s a coincidence that we know a lot of tech folks & developers who love LEGO?

It’s obvious that it can’t be coincidence ;-). But I don’t have an explanation

What did you learn from building LEGO for your job?

To earn success, sometimes you have to go back a few steps and rearrange a few bricks to make the whole thing work

What will be your next set?

Lamborghini Sian FKP 37

Meet Thomas

When did you start playing with Lego as a kid? Did you stop at a certain point?

3 years old with duplo.then went to lego and technic. Around 16 as a teenager…

Did you re-discover Lego? When and How?

After moving to my own place after my first long relationship at 25. I just fell back into technics. And since my daughter is 2 we started again to play with Lego.

What is the build you struggled the most with?

None Thst I remember

Do you build alone or with a partner / in a team?

With my kids

Do you think it’s a coincidence that we know a lot of tech folks & developers who love LEGO?

Never thought about it but a friend also in It had bought a cour sets again so definitely not a coincidence.

What did you learn from building LEGO for your job?

At school around 10 we were doing programming on Apple 2 computers and had these cool lego with sensors and buttons. I loved that class. It teaches you patience and when building without a guide it allows me to be creative.

What will be your next set?

Hmmm, another speed champions and possibly the Ducati panigale

Meet Will Thompson

When did you start playing with Lego as a kid? Did you stop at a certain point?

I don’t remember when I started! But I’m sure it was a *very* early age, certainly at pre-school I was into Duplo and progressed throughout that. Best moment was when a 70-something year old neighbour came round saying she’d found “a little box of Lego” in the attic, and it turned out to be a giant trunk with loads of vintage trains (the blue rails!) and city stuff. I transitioned into Games Workshop’s tabletop wargames around 12-13 years and starting spending my spare money on that rather than Lego, and kinda dropped both once I moved out of home.

Did you re-discover Lego? When and How?

I remember exactly! I was visiting MSFT HQ in 2008 (I’d been working for them in the UK for a year or so) and saw the Space Needle set (21003) in Barnes and Noble. I had to buy it! And that got me back into looking at other sets. I started with a couple of other architecture sets, then some of the one-off franchise models like BTTF (21103) and Tron (21314). But it’s jumped again since my kids hit 4 years old and got an interest. I’m eternally grateful to my parents for saving all my Lego 🙂 I got a few boxes from them so we have a selection of Fabuland, Pirates, and City stuff to play with now!

What is the build you struggled the most with?

The Black Seas Barracuda (6285) had some odd steps that I remember struggling with as a kid. The masts & rigging never quite fitted straight either – that’s been documented by other builders too!

Do you build alone or with a partner / in a team?

Either along or with my kids! They love the Fabuland and city kits I’ve rediscovered from my parents’ attic, and are building their own collections of Frozen stuff.

Do you think it’s a coincidence that we know a lot of tech folks & developers who love LEGO?

Not at all. Pre-COVID I always had a kit on the go in my office to have something to occupy my hands on long conf calls or to fiddle with if I was thinking through some complex problems. It’s quite zen-like in that way!

What did you learn from building LEGO for your job?

You could make a ton of analogies between building LEGO and building Power BI – being detail oriented, good aesthetic design, a final output that is delightful to use etc. And of course a *wonderful* community of likeminded people!

What will be your next set?

I’ve had my eye on the ISS (7647) since getting the Apollo Lander (10266), but I’m also on the lookout for the Saturn V rocket (21309) if I see that again. Pretty sure it’s out of print now though…

Meet Randy Perkins-Smart

When did you start playing with Lego as a kid? Did you stop at a certain point?

5, I haven’t stopped.

Did you re-discover Lego? When and How?

N/A

What is the build you struggled the most with?

Lego Technic 8852 Robot

Do you build alone or with a partner / in a team?

Alone.

Do you think it’s a coincidence that we know a lot of tech folks & developers who love LEGO?

No.

What did you learn from building LEGO for your job?

Things can be fixed.

What will be your next set?

Technic Lamborghini Sián FKP 37

Meet Stacy Cashmore

When did you start playing with Lego as a kid? Did you stop at a certain point?

I loved Lego growing up! And I was lucky enough that friends of my parents had older children, so I got a lot of “hand me down” sets without having to go through all of my pocket money! I stopped at some point in my teenage years. Back then, certainly where I grew up, it was considered to be a children’s toy.

Did you re-discover Lego? When and How?

Good question… Well, my first set as an adult was the camper, 10220, so it was probably around 2012. I saw the camper in a shop and was smitten- I’ve great memories from VW bashes in the UK from when I was a teenager, so nostalgia hit me hard. And let’s face it, it’s a beautiful set! Building it was amazing, the details that were put into the model (the engine, the T-Shirt in the window and the folding bed!). And the finished model is still in the living room on display! There was maybe a year or two between that and my next model, but from that point on I was trying to figure out what to build next

What is the build you struggled the most with?

Without a doubt the 2017 USC Millennium Falcon 75192! That took months to complete and there were more than a few times where we had to redo a few steps

Do you build alone or with a partner / in a team?

It depends on the model. Smaller models, or models that not everyone in the family is interested in, we build alone. We all have some of our own sets, but we the bigger ones we build as a family. Taking it time to search for bits, read instructions or build. That’s how we built the Falcon and the modular buildings. My son has been building with us since he was 5 – he actually built a number of complex pieces for the Falcon without waiting for the instructions (he cheated and read the book, cutting his parents out of the loop!)

Do you think it’s a coincidence that we know a lot of tech folks & developers who love LEGO?

Good question… I don’t think so. Personally, I love the flow of making a beautiful Lego model out of a pile of bricks, and seeing how some of the really complex structures are actually made. And just sheer the detail on the sets when done. It’s not unlike the feeling when I make software, seeing the end result, and figuring out how to join it all together. As well as that I know many people, not in tech, who laugh at me for being a geek, and include my Lego collection in that. Maybe geeks worry about that kind of judgement less and so don’t have a hang up about spending hours “playing with childrens toys”…

What did you learn from building LEGO for your job?

Don’t rush, step by step and make sure you are paying attention! Building with the family has really taught me about communication, how easy it is to be misunderstood and how when making something you need to have a shared vocabulary.

What will be your next set?

We have the Parisian Restaurant (10243) waiting to be opened as a family, and the Batmobile is calling to me for a build on my own…!

Meet Derek Cash-Peterson

When did you start playing with Lego as a kid? Did you stop at a certain point?

I have always played with Lego. I stopped at a point when I couldn’t afford to buy them and my old ones were stored in my parent basement.

Did you re-discover Lego? When and How?

I picked them back up when my son was old enough to play with them and I could give him my old Legos.

What is the build you struggled the most with?

The Parisian Restaurant, was the worst for me. All the little pieces totally stressed me out.

Do you build alone or with a partner / in a team?

Building Legos is a family affair in my house, partner, son, and me. We have most of the city collection around the house and Hogwarts.

Do you think it’s a coincidence that we know a lot of tech folks & developers who love LEGO?

No, I think tech folks gravitate to things that engage the mind creatively but are also modular. It’s fluid but also structured and you can do anything you want with it.

What did you learn from building LEGO for your job?

Patience!

What will be your next set?

We just got the new catalog today. Next set is Haunted House or Book Shop

Meet Jason Himmelstein

When did you start playing with Lego as a kid? Did you stop at a certain point?

I can’t recall a time growing up when I didn’t play with LEGO. I am pretty sure that my parents threw caution to the wind and gave them to me earlier than recommended just expecting that I wouldn’t choke on them. As a kid I truly PLAYED with LEGO. I never bothered to build what the instructions said, I just built what was in my imagination. I stopped doing that after high school when I had my own place and figured that the women I was attempting to date at the time would turn tail and run if they saw I was a big kid playing with LEGO in my spare time.

Did you re-discover Lego? When and How?

I never lost track of it, but the second I had kids I started re-engaging with LEGO. My dudes had sets WAY before they were old enough to understand what was going on. We went to LEGOLand Discovery stores any chance I could get my wife to go.

What is the build you struggled the most with?

the Millennium Falcon… but not for the reasons one might think

Do you build alone or with a partner / in a team?

My youngest son is my build partner. I try to build alone but he always wants to be involved. Occasionally I will build a set on my own after the dudes are in bed.

Do you think it’s a coincidence that we know a lot of tech folks & developers who love LEGO?

I think that LEGO does a good job of capturing the imagination of the creatives & provides an outlet to the highly structured alike. No surprise that techies gravitate toward LEGO for those reasons.

What did you learn from building LEGO for your job?

Just because there is a prescribed way of doing something doesn’t mean that it is the only way. Some of the coolest shit happens when you throw away the instruction manual.

What will be your next set?

Saturn V

Meet Paul Hughes

When did you start playing with Lego as a kid? Did you stop at a certain point?

My first memory of building “props” with LEGO was around aged 7 watching lots of Sci-fi and trying to re-create the props in LEGO (badly!). When I hit my teens and started working on games the LEGO went on the back burner for a few years.

Did you re-discover Lego? When and How?

Must’ve been the early 2000s when LEGO Interactive appeared on the scene – just seeing games melded with the LEGO franchise kick started me bakc buying sets again for my kids (well, OK, me!)

What is the build you struggled the most with?

The LEGO Technic Porsche 911 GT3 RS – was a real struggle; fiddly, sometimes confusing, but ultimately a very rewarding build.

Do you build alone or with a partner / in a team?

Just on my own – I find it strangely relaxing.

Do you think it’s a coincidence that we know a lot of tech folks & developers who love LEGO?

There’s just something fascinating about, quite literally, from small building blocks putting together big, well known objects and franchises – it just looks so darned cool!

What did you learn from building LEGO for your job?

I used to use LEGO for laying out isometric game ideas – which ironically led me to spending a decade programming LEGO Video Games!

What will be your next set?

I’m desperately trying to NOT buy the Millenium Falcon Collectors Edition – really. I’m not going to buy it, no sireee. (this is quite clearly a lie – I really need to build this, and, err, find somewhere to leave it on display)

Meet Spence

When did you start playing with Lego as a kid? Did you stop at a certain point?

Probably very young with duplo, then donated lego later on.

Did you re-discover Lego? When and How?

in the 90s when friends started to have children, and later when the Architecture series arrived

What is the build you struggled the most with?

Taj Mahal – a very long and often times tedious build

Do you build alone or with a partner / in a team?

Sometimes with a partner

Do you think it’s a coincidence that we know a lot of tech folks & developers who love LEGO?

Not really, given the marketing expansion of lego it has become a “thing” across many “technical” disciplines

What did you learn from building LEGO for your job?

patience

What will be your next set?

whatever the next architecture series model is

Meet Mikael Svenson

When did you start playing with Lego as a kid? Did you stop at a certain point?

I started when I was 4-5 and kept building until I was around 13, moving mostly to Technic and the Model Team series. My last set then was https://www.bricklink.com/v2/catalog/catalogitem.page?S=5580-1 which I modified to put an eagle on the hood – first and only time using scissors on a Lego brick

Did you re-discover Lego? When and How?

I re-discovered Lego briefly in 1998 with Lego Mindstorm. Next was around 5 years ago buying for my son then 5. He wasn’t that interested so I ended up building more and more, and then continued for myself.

What is the build you struggled the most with?

https://brickset.com/sets/42009-1/Mobile-Crane-MK-II due to an error, and didn’t want to redo hours. Managed at the end with careful power bending

Do you build alone or with a partner / in a team?

By myself most of the time, but do get some help from my son at times for Lego he likes. He built most of the Lego Boost and half the Voltron.

Do you think it’s a coincidence that we know a lot of tech folks & developers who love LEGO?

Good question….I think being grown up allows me purchasing power I didn’t have as a kid with Lego. And tech people love problem solving and have decent pays.

What did you learn from building LEGO for your job?

A great conversation icebreaker and people figure you are somewhat creative

What will be your next set?

After the 1989 Batmobile I’ll start with the new Lambo https://www.lego.com/en-us/product/lamborghini-sian-fkp-37-42115 which should arrive any day now.

Meet Simon Bisson

When did you start playing with Lego as a kid? Did you stop at a certain point?

I always remember playing with Lego as a child; I would construct huge moonbases and ships. I guess MOCs before they had a name! I fell out of it when I moved away from my home island to go to university, when I got to play with real steam trains in the Welsh mountains…

Did you re-discover Lego? When and How?

It’s one of those things I have had waves in an out of, usually when there’s been a set that’s caught my eye. But now I have a shelf set aside in my office, as I really got into it again when the Saturn V came out. Now I’m having fun exploring more complex builds, and have recently started making time lapses of my builds.

What is the build you struggled the most with?

I can’t think of any that really have been too hard, but I am yet to really get back into the Technic side of things!

Do you build alone or with a partner / in a team?

I tend to work alone, especially when I’m making a build time lapse.

Do you think it’s a coincidence that we know a lot of tech folks & developers who love LEGO?

No, I think they’re closely related concepts. I remember using it as a metaphor back in the 00s while trying to explain SOA and interface-first design to colleagues

What did you learn from building LEGO for your job?

SOA and design-by-contract! They’re great ways of explaining modern cloud-first microservice design.

What will be your next set?

I have managed to acquire a V-22 Osprey; it is on its way! I’m also fascinated by how the Chinese clone bricks are now starting to make their own sets, and have been building kits from Chinese sci-fi movies. There are some trucks from The Wandering Earth that I might get soon.

Feedback and what’s next

If you like this series, please leave a nice comment 😉 You can submit your answers here: https://bit.ly/LegoAddicts

Exploring Microsoft Graph Toolkit as a non Developer – Part 6

Wed, 10 Jun 2020 07:01:19 +0000

If you made it with me up to this blog post, it’s very likely, that you read the previous 5 blog posts about my learning journey about Microsoft Graph as well – Thank you. If not, this is your chance to catch up here.

The Lap around Microsoft Graph Toolkit is a super cool series initiated by the Microsoft Graph team to empower more developers in working with Toolkit.

I learned so far how to work with Toolkit components, and thanks to the excellent work of our Office development MVPs, I am now able to style and even template components. Never thought this would going to happen, but this super detailed step by step approach made developer tools/toys even accessible and usable for me, a non-developer.

From HTML application to SharePoint Solution

In Day 9 of the #MSGraphToolkitLap MVP Hugo Bernier guides us from writing web applications to writing a SharePoint solution. As usually in this series, we break it down to some (supposed to be) easy to follow steps. We already know these steps from Season 1 of our #MSGraphToolKItLap when we worked on creating our first HTML application. Let’s see how this goes.

We learned in Day 2, that we needed to register our application in Azure AD and that we needed that Client ID of this application to get access to our Graph APIs. In SharePoint solutions, we can skip this step, because each solution package automatically creates a unique ID which we use to grant access to Microsoft Graph APIs.

Create your application

Let’s get our hands dirty! Hugo guides us through creating our web part app with Yeoman SharePoint generator. As I recently dipped my toe into how to make my first Hello World! SPFx web part following these docs.microsoft.com, which Hugo also refers to, it was easy to do that, thanks to super detailed guidance. If you struggle with that, there is also an excellent video about how to set up your dev environment and do these first steps provided by Vesa.

Adding TypeScript 3.7 is a good idea since we can get rid of some error messages. I am not too fond of error messages, not only because I wonder what they mean, but because I always assume that I did something wrong, and then I question my skills. So if a few additional steps can avoid me getting error messages, this is already a good investment of time and effort. For context: I can write some super basic lines of JavaScript and never experienced doing stuff with TS. So I am a little bit insecure about how this turns out. But as the blog post series seems to be a super beginner-friendly end-to-end tutorial, I probably manage that as well.

Add Microsoft Graph Toolkit to your application

We did that in our previous HTML application by adding a one-line script, which was just a copy-paste job. (By the way: The more I learn about dev stuff, the more I am convinced that CTRL c and v are the essential keys on my keyboard).

For our SharePoint Solution, all we need to do is installing an npm package, which again is just a one-line command.

Add the MSAL SharePoint Provider

As we now deal with SharePoint and not an HTML application anymore, we do want to add a SharePoint provider. Remember part 5 of my series, where I explained that we do not necessarily as makers need to be able to write our providers? As a developer, you can do that, check out Nikola’s sample on this Github repo for reference. It’s just great that there is already a SharePoint provider in place, that we can use. You know, I love LEGO, and this seems to be the SharePoint Lego Set. Installing the SharePoint provider is quite easy, as we only need to add three lines of code. Understanding how providers work on a high level (thanks again to Simon Agren) helped me here.

Wow, the hardest part is already done, and it only took us a couple of minutes!

5. Add the login component

When we still worked on an HTML app, we used the mgt-login component because we wanted to enable the user to log in securely. In SharePoint, things are a little bit different: Users, who consume a SharePoint web part, already need to be authenticated. They did that login already, so we do not need to log in users twice. Nothing to do in this step – you see, stuff gets easier in SharePoint!

Add additional components

Again an easy step – we are already familiar with components like mgt-person or mgt-agenda – the only thing we need to do is adding these components in our HTML. Now we can repeat what we learned in the last season, like customizing the components so that they match more our needs or style them like we want it and even use the mgt-get as a placeholder for any data we want to get and even update.

Now that we translated our previous HTML application knowledge to SharePoint, it’s time for

Build our solution

First things first, choose the right MSGraph API permissions. When I learned something the hard way in Power Platform and Graph, it’s that permissions comes first. So let’s do this by simply

changing “isDomainIsolated”: true to “isDomainIsolated”: false

in a JSON file and

adding the correct permissions. Don’t you know which permissions you need? I hope that if you follow my blogs that I can’t stress enough, the value that docs.microsoft.com provides. Read the formidable manual is always a good advice. Just look up what you need, it’s not rocket science. Those webApiPermissionRequests always consist of a resource, which is “Microsoft Graph” and a scope like user.Read.All”. As always: Don’t add permissions that are not needed.

After we built the solution with

gulp bundle –ship
gulp package solution –ship

Note: Educated by Elio Struyf that I needed to –ship as otherwise only I could use that.

We can find an sppkg package in our solution folder. I mean, how easy was that?

We now want to upload our sppkg file to SharePoint’s app catalog, and we get asked to deploy our solution. It’s a good idea to have a careful look at the permissions again. We need to approve the pending permissions on the API Management page. What you need to know: By hitting this deploy button, we get a list of all permission requests, which we now need to approve. To access that list, we navigate to the SharePoint Admin Center and select ADVANCED -API ACCESS. Now approve all of these pending requests. This step is mandatory; without approved permissions, our web part can’t work.

Test our web part

Perhaps you are already familiar with the concept of a local workbench for testing. It runs on your machine. This won’t work here as it is not authenticated, so that we need to switch to a hosted workbench, which runs in our tenant. We now test by adding the new web part in this hosted workbench and see our component for the first time in action

I tried with mgt-agenda and mgt-tasks, and both worked like a charm.

Feedback and what’s next

If you liked this blog post, please let me know with a helpful comment. Also, follow me on twitter. I will surely blog about the upcoming blogs of Microsoft Graph Team using the hashtag #MSGraphToolKitLap.

Community Profile of the June – #MSBuild edition of Microsoft 365 Developer Newsletter

Tue, 09 Jun 2020 09:36:03 +0000

Wow, I’ve been featured in the Microsoft 365 Developer newsletter 🙂

1. What is the coolest Microsoft 365 developer feature for you?

Hard question, I love the core idea of making Microsoft 365 development as easy and accessible for everyone as possible, which leads to great products and documentation and attracts a community which breathes sharing is caring. My personal gamechanger were playgrounds like the Adaptive Cards Designer or the MGT Playground and I love my free DEV tenant.

2. What school did you graduate from?

I graduated from Humboldt University in Berlin with a Master degree in Business Communications

3. What’s your favorite city to live in?

I love my hometown Duesseldorf, where I usually live. Currently, I am staying in Belgium on the countryside, which is also lovely.

4. What did you want to be when you were a kid?

As a kid I had every day 3 new ideas what I wanted to become 🙂

5. Which words or phrases do you most over-use?

In sessions, I tend to say “soooo” :-).

6. Which talent would you most like to have?

I would love to be able to orientate myself better. I can easily get lost in a grocery store ¯\_(ツ)_/¯

7. Where would you most like to live?

I want to live with my beloved ones, like to travel (I really miss that) and love coming home again.

8. What is your most treasured possession?

I don’t really like having a lot of stuff, because that seeks my time, attention, focus and energy. But I really love my piano, an old box with photos and some LEGO.

9.What is your most marked characteristic?

Curiosity and empathy

10. Spaces or tabs?

Tabs. Unless I’d work in team in which they work with Spaces.

How to make a conference app in less than 30 minutes

Wed, 27 May 2020 13:07:00 +0000

I made an app for #MSBuild conference so I could more easily overview my sessions, follow relevant tweets and rate the sessions. This is the second app I’ve ever built and I want to share how you can easily rebuilt is as well.

I learned the very hard way, that the first thing you need to do in a Power App is not only to give it a name, but to save it, so you can then benefit from autosave. I didn’t do that and accidentally closed my browser tab and lost everything when I almost finished the app — Fair to say, that it took me more than 30 minutes when i built it the first time. This is when I came up with the idea of making it a challenge to complete a whole app in under 30 Minutes. I recorded my app making process and the video is about 18 mins. You can watch and share it here:

To make this app, we will need

6 Screens
3 galleries
2 Connectors
1 CDS entity

Let’s start with the

Common Data Service (CDS):

Make sure you understand: This is not an entire CDS tutorial, it’s just the way I started with it and made my app work.

Open make.powerapps.com, login and click SOLUTIONS → NEW SOLUTION

Give it a name AND create your own publisher; for reference see this article. Use this new publisher in your solution, click on CREATE.

Now select your solution, and click on NEW → ENTITY

Create the fields you want to see and make sure to respect the data type of the field.
You can add the first record manually on the DATA blade:

You will see that you won’t see all the fields you created before- don’t worry about that too early. Just add your first record “test” (or “#Unicorn”). You may now want to know where your fields are: Just define a new view in the upper right corner:

Now that we have our CDS entity it’s time to connect this entity with our Power App.

Click on the Data Sources icon on the left rail and connect to your entity.

As you are already here, you can also connect to Twitter and Office 365 Outlook, we will use that later.

Sessions

As we want to nicely display all sessions we were interested in, we first need to have the session data. I downloaded the .ics files for all sessions and saved them in an Outlook Calendar called “Events”.

So this is how it works:

Create a new screen and add a gallery to it- I chose ‘Title, Subtitle, and body’ as Layout
Create a Dropdown Input with Items= Filter(Office365Outlook.CalendarGetTables().value,DisplayName = Events)

without the filter you can actually use it as dropdown, it will show all your Outlook calendars. I set this visibility of this dropdown later to false, because we don’t need to see this in our app.

I chose that the Subject of my event should be the Title, the Body Preview should be the Subtitle and the Body should be Start / End Time.

Date /Time looked ugly, I didn’t want to repeat the date for the End Time and so I went for this approach- which is basically concatenating some texts and if formulas- You’d do the same in Excel: Hour(ThisItem.Start) & “:” & If( Minute(ThisItem.Start) = 0, “00”, Minute(ThisItem.Start) )& ” to ” & Hour(ThisItem.End) & “:” & If( Minute(ThisItem.End) = 0, “00”, Minute(ThisItem.End) ) & If( Hour(ThisItem.Start) <10, “zzz”, "" )

twitter

We already connected to Twitter, so we can now just repeat what we did for our sessions screen:

Create a new screen, add a gallery. I again chose Title, Subtitle, and Body as the layout.
Set Items = Twitter.SearchTweet(“#MSBuild”)

as we want all #MSBuild tweets.

Choose which data you want to display in your fields:

I want an icon in the gallery that should open this particular tweet. As a tweet URL has the Syntax:

https://www.twitter.com/USERNAME/status/TWEETID we just set the .onSelect property to:

Session Rating

Create a new screen as a form
Data Source is your CDS entity. I wanted to have one Dropdown field for the Session Name and 4 Number fields for session evaluation, displayed as stars.

Set this SessionName field to ALLOWED VALUES, and the allowed values property to the same value as the items property of the dropdown field:
Change the Data Value of the dropdown to SUBJECT (it’s Preview Body by default)
Change the Update property to DataCard.Value.Subject (important!)

Change the .onSelect property of the SubmitForm Button to

Make your app pretty

Beautiful apps are more engaging and it’s not as hard as you think to pretty up your app. Here are a few things that I did:

choose a nice background picture. I know, we all have our go to resources for nice pictures, but if you don’r find anything you like on unsplash.com you can even open PowerPoint and click on INSERT → STOCK PHOTOS. You will find tons of hi-res photos 🙂
There are at least three ways to define the color scheme of your app:

a) Choose a theme for your app that is in harmony with your background picture, so you don’t need to touch any single button to define your colors.

b) Create a collection with “your” colors on App Start and reference to them later, because you unfortunately can’t just write /upload your own CSS file.

c) You can also store your colors as variables:

I just picked a theme and it worked very well for me.

Choose icons for your navigation, use the ALIGN — DISTRIBUTE HORIZONTICALLY feature
Use the Navigate() function on the .onSelect property of your icons to navigate to the other screens
on each screen change the display mode of the icon that represents the screen to “disabled”- wouldn’t make sense to click them.

That’s it!

Feedback and what’s next?

If you like this blogpost / the video / my app, please clap and follow me on twitter and subscribe for my youtube channel. I think about doing a series called #LessCodeMorePower Community Calls, where I will demo my wins and learning of Power Platform including PowerApps, Power Automate, Power BI, CDS and Power Virtual Agents.If you like to join, just send me a message.

Exploring Microsoft Graph Toolkit as a non-developer -Part 5

Tue, 05 May 2020 12:36:00 +0000

Wow, we almost reached the end of season 1 of the #MSGraphToolkitLap — in which the Team of Microsoft Graph takes us seriously from zero to hero. If you didn’t read part 1, part 2, part 3 or part 4 of my series about it, you should catch up first. I promise to stay here and wait until you are ready.

Read it? Great! So let’s see, what this part is about: MVP Simon Agren takes my learning journey in which I play with developer tools, to the next level as his blog post is not about how to make good use of another component, but as he provides an excellent overview about providers and gives an example how to use this as well. My first read of the blog post (and especially the SimpleProvider sample by Nikola Metulev in the corresponding GitHub repo made me feel like this:

Time to eat that shark bite by bite

My blog posts are about which parts of Microsoft Graph Toolkit are useful as well for non-developers. As in many other scenarios, this is a #bettertogether story: Having a dev in your team will be crucial if you want to follow Simon’s approach. Once this is done, citizen developers can contribute by using the LEGO blocks as I already wrote about it.

First things first: the architecture of providers

the provider needs to be initialized — by a provider component (like we did in the previous posts) or by a developer in the code (this is way more advanced but makes sure that you are flexible!)
after that, it needs then to be set as a global provider in the provider’s namespace
provider tells the web component which of the three login state is true: ‘loading’, ‘SignedIn’ or ‘SignedOut’
on change of this state to ‘SignedIn’ the component can call Microsoft Graph via provider
provider implements an SDK instance which means, that the provider can call Microsoft Graph APIs
Microsoft Graph SDK makes the actual Graph call.

Let’s get practical

So if you feel a bit lost here — don’t worry — it’s getting better once we approach this topic more practically and use an example. You surely remember Cameron Dwyer’s use case of warehouse packers who needed a lightweight app? Cool. Simon extends this use case so that we can update list items as well and not only get data from a SharePoint list.

Simon added just a few things to Cameron’s code:

he changed the filter from Status eq ‘ready for packing’ to Status ne ‘delivered’
he played a bit with colors
display a ‘pack’ button if the item status is ‘requested’

All we need to add to our existing code is a little script that checks if the user is already logged in (so if the state changed to “SignedIn”) and then patch the list item with an updateOrder() function which runs on select of the “pack” button. Obviously, we need the right permissions to do that so that we will add sites.readwrite.all as prepScope.

My take on providers

To be very honest: I couldn’t write my own provider. But fortunately, this just isn’t my job. Remember: I am one of those self-taught makers citizen developers who are not paid to write code, but just feel the urge to build solutions and making things happen to make people’s work work. I use the so-called low-code on Microsoft Power Platform, and I am ok with writing some lines like in the last parts of this series, but doing the hard work writing a provider would require a lot more coding experience than I have.

But although this part is not entirely doable for me, I found much value in it. I understood not only what a provider does and in which kind of scenarios we would use our own providers, but also how easy it would be to include a custom provider into a lightweight solution like our warehouse packer application. I got it that predefined blocks make it easier to build faster as we do not always have to reinvent the wheel over and over again.

Some of the concepts that I learned in this first season were already familiar to me — not because I knew them, but because I spotted similar things in Power Apps (like updating a list with a patch() function) or Power Automate (permissions for Graph calls within a flow). I love to see that I could connect some dots.

What’s next & Feedback

Next is #MSBuild — if you haven’t registered yet, do yourself a favor and register as it’s all free and digital. The Graph team will do a live coding session as well, and I will blog about that as well. What do you think about the #MSGraphToolkitLap and how I approach it? Will you stay for the second season after #MSBuild? Please let me know what you want to learn, clap for this blog post, and follow me on twitter to connect with me.

May the force be with me: My first Canvas App in Power Apps

Mon, 04 May 2020 12:38:22 +0000

Challenged and inspired by Pieter Veenstra’s Video about an app by and for kids with Power Apps I decided to finally make my first canvas app. The decision was not attempting to make something: Do or do not- there is no try 🙂

Purpose

Before I talk about the solution I came up with, I want to introduce to Miss 8- my most important user MIU. Miss 8 struggles a bit with calculating. The fact, that she can’t go to school during these difficult times or attends lessons, doesn’t make it easer. So I wanted to help her.

So very obviously, this will be an app for kids. I want a pretty simple UI, without fancy elements and a color scheme that is compelling for my MIU. Miss 8 even asked me to take a photo of her favorite #Lego Minifig to make this a background of the app.

Challenges

There were in total three main issues for me with building this app:

I am not a professional developer and I am truly intimidated by all the tech that is available and impostor a lot about it — although I already made progress
I have dyscalculia, which means I have difficulties in understanding the meaning behind numbers and that it it’s very hard for me to get the logic in a calculation
I never built an app before!

The list of requirements:

random tasks for exercises

for the four basic calculation operations: +,-, *, / only with natural numbers

addition: x+y = z; z ≥ 100
subtraction: x-y = z≥ 0
multiplication: x*y = z; z≤ 100
division; x/y = z; z≥0

show if result is correct or incorrect

so that user gets an instant feedback

count correct and incorrect answers and calculate a score

and display this during the game

let user submit results only if a score of 30 points is reached

to ensure Miss 8 stays focused and spends a while with doing exercises

write results into a list

so that parental account can see results as well

display scores for a user and send confirmation to parental email address

so no way to cheat

reward user for getting 100, 200, 300 points

with stickers to collect in the app

make it compelling for Miss 8!

Not too bad for a first app? This is what I thought as well. So here is how I did that.

Preparations:

If you haven’t already, get a free PowerApps license and log in. Click on Create, provide a name and here we go:

Working on our app

as we need four exercises for the different basic calculation operations, I decided to go for four screens. Each screen contains

text labels

firstNumber
secondNumber
operator
equals
result
amount of correct answers
amount of incorrect answers
this game’s score

buttons

next (to create the next task)
navigation (back to Start, submit to SharePoint, show my scores, hall of fame)

Let’s have a look at this (and also reveal the design):

logic

Of course, these text labels and buttons don’t do anything unless we tell them what they need to do.

START, MY SCORES, HALL OF FAME will be just links to screens we will create later on. To let your user navigate between screens, just select the .onSelect property and type navigate(- your other screens will now show up and you can just select from this list. Don’t forget to close your parenthesis (round bracket).

As we want two numbers AND make sure that our user gets an instant feedback, we need do the following in the .onSelect property of NEXT button:

This ensures, that if the answer to x+y = z (correctly), we will set a variable named varQuestionCorrect to the value true, else we will set a variable named varQuestionIncorrect to the value true.

We will need 3 functions to meet all requirements here:

rand() — gives us randomized numbers between 0 and 1 with lots of digits after the comma — we will need to multiply this random number with 100 to get numbers up to 100: rand()*100
round(,0) — makes sure that we round the value and get 0 digits after the comma. Our value is the randomized number between 1 and 100from our previous step: round(rand()*100,0)
now it’s getting a bit ugly. The mod() function returns the remainder from a division. So we can have any random number and then use Mod(, 100) to get a random number between 1 and 100

After we learned the functions, we will use them like this — again .onSelect of our NEXT button:

a) First we need to create z- as this is the highest number (≤ 100)

b) Now we create y and make sure that y is between 0 and z

c) After that we already know x: it’s just z-y

After that we just reset our Result text label, to make it more convenient for MIU:

Reset(‘Add-Result’);

As we want to add/deduct one point to/from our Counter, we need to do two things:

a) Set a global variable on app Start

b) set a condition, that if the result was correct (we know this already by our varQuestionCorrect), then add 1 to our counter, else subtract 1 from our counter:

Pretty easy, hm?

Next thing I want is to give Miss 8 an indicator, if her answer was correct or not — show i want to show a 🙂 for a correct answer and a 🙁 for an incorrect answer — but only for 1,5 seconds. Plus: I want the colors of these emojis with my color scheme. Let’s do this!

a) First, I created a happy face icon — and guess what? An icon has an icon property .

Again, a simple if statement (now in the in the .icon property of the icon):

b) Next small feature: colors of the Emoji. If it’s the happy face, it shall be the light blue I use”, else it shall be pink. So on the .color property of our icon we do:

c) Now I want to make sure that the Emoji will only be visible after Miss 8 clicked on the NEXT button:

So I need to set a variable in the .onSelect property of my NEXT button:

(we will need the varNextclicked in step c)

so whenever the NEXT button is clicked, the varShowface variable is set to true.

Now we will work on the .visibility property of our icon:

It should only show up, if the NEXT button is clicked — we know this from the value of the variables of the previous step — so we just type:

varShowFace

d) Now let’s work on this 1 1/2 seconds:

I added a timer and set its .duration property on 1500 (which means 1500 milliseconds or 1,5 seconds).

The Start property is varAddNextclicked = true (we did that in step b) and the .onTimerEnd property is set to:

to make sure, that the icon will be visible on next NEXT click again.

e) I wanted to show the amount of correct and incorrect given answers, not only the earned points, so I set two variables in the .onSelect property of my NEXT button in an if statement, depending on if varQuestionCorrect equals true or false:

All I need to do now is to set three additional text labels, that display my variables. I found it nice to do it like this in the .text property:

Now the easy part — at least for me. We want to write results into a SharePoint list, display the list in a nice way in the app, notify parental account by email and make sure that Miss 8 needs to have at least 30 points to be able to submit her records. Here we go:

Preparation for this step: Create a SharePoint list

a) Create a button which is only visible, if the gloCounter is ≥ 30. We will do the following in the .visibility property of this SUBMIT button:

b) in the .onSelect property, we want to run a flow, so we select Power Automate in the menu and create a flow — there is even a template to do this:

Back in Power Apps, we need to specify the arguments of our run function:

The contextual help will guide you through this like in an excel formula. Basically, all your fields in Power Automate need to now be defined in this step.

Now that we got our records in the list, I want to display it to my MIU. To make this work, I created a new screen and in this screen new form. I connected in the DATA tab of Power Apps to my SharePoint list and now wanted to show the values of my SharePoint list sorted by highest points. A couple of questions, answered by her Queen of Canvas Apps Clarissa Gillingham, google search and RTFM I found out how to do this: We first need to create a new collection (we call it colSortedData) and define the order in which we want to display it:

We do the same thing for our other screens in which our user can practice the other operations.

Additional Screens and logic

As we already made a button for the hall of fame, we should make a screen as well 🙂 In this hall of fame, Miss 8 gets stickers /images if she reaches a defined amount of points overall her games. To get this, we need another global variable, I called it gloOverallPoints — so what we need to do is:

and display the variable gloOverallPoints in our HALL OF FAME and/or MY SCORE screen in a text label

A Start Screen to navigate through the app and a Success Screen to let Miss 8 know, that she submitted results make the app complete. Let’s see this app in action:

Learnings:

I learned: a ton! As this was my very first app and I didn’t touch Power Apps before, everything that described in this post was new to me. But I’d like to share, what helped me the most:

View on variables- You can not only see here all variables that you used globally or in context of a screen, but also have a look at their current value and where you used them. Invalueable while debugging!
Train your eyes! We often oversee things because we are too fast- rubberduck debugging works in Power Apps as well. Talk something or someone (thanks again to Clarissa) through your code- this slows down your thinking and likelihood that you understand what you did wrong will be so much higher.
The importance of docs.microsoft.com — especially when it comes to all functions- some of them are perhaps familiar to you, but it’s a good idea to read that list of functions to know what’s possible and then lookup syntax when you need it.
Curiosity helps you to find the little gems like: you can rename everything in your tree view with F2 (like in Excel) or make a new screen like with CTRL+m (like in PowerPoint).

My two Cents on Power Apps after this experience:

Microsoft introduced Power Apps (and the whole Power Platform) as something no-code / low-code -ish environment — and left some people behind with that. Actually, there is lot of code in an app made with Power Apps, but you can’t see it in one view. There are a lot of tiny boxes and panes, which you need to open to see all the code that you have written. So it’s more a trojan horse: it hides the code very well 🙂

Also, there is no easy way to document your solution (this is one reason why I wrote this blog… quite sure that I will forget at least one thing that I learned by making this app and I will google that in a few months and will be overly excited to find my own blog post ).

What’s next and Feedback

If you liked the post, learned something new, reactivated knowledge or just like the #Lego Minifig, then please clap for this blog post. Also make sure that you follow me on twitter. I already have ideas for next apps to make, but I am open for suggestions as well. May the force be with you.

Exploring Microsoft Graph Toolkit as a non-Developer — Part 4

Thu, 30 Apr 2020 11:55:03 +0000

Continuing my learning journey with #MSGraphToolkitLap to make good use of the Graph Toolkit I read Cameron Dwyer’s blog about the power of the mgt-get. You can catch up here to read part 1, part 2 and part 3 of my series, if you haven’t done this before.

I took a look at the GitHub Repo, but instead of copy-paste everything and only replacing the IDs, I just copied the CSS code- I am still very slow at writing CSS and I wanted to focus on the web component itself. So I talked myself 3 times through Cameron’s code to really know what it needed to do. As you know: I am (still) not a developer, but I am getting familiar to writing code -step by step.

MGT and SharePoint lists

I work a lot with SharePoint and of course, lists are an amazing feature. So in Cameron’s example of warehouse workers, who need a lightweight app to know which orders to pack, he uses the mgt-get component and “some CSS magic” to nicely display only the orders, that are ready to pack by using a filter.

Easy to understand, but what took the longest time was to find out where I get this list ID, that I needed to provide in the code. For everyone who doesn’t know as well (or is that long in the business to have already forgotten this):

get list ID

Navigate to your list, go to your list settings
The list ID is now in the URL of your browser and should look like this:
…list=%7B4895e009–4478–4153–94ef-05b172541d38%7D
Delete everything before “list=” and replace “%7B” by “{“ and “%7D” by “}”. Just in case your list name contains spaces, you need to replace all “%2D” by “-”. That’s it. You can now insert this ID (in my example it’s
{4895e009–4478–4153–94ef-05b172541d38}) into your code.

index the column you want to filter by

Next thing that needed my attention was that I obviously first needed to index my “status” column .

So I did this as well:

navigate to List settings, Indexed columns
then create a new index selecting “status” column as we want to filter by this

and tried again.

Make your data ready

So what happened when I set two items of my list to the status “ready” and played a bit with the colors and font size in CSS:

w00t! it works!

Boom — first trial and it already worked the way I wanted it to work! Again, this is seriously LEGO and you can’t do anything wrong as everything is already perfectly shaped and aligned with each other.

When I first read the blog title “Power of mgt-get”, I thought, “wow, what a click baiting title”. But then I realized how powerful this is web component is, because it is the most flexible one of all components. Instead of just having a very defined purpose like the components I learned about before, it can be used to get literally any data set from the Graph API.

Playing around with the Microsoft Graph Explorer let me realize, which amount of data regarding people, tools, services can be accessed there, possibilities seem to be endless!

Conclusion, Feedback and what’s next

Short and super concise blog post- short recap: mgt-get is the placeholder component in the Graph toolkit, which basically means that you can literally access ANY information in Graph API and make secure, lightweight and easy to build apps to display information that fit your business case. I am curious: What can you imagine? How do you want to use this power for?

If this post brought you some insights, joy or even food for thought, please clap for it and also follow me on twitter. Feel free to connect with me and share your thoughts. Can’t wait for next part of the #MSGraphToolkitLap, will blog about that soon.

Exploring Microsoft Graph Toolkit Lap as a non-developer -Part 3

Mon, 27 Apr 2020 11:52:00 +0000

This is part 3 of my blog series about the Microsoft Graph ToolKit Lap — a very hands-on approach by the Microsoft Graph Team to engage the developer community to start using the Toolkit. If you haven’t read the first parts, please catch up here. So you know that I am not a developer, but I just began to learn about how this set of web components works and how easily even I could change the look and feel of them by using some CSS. As a code newbie, this was not the most natural thing — but as with the provided resources, I was able to achieve the desired outcome — and thanks to the author MVP Hugo Bernier I learned much new stuff as well.

#MSGraphToolkitLap Day 5

In this part, MVP Fabio Franzini will continue, and I need to confess, when I first skimmed the post, I felt seriously intimidated. But Fabio explained everything in a very concise and well-structured way so I could follow.

templates

Wow, my learning curve is steep. I can tell you! A few days ago, I didn’t even have a clue that something like the Toolkit exists or what is a component or the fact that you style it using CSS custom properties — and today, I will learn how to use templates to change the UI. Learned that I could just add a