UMB.FYI Firehose - News

ProWorks.Umbraco.AI.PageEvaluator

Fri, 10 Apr 2026 00:00:00 Z

An Umbraco 17 backoffice package that adds an Evaluate Page button to the content editor toolbar. When clicked, it sends the current page's content to an AI model and returns a structured quality report directly inside the backoffice, including scored checks, warnings, and actionable suggestions.

File Uploads in Umbraco.AI

Thu, 09 Apr 2026 08:30:00 Z

File uploads have landed in Umbraco.AI. While the most visible change is in Copilot — where you can now drag and drop documents directly into the...

Our.Community.Tags.Popular

Thu, 09 Apr 2026 00:00:00 Z

A custom property editor for Umbraco 17 that displays the most-used tags in a named group and lets editors multi-select them to populate a sibling Tags property

Umbraco Cloud testimonials

Wed, 08 Apr 2026 12:24:47 Z

"We use Umbraco Cloud for almost all our clients—about 95% of them. The baseline functionality means we can spin up a site pretty quickly and get going fast, which reduces project time and budget while bringing more value to the customers." Find out more about Umbraco Cloud here: https://umbraco.com/products/umbraco-cloud/

ProWorks Umbraco AI Page Evaluator

Wed, 08 Apr 2026 08:00:00 Z

Indexing Word, Excel and PowerPoint Documents in Umbraco Using Examine

Wed, 08 Apr 2026 05:28:42 Z

Meet the nominees for the Umbraco Awards 2026!

Tue, 07 Apr 2026 14:43:09 Z

🚀 Meet the nominees for the Umbraco Awards 2026! From stunning design to AI innovation and cloud solutions, these projects showcase the best of our community 🏆 Check them out: umbra.co/3Oq6hY3 #Umbraco

Why Umbraco 17.4.0 Is a Big Deal for AI

Tue, 07 Apr 2026 08:30:00 Z

If you told most Umbraco developers to get excited about a minor release, you’d probably get a polite nod. Point releases aren’t usually the ones...

Announcing the 2026 Umbraco Awards Nominees 🏆

Tue, 07 Apr 2026 00:00:00 Z

The jury has nailed it down to the very best of each category - check out the impressive Umbraco Award 2026 Nominees 🏆

Skrift Issue #126

Tue, 07 Apr 2026 00:00:00 Z

Featuring guest posts by Bernadet Goey on "Admin Only property using Granular Permissions in Umbraco 17" and Dirk Seefeld on "PostgreSQL Support for Umbraco"

SplatDev.Umbraco.Plugins.Schema2Yaml

Sun, 05 Apr 2026 00:00:00 Z

An Umbraco plugin that exports your existing Umbraco schema and content to YAML format. Exports DataTypes, DocumentTypes, Media Types, Templates, Content, Media, Languages, Dictionary Items, Members, and Users to a declarative Infrastructure-as-Code YAML file. Supports Umbraco 13–17.

Skybrud.Umbraco.Redirects 17.0.4

Fri, 03 Apr 2026 23:19:02 Z

Award winning redirects manager for Umbraco.

Umbraco Spark 2026 is a wrap!

Thu, 02 Apr 2026 13:20:50 Z

Umbraco Spark 2026 is a wrap! ⚡What a fantastic day — full of inspiring sessions, thoughtful conversations and everything that makes this community so special.Huge thanks to everyone who made it happen 💛🎥 Highlights video attached — take a look!📝 Plus, all the conference buzz—read our blog: https://gibe.digital/blog/spark-2026-highlights-code-community-creativity/ 📅 Save the date: Friday 19th March 2027🎟 Tickets go on sale November 2026#umbracospark #umbraco #community #webevents #opensource

Umbraco AI Prompts: Template Syntax and Variables

Thu, 02 Apr 2026 08:30:00 Z

Following on from my Introducing Umbraco AI post, I wanted to dig deeper into one of the add-on packages that I think has the most immediately...

[Breaking change]: Casing on EF Core code constructs

Thu, 02 Apr 2026 07:34:59 Z

Our.Umbraco.PostgreSql

Thu, 02 Apr 2026 00:00:00 Z

Adds support for PostgreSQL to Umbraco CMS.

Umbraco.Community.Examine.OpenXml

Thu, 02 Apr 2026 00:00:00 Z

Extracts text content from OpenXml documents (.docx, .pptx, .xlsx) uploaded to the Umbraco media library and indexes it using Examine, making Office document content fully searchable.

Umbraco Spark 2026

Tue, 31 Mar 2026 21:00:00 Z

My notes and reflections from Umbraco Spark 2026 in Bristol. Covering every talk from Umbraco Search and backoffice collaboration to AI, cloud hosting and community.

Merchello v17 Starter Site Template now available

Tue, 31 Mar 2026 13:23:34 Z

Merchello Starter Site Template

AI agent workflows sneak peek

Tue, 31 Mar 2026 09:35:28 Z

Post | LinkedIn

Finding my Spark through Community

Tue, 31 Mar 2026 08:55:52 Z

(6) Finding my Spark through Community | LinkedIn

V17 of IconPicker has been released

Tue, 31 Mar 2026 08:26:38 Z

https://github.com/Ambertvu/Umbraco.Community.IconPicker/releases/tag/17.0.0 V17 of IconPicker has been released. - Add an sprite containing all the SVG's - Pick these in the backoffice - Render them as SVG in the frontend, so you can apply styles and effects!

Live from Spark 2026: AI, Play and the Human in the Loop

Tue, 31 Mar 2026 06:01:17 Z

Live from the Umbraco Spark Innovation Conference in Bristol! Emma, Laura and Lotte were joined by Phil Whittaker, AI Staff Engineer at Umbraco HQ - someone who's been thinking and talking about AI in development for longer than most. Together we talk about play as a superpower for developer learning, what returning from maternity leave looks like in an AI-transformed workplace, why developers approaching retirement are finding a second wind, and why augmentation beats automation every time.

A massive thank you to our live audience for missing out on the sunshine and making it so fun to record!

Links:

Umbraco Spark: https://umbracospark.com/
Phil Whittaker's blog: https://dev.to/phil-whittaker

uTPro.Feature.FileManager

Tue, 31 Mar 2026 00:00:00 Z

A powerful file management dashboard for Umbraco 16+ backoffice. Browse, upload, download, edit (with Monaco code editor), preview media, rename, delete, extract ZIP, and import files via URL. Features Windows Explorer-style navigation, role-based access control (Admin/Sensitive Data/Media), pagination for large directories, and URL state persistence. Zero configuration required.

Phases.Umbraco.Community.Tiptap.Rte.Emoji

Tue, 31 Mar 2026 00:00:00 Z

Adds a simple emoji picker to the Umbraco TipTap Rich Text Editor. Insert emojis directly into content using a searchable picker in the backoffice.

Umbraco.Community.TipTap.MarkdownImport

Tue, 31 Mar 2026 00:00:00 Z

Adds a Paste Markdown action to the Umbraco TipTap Rich Text Editor so editors can import Markdown into rich text fields as HTML content.

Optimizing Umbraco Member Pagination From Slow to Lightning Fast

Tue, 31 Mar 2026 00:00:00 Z

Umbraco.Community.DataTypeCleanup

Mon, 30 Mar 2026 00:00:00 Z

Clean up orphan data types, merge duplicates, and organize data types into folders by editor.

Searching file content with Umbraco Search

Mon, 30 Mar 2026 00:00:00 Z

Introducing a package for searching file content with Umbraco Search.

SplatDev.Umbraco.Plugins.Yaml2Schema

Mon, 30 Mar 2026 00:00:00 Z

A declarative, Infrastructure-as-Code style plugin for Umbraco 17 that enables programmatic creation of DataTypes, DocumentTypes, Templates, and Content from a YAML configuration file. Define your entire Umbraco structure in YAML — the plugin builds it automatically on startup.

Umbraco.Community.EnvironmentIndicator

Mon, 30 Mar 2026 00:00:00 Z

Makes Umbraco backoffice environments stand out with colored favicons and environment name badges in the header.

Content Lock 17.1.0 - aka the WebRTC Audio Calling edition

Fri, 27 Mar 2026 12:30:04 Z

Content Lock 17.1.0 - aka the WebRTC Audio Calling edition Latest release adds in audio calling to other logged in users of the backoffice with nothing to install. So that quick call to another editor to hurry up and unlock the homenode so you can get the press release out before lunch can be done without having to remember what Microsoft Teams account you need to login to Docs Site https://warrenbuckley.github.io/Umbraco.Community.ContentLock/ Marketplace https://marketplace.umbraco.com/package/umbraco.community.contentlock Nuget https://www.nuget.org/packages/Umbraco.Community.ContentLock

umbraCoffee - Spring Sips

Fri, 27 Mar 2026 08:51:45 Z

Welcome to your monthly dose of #umbraCoffee! Your hosts - Marcin and Callum - together with their guest(s) will drive through all of the community news and happenings in the Umbraco world. So... grab a cuppa, join us LIVE and enjoy! This time we're joined by Umbraco Hacker, Maker and Do'er - Warren Buckley - to talk about everything Umbraco from the past moth. See ya?! --- ☕ Wanna buy us a coffee/pizza/donuts? https://www.buymeacoffee.com/umbracoffee --- Notes: // ToDo:

Umbraco.Community.PropertyInfo

Fri, 27 Mar 2026 00:00:00 Z

Package Description

uTPro.Feature.AuditLog

Fri, 27 Mar 2026 00:00:00 Z

Audit Log viewer dashboard for Umbraco 16+ backoffice. Browse umbracoAudit and umbracoLog tables with filtering, search, and pagination.

Understanding Contexts in Umbraco AI

Fri, 27 Mar 2026 00:00:00 Z

In my introductory post, I gave a high-level overview of how Umbraco AI is structured — providers, connections, profiles, and contexts. Of those,...

Early concepts for Reuse Content of Blocks

Thu, 26 Mar 2026 13:08:18 Z

(4) Early concepts for Reuse Content of Blocks - YouTube

Modgift.Umbraco.CronInput

Thu, 26 Mar 2026 00:00:00 Z

A property editor for Umbraco that provides a cron expression input with real-time human-readable descriptions. As the user types a cron expression, a label beneath the input instantly translates it into plain language. Includes an optional validation setting to prevent publishing without a valid expression.

Announcing the Umbraco in AI Community Team & the AI in Umbraco Advisory Board

Thu, 26 Mar 2026 00:00:00 Z

Meet the 27 experts joining the Umbraco in AI Community Team and Advisory Board to help shape the future of AI tools and editor experiences within Umbraco.

Building an AI-Powered Log Analyser for Umbraco at the Spark Hackathon

Wed, 25 Mar 2026 09:50:08 Z

A look at how I built AI.LogAnalyser at the @umbracospark.bsky.social Hackathon - an open-source package that adds one-click AI analysis to the Umbraco backoffice log viewer. Powered by any AI provider via Umbraco AI. www.nevitech.co.uk/blog/buildin... #umbraco #ai #package

Rescope.ContentDelivery

Wed, 25 Mar 2026 00:00:00 Z

Improves swagger definitions for use with typed client generators

Umbraco.Community.UpDoc

Wed, 25 Mar 2026 00:00:00 Z

Create Umbraco documents from external sources (PDF, web pages, markdown) using configurable extraction workflows with rule-based field mapping.

Rescope.uAstro

Wed, 25 Mar 2026 00:00:00 Z

Automatically build and serve static Astro sites within Umbraco

MetaMateAI

Tue, 24 Mar 2026 00:00:00 Z

Umbraco plugin for generating creative meta title and meta description values for pages with missing metadata.

GitKraken CLI Beginner's Guide: A Better Git CLI for Developers

Tue, 24 Mar 2026 00:00:00 Z

Umbraco In Action - Introduction to CMS for students

Mon, 23 Mar 2026 06:57:07 Z

Just put out a blog + session recording from a talk I did with Coders Club students at Don Bosco College of Engineering, Fatorda. Started simple with “what is a CMS” before jumping into demos with Umbraco, headless setup with Next.js, and even a bit of AI. Good questions from the students, especially around WordPress vs Umbraco 👀 Blog Post: https://www.nathanielnunes.com/blog/umbraco-in-action-introduction-to-cms-for-students Video: https://youtu.be/znH8tnedIQg

Conzent.Umbraco

Mon, 23 Mar 2026 00:00:00 Z

GDPR, CCPA & ePrivacy compliant cookie consent banner for Umbraco. IAB TCF v2.3 and Google CMP Certified. Supports Conzent Cloud and self-hosted OCI.

Modgift.Umbraco.DataGrid

Sat, 21 Mar 2026 00:00:00 Z

A multiple column data editor property editor for Umbraco with strongly-typed DataGrid model.

Umbraco.Community.DeliveryApiModelMapper

Fri, 20 Mar 2026 00:00:00 Z

This package allows you to create custom models which will get ouput in the Delivery API response as a custom "model" property.

Growcreate.SchemaGenerator.DeployAddon

Fri, 20 Mar 2026 00:00:00 Z

Schema Generator for Umbraco to create and render schema objects. Map document type properties to schema properties and allow editors to populate additional schemas.

Jumoo.TranslationManager.Cleanup

Fri, 20 Mar 2026 00:00:00 Z

Prodvides health checks to clean up archived jobs and nodes.

Growcreate.SchemaGenerator.uSyncAddon

Fri, 20 Mar 2026 00:00:00 Z

Schema Generator for Umbraco to create and render schema objects. Map document type properties to schema properties and allow editors to populate additional schemas.

Umbraco.Community.AI.LogAnalyser

Fri, 20 Mar 2026 00:00:00 Z

Adds AI-powered log analysis to the Umbraco backoffice log viewer. Analyse any log entry with one click using your configured AI provider via Umbraco.AI.

Growcreate.SchemaGenerator.Core

Fri, 20 Mar 2026 00:00:00 Z

Schema Generator for Umbraco to create and render schema objects. Map document type properties to schema properties and allow editors to populate additional schemas.

Developer’s Guide to Creating a Custom Umbraco 17 Backoffice Dashboard

Fri, 20 Mar 2026 00:00:00 Z

Setting Up a New Umbraco Package Dev Environment with Umbraco.AI

Thu, 19 Mar 2026 09:30:57 Z

This guide walks through setting up a new Umbraco package project called Umbraco.Community.AI.Woowoo that extends Umbraco.AI. Rather than starting from scratch with a blank solution, the goal is a proper package structure from day one: the right project layout, a frontend build pipeline, uSync, GitHub Actions for NuGet publishing, the works.

That's where Lotte's Opinionated Package Starter Template comes in. Lotte has done the hard work of figuring out what a well-structured Umbraco package solution should look like, and turned it into a dotnet new template. Pair that with Matt Brailsford's Umbraco.AI Kitchen Sink install guide, and you have everything you need to go from zero to a fully wired-up Umbraco.AI development environment.

This post walks through the full setup, including the Linux-specific gotcha to watch out for.

Prerequisites

Before starting, make sure you have:

.NET 10 SDK -- Umbraco 17 targets .NET 10
Node.js and npm -- the package project uses Vite and TypeScript for its frontend
A GitHub account -- the template wires up a GitHub remote and includes GitHub Actions for NuGet publishing

Step 1: Install the template

Install the package starter template from NuGet:

dotnet new install Umbraco.Community.Templates.PackageStarter

You should see output ending with something like:

Success: Umbraco.Community.Templates.PackageStarter::X.X.X installed the following templates:
  umbracopackagestarter

What does this template give you?

When you scaffold from it, you get a complete two-project solution:

src/AI.Woowoo/ -- the package project, with Vite + TypeScript frontend (via the umbraco-extension template) and a NuGet-configured .csproj
src/AI.Woowoo.TestSite/ -- an Umbraco 17 test site with uSync pre-configured
src/AI.Woowoo.sln -- the solution file, with the TestSite already referencing the package project
.github/workflows/release.yml -- a GitHub Action that publishes to NuGet when you push a version tag
umbraco-marketplace.json, README stubs, issue templates, and an MIT LICENSE

That's a solid foundation for package development, covering all the scaffolding that would otherwise take hours to set up from scratch.

Step 2: Scaffold the solution

dotnet new umbracopackagestarter -n AI.Woowoo -an "Your Name" -gu YourGitHubUsername -gr Umbraco.Community.AI.Woowoo --allow-scripts yes

What each parameter does:

Parameter	What it does
`-n AI.Woowoo`	The base name for the solution. The template prepends `Umbraco.Community.`, so the NuGet package ID becomes `Umbraco.Community.AI.Woowoo`
`-an "Your Name"`	Author name, used in the `.csproj` and marketplace metadata
`-gu YourGitHubUsername`	Your GitHub username, used to construct the repo URL
`-gr Umbraco.Community.AI.Woowoo`	The GitHub repository name
`--allow-scripts yes`	Bypasses the security prompt for the post-creation script (`setup.cmd`), which runs `npm install` as part of the `umbraco-extension` template setup

This will take a few minutes -- npm install runs as part of the setup. Wait for the "All done!" message.

Step 3: The Linux/macOS gotcha -- `setup.cmd` won't run

If you're on Windows, you can skip this section. The template's setup.cmd script will have run fine and your solution is ready. Jump straight to Step 4.

On Linux and macOS, the setup.cmd post-creation script fails with "Permission denied" because it's a Windows batch file. The template files are all created correctly -- the script just doesn't run, so the git repository, the frontend scaffolding, the solution wiring, and a few other things need to be done manually.

Here's everything the script would have done, translated into commands you can run:

# Initialise the git repository
cd AI.Woowoo
git init
git branch -M main
git remote add origin https://github.com/YourGitHubUsername/Umbraco.Community.AI.Woowoo.git

# Make sure you have the latest Umbraco dotnet templates
dotnet new install Umbraco.Templates --force

# Scaffold the package project inside src/
cd src
dotnet new umbraco-extension -n "AI.Woowoo" --site-domain "https://localhost:44361" --include-example

# The template creates two .csproj files -- swap them so the NuGet-configured one is active
cd AI.Woowoo
rm AI.Woowoo.csproj
mv AI.Woowoo_nuget.csproj AI.Woowoo.csproj

# Wire everything up in the solution
cd ..
dotnet sln add "AI.Woowoo"
dotnet add "AI.Woowoo.TestSite/AI.Woowoo.TestSite.csproj" reference "AI.Woowoo/AI.Woowoo.csproj"

Tip: The repo root also contains a setup.mjs file -- a Node.js replacement for setup.cmd that works cross-platform. If it's present, running node setup.mjs handles all the steps above.

Step 4: Build the frontend & verify the base site

Before layering anything on top, confirm the scaffolded solution actually works. Build the frontend assets first:

cd src/AI.Woowoo/Client
npm install
npm run build

You should see Vite output with files written to dist/. Now start the TestSite:

cd ../../AI.Woowoo.TestSite
dotnet run

The launchSettings.json included by the template automatically sets ASPNETCORE_ENVIRONMENT=Development, so you don't need to set it yourself. On first run, Umbraco installs itself unattended -- watch the terminal output for the URL (typically https://localhost:44331 or similar).

Email: admin@example.com
Password: 1234567890

Check two things:

Navigate to the Content section -- an "Example Dashboard" should be there (this is the example added by the --include-example flag in the umbraco-extension template)
Navigate to /umbraco/swagger -- the Umbraco Management API document should appear in the dropdown

Once everything looks good, hit Ctrl+C to stop the site. You now have a clean, working base to build on.

Step 5: Add the Umbraco.AI packages

All the Umbraco.AI packages go into the TestSite project, not the package project. The package project stays clean -- it will only reference Umbraco.AI (or specific Umbraco.AI interfaces) when actually needed for package code. The TestSite is the development host.

Run these from the repo root (AI.Woowoo/):

# The Clean starter kit adds a demo content structure to the site
dotnet add "src/AI.Woowoo.TestSite" package Clean

# The core Umbraco.AI integration layer
dotnet add "src/AI.Woowoo.TestSite" package Umbraco.AI

# Addons
dotnet add "src/AI.Woowoo.TestSite" package Umbraco.AI.Prompt
dotnet add "src/AI.Woowoo.TestSite" package Umbraco.AI.Agent
dotnet add "src/AI.Woowoo.TestSite" package Umbraco.AI.Agent.Copilot --prerelease

# AI providers
dotnet add "src/AI.Woowoo.TestSite" package Umbraco.AI.Amazon
dotnet add "src/AI.Woowoo.TestSite" package Umbraco.AI.Anthropic
dotnet add "src/AI.Woowoo.TestSite" package Umbraco.AI.Google
dotnet add "src/AI.Woowoo.TestSite" package Umbraco.AI.MicrosoftFoundry
dotnet add "src/AI.Woowoo.TestSite" package Umbraco.AI.OpenAI

A couple of notes:

Umbraco.AI.Agent.Copilot requires --prerelease because it's still in alpha. The other packages are stable.
All five provider packages (Amazon Bedrock, Anthropic, Google, Microsoft Foundry, OpenAI) are installed so the environment is ready for any AI provider you or contributors want to test against. The seed data in the next step only activates the OpenAI connection, but the others are configured and waiting.

Check Matt's install guide if you're following along later -- version numbers may have moved on. The Umbraco.AI documentation covers all the extensibility points in detail if you want to go further.

Step 6: Add the seed demo data

Matt has a helpful GitHub Gist that seeds a full Umbraco.AI demo configuration: a connection, profile, context, prompts, and agents. It's a self-registering C# file -- drop it in the project and it registers itself via Umbraco's component system and seeds the data on first startup. It's also idempotent, so safe to leave in place.

curl -o src/AI.Woowoo.TestSite/UmbracoAISeedData.cs \
  "https://gist.githubusercontent.com/mattbrailsford/199d0b45e926ffb122fa96467039bd90/raw/UmbracoAISeedData.cs?v=2"

API key (optional)

The seed data installs an OpenAI connection with a dummy key. The site runs fine without a real key -- all the AI configuration gets seeded into the backoffice, the connection just won't be functional. Replace the key later through the Umbraco.AI section in the backoffice once everything is up and running.

Don't have an OpenAI key? Google hands out free Gemini API keys via Google AI Studio -- no credit card required. Hit "Create API key" in the top right, or "Get API key" in the left sidebar. The free tier is generous enough for development. If you go this route, use the Umbraco.AI.Google provider and configure the connection in the backoffice accordingly.

Step 7: Run and verify

cd src/AI.Woowoo.TestSite
dotnet run

Once it's running, log in (admin@example.com / 1234567890) and navigate to the Umbraco.AI section in the backoffice. You should see:

A seeded OpenAI connection
A profile
A context
Several prompts
Several agents

If you added a real API key, try running a prompt or agent to confirm the connection is live.

Step 8: Make the initial commit

Before staging everything, do a quick sanity check: open UmbracoAISeedData.cs and confirm there's no real API key in there.

git add .
git commit -m "chore: initial scaffold from Lotte's Opinionated Package Starter Template"
git push -u origin main

Prerequisite: before pushing, go to GitHub and create a new empty repository named Umbraco.Community.AI.Woowoo (skip the readme, license, and gitignore options -- the template already created those locally). The template already configured the remote, so git push goes straight to the right place.

What's next

The environment is now ready:

src/AI.Woowoo/ -- the package project, clean and ready for package code
src/AI.Woowoo.TestSite/ -- a full Umbraco 17 + Umbraco.AI host to develop and test against, with demo data seeded
GitHub Actions configured for NuGet publishing on version tags
All five AI providers installed and ready to configure

When it comes to implementing the package itself, the first thing to add to src/AI.Woowoo/AI.Woowoo.csproj is a reference to Umbraco.AI.Core -- the package that contains all the extension points (custom tools, middleware, guardrail evaluators, etc.):

dotnet add src/AI.Woowoo package Umbraco.AI.Core --version 1.6.0

Note that Umbraco.AI.Core 1.6.0 requires Umbraco.Cms 17.1.0 or higher. The template scaffolds the package project against 17.0.0, so bump the four Umbraco.Cms references in the same file to 17.1.0 when you add this.

The next step is implementing the Umbraco.Community.AI.Woowoo package itself -- but that's a story for another post.

Umbraco.Community.AI.PropertyValidation

Thu, 19 Mar 2026 00:00:00 Z

AI-powered property validation for Umbraco CMS using the Umbraco.AI infrastructure.

Kraftvaerk.Umbraco.Alchemy

Thu, 19 Mar 2026 00:00:00 Z

AI-powered developer assistant for the Umbraco backoffice — generates property descriptions, document type descriptions, UFM block labels, and content type icons.

Growcreate.SchemaGenerator

Thu, 19 Mar 2026 00:00:00 Z

Schema Generator for Umbraco to create and render schema objects. Map document type properties to schema properties and allow editors to populate additional schemas.

OC.PowerSort

Wed, 18 Mar 2026 00:00:00 Z

A powerful sorting extension for Umbraco CMS that provides enhanced sorting capabilities for content nodes in the backoffice.

OC.PowerSort package

Wed, 18 Mar 2026 00:00:00 Z

The Call for Speakers for UMBRAAD 2026 is open!

Tue, 17 Mar 2026 19:27:22 Z

🚀 The Call for Speakers for UMBRAAD 2026 is open! Take to the virtual stage and present your insights on digital accessibility to the Umbraco community during Global Accessibility Awareness Day. Whether you're an experienced presenter or simply passionate about enhancing the web, your contribution is welcome! Key Details:🗓️ Date: 21st May 2026💡 Topics: Neurodiversity, AI & Accessibility, Inclusive UX, Accessibility Fatigue, and more!Submit your session idea: https://sessionize.com/umbraad-2026/

Getting Started with Umbraco AI

Tue, 17 Mar 2026 11:56:09 Z

At last night's Umbraco Kent Meetup, I gave a live demo on the new AI integrations in the Umbraco back office. If you missed it - or just want a recap - I've put together a blog post covering everything. www.nevitech.co.uk/blog/getting... #umbraco #ai #umbracoai @umb.fyi

OC.UFMFallbacks Package

Tue, 17 Mar 2026 00:00:00 Z

Umbraco.Community.JobsJobsJobs

Tue, 17 Mar 2026 00:00:00 Z

Backoffice dashboard for recurring Umbraco background jobs with status, manual triggering, persisted run history, cooperative stop support, and opt-in CRON scheduling.

OC.UFMFallbacks

Tue, 17 Mar 2026 00:00:00 Z

An Umbraco package that extends Umbraco Flavored Markdown (UFM) with a {fbk:} component, giving you property fallbacks and text filters directly inside block labels and other UFM contexts.

Umbraco Recognized as a G2 Leader Across CMS and Headless in the Spring 2026 Reports

Tue, 17 Mar 2026 00:00:00 Z

See Umbraco’s Winter 2026 G2 results across CMS, Headless, DXP, and WebOps, including key badges, usability gains, and implementation highlights.

The Umbraco Playground — Experiment, build, and share 1

Mon, 16 Mar 2026 10:04:35 Z

Automatically Filter Content Delivery API Content

Mon, 16 Mar 2026 09:37:18 Z

Just Blogged: Automatically Filter Content Delivery API Content without applying a filter in querystring parameters.. https://richardsoeteman.net/blog/automatically-filter-content-delivery-api-content/

A Practical Guide to SVGs in Umbraco

Mon, 16 Mar 2026 09:22:37 Z

If you've ever tried to use SVGs properly in Umbraco, you'll know it's not quite plug-and-play. Icons, logos, illustrations - SVGs are everywhere on the modern web.

Out of the box Umbraco will let you upload SVGs. It even has a dedicated Vector Graphics (SVG) media type. But there are two things I wanted to improve.

The Two Problems

Inlining for CSS control.

If you serve an SVG as an <img> tag, it works - but you lose most of what makes SVGs useful. You can't style it with CSS, you can't use currentColor to inherit text colour, you can't target individual paths for hover states or animations. To get that level of control you need the SVG markup inlined directly into your HTML.

But inlining creates its own issues. An <img> tag sandboxes its content - scripts inside the SVG won't execute. Inline that same SVG into the page and any <script> tags or javascript: handlers will run. An editor could unknowingly upload an SVG containing an XSS attack, and you'd be serving it straight into the DOM. SVGs from design tools also come with hard-coded width and height attributes that fight your CSS when inlined - you want a viewBox instead.

Duplicate requests on <img> tags.
Not every SVG needs to be inlined. But when you call GetCropUrl() on a media item, Umbraco adds crop and resize parameters to the URL. So GetCropUrl(200) produces example.svg?width=200, and GetCropUrl(48) produces example.svg?width=48. The browser treats those as different URLs - meaning if you use the same SVG at multiple sizes, it gets downloaded multiple times instead of once. For a vector image that scales to any size, those parameters are pointless and the duplicate requests are pure waste.

Securing SVG Uploads

Since we're inlining SVGs into the page, we need to make sure they're safe before they get anywhere near the DOM.

Umbraco has an IFileStreamSecurityAnalyzer interface that gets called when media is uploaded. Umbraco doesn't ship with an SVG implementation, but the docs include an example. My version makes two changes to that example: it drops the xmlns check (since not all SVGs include it) and adds a check for javascript: protocol handlers:

internal class SvgXssSecurityAnalyzer : IFileStreamSecurityAnalyzer
{
    public bool ShouldHandle(Stream fileStream)
    {
        // reduce memory footprint by partially reading the file
        var startBuffer = new byte[256];
        var endBuffer = new byte[256];
        fileStream.ReadExactly(startBuffer);
        if (endBuffer.Length > fileStream.Length)
            fileStream.Seek(0, SeekOrigin.Begin);
        else
            fileStream.Seek(fileStream.Length - endBuffer.Length, SeekOrigin.Begin);
        fileStream.ReadExactly(endBuffer);
        var startString = Encoding.UTF8.GetString(startBuffer);
        var endString = Encoding.UTF8.GetString(endBuffer);
        return startString.Contains("<svg")
               && endString.Contains("/svg>");
    }

    public bool IsConsideredSafe(Stream fileStream)
    {
        // do not use a using as this will dispose of the underlying stream
        var streamReader = new StreamReader(fileStream);
        var fileContent = streamReader.ReadToEnd();
        return !(fileContent.Contains("<script")
                || fileContent.Contains("/script>")
                || fileContent.Contains("javascript:"));
    }
}

Registration is a single line in DI:

services.AddSingleton<IFileStreamSecurityAnalyzer, SvgXssSecurityAnalyzer>();

Storing SVG Content for Inline Rendering

To inline SVGs in your templates, you need the actual SVG markup available at render time. You could read the file on every request, but that's expensive. Storing the markup as a property on the media item means it gets served from Umbraco's cache instead of hitting IO on every render.

Add a custom property called svgContent to the Vector Graphics (SVG) media type in Umbraco, then create a notification handler that populates it automatically whenever an SVG is saved.

The property type matters here. A Label (string) won't work - SVG markup easily exceeds 512 characters. If you're on Umbraco 17.3.0+ the Label (long string) type stores as Text in the database, but on earlier 17.x versions there's a known issue where it's capped at 512 characters. If that affects you, you'll need a custom data type to store the content.

//Umbraco extension manifest:
export const manifests: Array<UmbExtensionManifest> = [
    {
        "type": "propertyEditorUi",
        "alias": "Website.PropertyEditorUi.LongLabel",
        "name": "Website Long label",
        "elementName": "umb-property-editor-ui-label",
        "meta": {
            "label": "Long Label",
            "icon": "icon-list",
            "group": "common",
            "propertyEditorSchemaAlias": "Umbraco.Plain.Json" //Means we get IHtmlEncodedString in c#
        }
    },
];

Using a MediaSavingNotification handler to read the file content, clean up the markup, and stores it in svgContent whenever an SVG is saved. For each SVG node it generates a viewBox from existing dimensions if one doesn't exist, strips width and height attributes, and removes the xmlns declaration. The viewBox logic here is based on the approach used in Our.Umbraco.TagHelpers - well worth a look if you haven't already:

HtmlDocument doc = new HtmlDocument();
doc.LoadHtml(fileContents);
var svgs = doc.DocumentNode.SelectNodes("//svg");

foreach (var svgNode in svgs)
{
    if (svgNode.Attributes.Contains("width")
        || svgNode.Attributes.Contains("height"))
    {
        if (!svgNode.Attributes.Contains("viewbox"))
        {
            if (!Decimal.TryParse(
                svgNode.GetAttributeValue("width", "0"),
                out var width)) width = 0;
            if (!Decimal.TryParse(
                svgNode.GetAttributeValue("height", "0"),
                out var height)) height = 0;
            svgNode.SetAttributeValue("viewbox",
                $"0 0 {width} {height}");
        }

        svgNode.Attributes.Remove("width");
        svgNode.Attributes.Remove("height");
    }

    svgNode.Attributes.Remove("xmlns");
}

This all happens once at upload time. Editors don't need to think about it. The full handler with error handling is in the complete example at the end of the post.

The handler is registered on the Umbraco builder:

builder.AddNotificationAsyncHandler<MediaSavingNotification, StoreSvgContentMediaSavingNotificationHandler>();

Cleaning Up the Image Pipeline for SVGs

Remember that issue with adding width and height to SVG output. here's how to fix that

what about something along this line?
The DontCropSvgsImageUrlGenerator wraps the default generator. If the image is an SVG, it creates a new ImageUrlGenerationOptions with only the URL - stripping all crop and resize parameters. Everything else passes through normally:

public string? GetImageUrl(ImageUrlGenerationOptions options)
{
    if (options?.ImageUrl == null)
    {
        return null;
    }

    if (options.ImageUrl.EndsWith(".svg"))
    {
        return _imageGenerator.GetImageUrl(
            new ImageUrlGenerationOptions(options.ImageUrl));
    }

    return _imageGenerator.GetImageUrl(options);
}

The registration replaces Umbraco's default IImageUrlGenerator, wrapping the original ImageSharpImageUrlGenerator inside the decorator:

services.RemoveAll<IImageUrlGenerator>(); //Umbraco only has one by default
services.AddSingleton<IImageUrlGenerator, DontCropSvgsImageUrlGenerator>(
    sp =>
    {
        var generator = new ImageSharpImageUrlGenerator(
            sp.GetRequiredService<SixLabors.ImageSharp.Configuration>(),
            sp.GetService<RequestAuthorizationUtilities>(),
            sp.GetRequiredService<IOptions<ImageSharpMiddlewareOptions>>());
        return new DontCropSvgsImageUrlGenerator(generator);
    });

Rendering the SVG Content

With all of this in place, using SVGs in Razor views is straightforward. An extension method on MediaWithCrops surfaces the stored SVG content (using the C# 14 extension members syntax on .NET 10):

extension(MediaWithCrops? media)
{
    public IHtmlEncodedString? SvgContent =>
        media?.Content is UmbracoMediaVectorGraphics svg
            && !svg.SvgContent.IsNullOrWhiteSpace()
            ? svg.SvgContent
            : null;
}

Then in a component, render the SVG inline if available, falling back to an <img> tag otherwise:

@if (Model.Icon.SvgContent is not null)
{
    @Model.Icon.SvgContent
}
else
{
    <img src="@Model.Icon.GetCropUrl(48, 48)"
         alt="@Model.Icon.GetAltText()" loading="lazy">
}

An alternative here would be to create a custom tag helper in a similar way to Our.Umbraco.TagHelpers.

Wrapping Up

Together it gives you a solid SVG story in Umbraco: editors upload SVGs as normal, the code secures them, fixes the sizing, and serves them from a single URL or inline with full CSS control as the developer and site need.

The Full Handler

Here's the complete StoreSvgContentMediaSavingNotificationHandler ready to copy-paste:

internal class StoreSvgContentMediaSavingNotificationHandler
    : INotificationAsyncHandler<MediaSavingNotification>
{
    private const string SvgContentPropertyAlias = "svgContent";

    private readonly MediaFileManager _mediaFileManager;
    private readonly ILogger<StoreSvgContentMediaSavingNotificationHandler> _logger;

    public StoreSvgContentMediaSavingNotificationHandler(
        MediaFileManager mediaFileManager,
        ILogger<StoreSvgContentMediaSavingNotificationHandler> logger)
    {
        _mediaFileManager = mediaFileManager;
        _logger = logger;
    }

    public async Task HandleAsync(
        MediaSavingNotification notification,
        CancellationToken cancellationToken)
    {
        foreach (var svg in notification.SavedEntities
            .Where(x => x.ContentType.Alias
                .InvariantEquals(UmbConstants.Conventions
                    .MediaTypes.VectorGraphicsAlias)))
        {
            if (svg.HasProperty(SvgContentPropertyAlias) is false) continue;
            try
            {
                using var content = _mediaFileManager.GetFile(svg, out _);
                using var reader = new StreamReader(content);
                var fileContents =
                    await reader.ReadToEndAsync(cancellationToken);

                HtmlDocument doc = new HtmlDocument();
                doc.LoadHtml(fileContents);
                var svgs = doc.DocumentNode.SelectNodes("//svg");

                foreach (var svgNode in svgs)
                {
                    if (svgNode.Attributes.Contains("width")
                        || svgNode.Attributes.Contains("height"))
                    {
                        if (!svgNode.Attributes.Contains("viewbox"))
                        {
                            if (!Decimal.TryParse(
                                svgNode.GetAttributeValue("width", "0"),
                                out var width)) width = 0;
                            if (!Decimal.TryParse(
                                svgNode.GetAttributeValue("height", "0"),
                                out var height)) height = 0;
                            svgNode.SetAttributeValue("viewbox",
                                $"0 0 {width} {height}");
                        }

                        svgNode.Attributes.Remove("width");
                        svgNode.Attributes.Remove("height");
                    }

                    svgNode.Attributes.Remove("xmlns");
                }

                fileContents = doc.DocumentNode.OuterHtml;
                svg.SetValue(SvgContentPropertyAlias, fileContents);
            }
            catch (Exception ex) when (ex is IOException
                || ex is FileNotFoundException)
            {
                _logger.LogError(ex,
                    "Unable to read file to set SVG content "
                    + "for media item with ID {MediaId}.",
                    svg.Id);
            }
        }
    }
}

References

OC.UFMMembersLookup package

Mon, 16 Mar 2026 00:00:00 Z

The Agent-Ready CMS: Introducing Agent Skills: Umbraco Backoffice Extension

Mon, 16 Mar 2026 00:00:00 Z

From turning rough ideas into working wireframes to building complex backoffice extensions without hallucinations, discover how we’re making AI a practical tool for Umbraco development.

Umbraco.Community.uRestore

Mon, 16 Mar 2026 00:00:00 Z

Extends the Umbraco backoffice with a Property Restore workspace tab, allowing editors to compare any saved content version against the current draft and selectively restore individual property values without affecting the rest of the content.

PulseForUmbraco

Mon, 16 Mar 2026 00:00:00 Z

Your Umbraco site's operational health monitor. Pulse scans your content, configuration, performance, and security — giving you an actionable health score and one-click remediation from inside the backoffice.

OC.UFMMemberLookup Package

Mon, 16 Mar 2026 00:00:00 Z

OC.UFMMemberLookup

Mon, 16 Mar 2026 00:00:00 Z

An Umbraco Flavoured Markdown extension to allow for searching Member data

Why Implicit Scoring Isn't Always Enough for Personalization

Mon, 16 Mar 2026 00:00:00 Z

Implicit scoring works great for most visitors, but what happens when the system gets it wrong? Let's take a look at how Explicit Scoring in Umbraco Engage gives marketers the confidence to stop guessing.

Limbo.Umbraco.Separator 17.0.0

Sun, 15 Mar 2026 20:58:37 Z

Limbo.Separator is a small package for Umbraco that adds a property editor serving as a separator to give a better overview of properties within your Umbraco content types.

Programmatically create Umbraco Members and set Password

Sun, 15 Mar 2026 14:19:20 Z

Over the last months, I've been working on moving websites from Umbraco 13 up to Umbraco 17. I had a really hard time to find good documentation on how to work with Members so I figured I'll write a short blog post to fill some of the "gaps" I experienced in the documentation.

What is Member in Umbraco?

A Member in Umbraco is an external or frontend user. In other words, this is the kind of account you would use for things like a customer area, intranet login, gated content, forums, and similar functionality on the public-facing site.

Working with Members programmatically

When working with Umbraco Members programmatically you need to familiarize your self with the IMemberService and the IMemberManager.

IMemberService is used to work with the IMember object, set username, email and update custom properties.
IMemberManager is used to perform login, get current member and set password.

Here is a code sample that will create a member programmatically and set the password programmatically.

public class MemberRegistrationService
{
    private readonly IMemberService _memberService;
    private readonly IMemberManager _memberManager;
    private readonly IPasswordHasher _passwordHasher;

    public MemberRegistrationService(
        IMemberService memberService,
        IMemberManager memberManager,
        IPasswordHasher passwordHasher
        )
    {
        _memberService = memberService;
        _memberManager = memberManager;
        _passwordHasher = passwordHasher;
    }

    public async Task<IMember> CreateMemberAsync(string email, string password, string name)
    {
        var member = _memberService.CreateMember(
            email,
            email,
            name,
            "Member"); // or Member.ModelTypeAlias with ModelsBuilder
        
        member.IsApproved = true;

        _memberService.Save(member);

        // Optionally add to a role
        _memberService.AssignRole(member.Id, "Member"); 

        // Set password
        var memberIdentity = await _memberManager.FindByIdAsync(member.Id.ToString());
        var passwordResult = await _memberManager.AddPasswordAsync(memberIdentity!, password);

        // Alternative way of setting password
        member.RawPasswordValue = _passwordHasher.HashPassword(password);

        return member;
    }
}

I'm learning python with AI and TDD

Sun, 15 Mar 2026 08:57:27 Z

I decided to make my next hobby project in python. I used this project to learn python, but also to become familiar with AI-assisted coding. In this article I document my experiences with AI as a pair programming buddy, doing Test-Driven Development together.

About TDD, the project and me

Test-Driven Development is about writing tests before writing your code. This is often done in the Red, Green, Refactor cycle: Write a failing test, specifying the behaviour that the code should exhibit, make all tests pass with as few changes as possible and finally make your code (and your tests) nice. It's a design tool that helps make your code easier to understand and maintain.

The project is a self-hosted information database that connects Animal Crossing Amiibos to information on Nookipedia. An API exposes the data so that an app can scan an amiibo and direct the user straight to the character's page on the Nookipedia. The project, besides providing desired functionality, is also an excuse for me to try out some enterprise software patterns that I wish to learn more about.

D-Inventor / my-animal-crossing-app

This is a hobby project. It is a combination of an app for android and a python-based server API. The server supplies information about Animal Crossing villagers. The app lets me scan Amiibo cards and then I can see basic information about the villager.

This is a hobby project. I wanted to get easy access to basic villager information from my Amiibo card collection.

This project combines an android app with a python-based API so that I can scan the NFC chip of an amiibo card and then fetch the information. That's all.

View on GitHub

I am a dotnet developer with very little python experience. Python has a special place in my heart, because it's the first language that I earned some money with. That was more than 10 years ago and I haven't touched python that much since then.

AI as a pair programming buddy

Most of the code in this project has been written by AI. Overall, the results were mostly good, sometimes very frustrating, but sometimes also very impressive.

Scaffolding a project baseline

Yes, AI got me started very quickly and effectively. I knew what I wanted: multiple python projects in a monorepo with some shared modules. I know what python code looks like, but actually setting up a project like this is quite a lot. Setting up testing with pytest, multiple independent modules with a shared pyproject.toml. Module imports are very confusing in python and if you don't know what you're doing, they're difficult to get right sometimes. I asked the AI to do it for me with working examples of unit tests and shared modules. It did all of it, the code ran, the tests worked and the code looked acceptable. Big win 💪

So many comments, so much "documentation"

It was really my own fault and it was quickly fixed. The AI was writing excessive comments. Every generated function filled with comments and "documentation", detailing exactly what the code does. That's not what I need comments for. I can read the code to see what it does. The thing here is that I let the AI generate its own instruction file and the instruction file literally instructed the AI to do this. I simply updated the instruction file and instructed the AI to never write comments.

Stop! Wait! Not so fast! Not so much!

Some people may find it wonderful: just tell the AI what you want to make and it'll happily build the whole thing for you. Or try to at least... Although it's magnificent, I think it's also incredibly irresponsible to let AI generate large amounts of code at once. Especially in a professional environment, I would be held personally responsible for bugs and mistakes and saying "it's the fault of the AI" simply will not fly. It's essential that I can review the code that the AI generates and I can only do this if I develop in small steps.

Test-Driven Development has been very helpful to put a leash on the AI. AI is very eager to write code and will simply sprint to the finish line if you let it. By strictly following the Red, Green, Refactor cycle, I was able to stay more in control of what the AI does and how it does it. It took a bit of trial-and-error, but the following instructions seemed to be very helpful:

Follow strict TDD practice with Red, Green and Refactor phases
Always run the test in the Red phase to verify that the test fails in the way that we expect
Prefer runtime failures over compile-time failures at all times
Prefer failures on assertions over failures in code under test whenever this is reasonable
Make sure in the green phase to write as little code as possible to make the test pass
Always ask for verification from the user after each phase before proceeding to the next

Additionally, it seemed helpful when I start each session with "We are pair programming buddies and we are going to do Test Driven Development". Nevertheless, the AI would still occasionally do more than I asked for, especially the green phase was difficult at times.

Please give me an example in the form of an automated test

In this project I needed a handful of slightly more advanced concepts, including:

Messaging
HTTP API calls
Database querying

Though the concepts are familiar, I had never done them in python specifically. I know approximately what good integrations look like, but I simply needed some examples in python specifically. AI has been an excellent tool for learning and it helped me to understand python frameworks, tools and syntax. By asking about it in the shape of an automated test, I could also immediately apply the concepts I learned with Test Driven Development. This was a massive win! I would like to share a particular experience that really blew my mind.

I needed to build an integration with an external HTTP API. Coincidentally, I recently also had to do this for work in dotnet, so I had a good idea what a good integration looks like and also how a good unit test looks for such an integration. It had taken me about 5 hours to build in dotnet. I asked the AI to generate me an example of a unit test that demonstrates an http request and response in python. the unit test was quite bloated and unreadable, but it did work. I told the AI as much and I gave it an example of what I expected the test to look like, based on a test that I wrote in dotnet. I asked to refactor the test to make it as close as possible to the example that I gave. In just a few minutes it generated exactly the testing utility that I had spent several hours on earlier! This was shocking and incredibly impressive.

Thoughts overall

In general, I find the workflow decent. Although I did get much further with AI in a shorter amount of time than I would have without, I don't believe (yet) that AI is a massive time-saver overall. That sounds like a contradiction, but you must see that it was my lack of understanding of the python ecosystem that held me back and not the speed by which I type code. Although the AI can create code much faster than me, the code is often not up to standards and at times I have had to throw away work of the past 10 minutes, because prompting for corrections was only making things worse.

An important thing, in my opinion, is that AI may replace your typing, but shouldn't replace your brain. The skills that I've developed as a professional developer are still required to judge the quality of the output and are still essential to prioritize long-term success over short-term gains.

So yeah, if you haven't tried it yet, perhaps you could also turn your AI into your TDD pair programming buddy. Thank you for reading and maybe I'll see you in my next blog! 😊

DigitalWonderlab.AccessibilityToolkit

Sat, 14 Mar 2026 00:00:00 Z

Comprehensive WCAG 2.1 accessibility auditing for Umbraco backoffice. 37 checks across Level A, AA, and AAA with scored results, scan history, site-wide audits, printable reports, and CSV export. Lightweight with no external dependencies — works on Umbraco Cloud and all hosting environments out of the box.

uProfile March 2026 - Debasish Gracias

Fri, 13 Mar 2026 00:00:00 Z

On a mission to inspire, connect, and bring together the global Umbraco community

Umbraco.Community.uAccessible

Fri, 13 Mar 2026 00:00:00 Z

Accessibility audit reports for your Umbraco content pages, directly in the backoffice.

A first look at load balancing the Umbraco backoffice

Thu, 12 Mar 2026 21:06:17 Z

When Umbraco 17 released there was a lot of focus on it being the first LTS version of Umbraco using the new web component based backoffice, and for a lot of people that was important enough in itself.

I must admit the only other feature I paid attention to is that dates now consistently have a timezone on them making it much easier to work with them.

However, one thing I somehow managed to miss completely was that as of Umbraco 17 you can now load balance the backoffice of Umbraco.

Isn't load balancing Umbraco an old feature?

Load balancing Umbraco sites has been around for longer than I have used Umbraco - so at least since v7!

It used to work a certain way as shown in this diagram based on the official documentation:

Source: Umbraco documentation

Which basically meant that what most people doing load balancing would do is spin up 2 Azure Web Apps, deploy the same code to both of them but have some settings that would designate one web app as the frontend app and one as the backend app.

Both apps would use the same database, and with some specific settings added you could allow the frontend app to scale out - for example by setting some rules that determines what amount of load the frontend should be under before it starts additional instances to automatically scale out.

This works pretty well, but also means that the minimal amount of infrastructure was 2 web apps - and if you had a lot of editors then there was no way to scale out the backend to accommodate extra load there.

Load balancing the backoffice

So the new thing in Umbraco 17 is that you can now load balance everything. One immediate effect that could have is that you now just need a single web app for a basic scale out site, something like this:

Shout out MermaidJS charts. AI agents are very good at translating described flows into charts, and it makes it so much easier to create visuals!

This setup could theoretically make it cheaper, and it's also easier to have a regular site running just 1 instance with the option of scaling out for big peaks in load without a bunch of extra setup!

So first you have to decide between the "old" way of load balancing with separate backend and frontend webapps and the "new" way of having a single scaleable app for both.

Secondly if choosing the "new" way of scaling a single app there is also a choice of whether the backoffice should use sticky sessions or be stateless.

There are a lot of articles about pros and cons for both:

But in short the difference is how traffic is distributed:

Sticky sessions

Once a request hits the load balancer it is assigned to an instance and a cookie is returned on the response that has a reference to that instance.
Future requests pass the cookie along to the load balancer, and it ensures that the new request hits the same instance.
If x amount of users cause the server resources to spike to the point that more instances are added based on the load balancing rules, you can end up having a lot of users "stick" to the initial instance due to their cookies.
If the instance a user is "stuck" to gets removed during a scale-down, the load balancer assigns them to a new instance - which can cause problems (more on that below).

Stateless

Once a request hits the load balancer it is assigned to the instance with the least load
This ensures a much more equal distribution between instances
This also makes things like sessions or SignalR connections a lot more complicated to manage

Setting up a backoffice load balanced site

The following setup applies to both sticky sessions and stateless, with the exception of SignalR which differs between the two and is covered separately at the end.

The assumption here is that the load balanced site will be hosted on Azure as a web app.
The current documentation will always be the most relevant resource: https://docs.umbraco.com/umbraco-cms/fundamentals/setup/server-setup/load-balancing/load-balancing-backoffice

As of writing this for Umbraco 17, there are some settings that should be set no matter if it is a sticky session or stateless setup:

Set Umbraco:Cms:Examine:LuceneDirectoryFactory to TempFileSystemDirectoryFactory
Set Umbraco:Cms:Hosting:LocalTempStorageLocation to EnvironmentTemp
Set the Server role accessor & IsolatedCaches:

public class LoadBalancingComposer : IComposer
{    
    public void Compose(IUmbracoBuilder builder)
    {        
        builder.LoadBalanceIsolatedCaches();
        builder.SetServerRegistrar(new StaticServerAccessor());
    }
}

public class StaticServerAccessor : IServerRoleAccessor
{
    public ServerRole CurrentServerRole => ServerRole.SchedulingPublisher;
}

Note: In the traditional setup you'd have one SchedulingPublisher and multiple Subscribers. With the new backoffice load balancing, check the current documentation for how server roles should be assigned, as this may differ from what you're used to.

Session management

If you use sticky sessions then it may seem like nothing is needed for managing sessions as you "stick" to one instance and that instance will handle your session just like on a non-loadbalanced site.

However, if you consider this scenario:

You run a webshop with automatic scaling set up & sticky sessions
You have a big sale, and the site scales up from 1 to 4 instances
A user is assigned to the 4th instance and starts adding things to their basket (which is stored as a session)
While that user is browsing traffic lowers, and the automatic scaling scales down to 3 instances
The user tries to add a new item to their basket - but the API controller request now hits the load balancer with a sticky session cookie to an instance that has been removed.
The load balancer assigns them to a new instance, which has no knowledge of their previous session. Their basket now only contains the item they just added - everything else is gone.

The same thing would happen for auth cookies as they use Data Protection - by default each instance generates its own encryption keys, meaning cookies encrypted on one instance can't be decrypted by another. So similarly to the example above, users may need to log in again each time they are moved to a new instance.

Dependent on your site this may not be a big problem, but if you use anything with sessions / auth cookies then it is very bad user experience.

Setting up out of process sessions and data protection

The solution to both the session and auth cookie problem is to move them out of the individual instances and into a shared store.

This is needed regardless of whether you use sticky sessions or stateless load balancing:

With sticky sessions, users are normally pinned to one instance - but as shown in the scenario above, scaling events can force them onto a different instance. Without shared sessions and data protection, that means lost session data and forced re-authentication.
With stateless load balancing, every single request can land on a different instance, making shared sessions and data protection essential for even basic functionality.

In this example we'll use Redis, but any IDistributedCache implementation would work.

You'll need the following NuGet packages:

There are three things we need to set up:

1. A shared distributed cache

builder.Services.AddStackExchangeRedisCache(options =>
{
    options.Configuration = redisConnectionString;
    options.InstanceName = "my-site-";
});

This registers Redis as the IDistributedCache implementation. By default, ASP.NET Core uses an in-memory implementation which is exactly what causes the problem - each instance has its own cache. By pointing this at a shared Redis instance, all app instances share the same cache.

The InstanceName is used as a key prefix in Redis, which is useful if you share a Redis instance across multiple applications.

As a bonus, Umbraco's content and media cache is built on Microsoft's HybridCache - which automatically uses any registered IDistributedCache as a second-level cache. So by registering Redis here, Umbraco will also use it to share its content and media cache across instances.

2. Session configuration

builder.Services.AddSession(options =>
{
    options.IdleTimeout = TimeSpan.FromMinutes(30);
    options.Cookie.HttpOnly = true;
    options.Cookie.IsEssential = true;
    options.Cookie.SecurePolicy = CookieSecurePolicy.Always;
});

ASP.NET Core sessions use whatever IDistributedCache is registered - so because we registered Redis above, sessions are now automatically stored in Redis instead of in-memory.

The cookie settings are worth noting:

HttpOnly prevents JavaScript from accessing the session cookie
IsEssential ensures the cookie is set even if the user hasn't consented to non-essential cookies
SecurePolicy = Always ensures the cookie is only sent over HTTPS

3. Shared Data Protection keys

var redisConnection = ConnectionMultiplexer.Connect(redisConnectionString);
builder.Services.AddDataProtection()
    .SetApplicationName("my-umbraco-site")
    .PersistKeysToStackExchangeRedis(redisConnection, "DataProtection-Keys");

This is what solves the auth cookie problem. By default, each instance generates its own Data Protection keys - meaning a cookie encrypted on instance 1 can't be decrypted by instance 2.

By persisting the keys to Redis and setting a shared ApplicationName, all instances use the same encryption keys. The ApplicationName is important - instances must share the same application name to be able to decrypt each other's cookies.

SignalR

This is the final piece of the puzzle, and the only one where the setup actually differs depending on whether you're using sticky sessions or stateless.

Umbraco uses SignalR in the backoffice for real-time client-to-server communication outside of standard HTTP requests - for example for preview functionality. In a load balanced setup, SignalR needs a way to send messages across all instances, not just the one the user is connected to. This is called a backplane.

Sticky sessions

With sticky sessions, client-side SignalR connections work as normal - the user has a persistent connection to one instance, just like on a single-server site. The only thing needed is a backplane so that server-side messages (like "this content was just published") can reach all instances.

Redis works well for this:

// Requires: Microsoft.AspNetCore.SignalR.StackExchangeRedis
builder.Services.AddSignalR().AddStackExchangeRedis(redisConnectionString);

Stateless

With stateless load balancing, each request can land on a different instance. SignalR relies on a persistent connection between client and server - and that connection can't just "jump" to a new instance on every request. So a Redis backplane alone isn't enough here.

The solution is to use a managed SignalR service like Azure SignalR Service, which handles both the backplane and the client-side connections externally:

// Requires: Microsoft.Azure.SignalR
builder.Services.AddSignalR().AddAzureSignalR(azureSignalRConnectionString);

This replaces the need for the Redis backplane entirely for SignalR - Azure SignalR Service handles everything. Note that you still need Redis for the distributed cache, sessions, and data protection as set up above.

Wrapping up

The stateless approach does give a smoother distribution of load across instances, but Azure SignalR Service adds a significant cost on top of the Redis you already need for everything else.

In most cases I would go with the sticky session setup - the lower cost and the simplicity of having everything managed through a single Redis instance makes it easy to set up and maintain. And once sessions and data protection are out of process, sticky sessions handle instance swaps gracefully anyway.

That said, I haven't done any load testing to compare the two approaches. If they scale differently under real-world traffic, that could easily be the biggest factor in choosing one over the other. This post is really just meant to highlight the differences and walk through the setup - not to declare a winner. Try both if you can, and pick what fits your situation.

Upgrade Umbraco 13 to 17: Property Editors + Property Value Converters

Thu, 12 Mar 2026 13:30:20 Z

This is part five in a series about common tasks you'll encounter when upgrading Umbraco 13 to 17. In this part, we’ll look at updating Property Editors and Property Value Converters.

When upgrading several packages, one area that caused confusion was Property Editors. In Umbraco 17 there is a much clearer separation between the UI in the backoffice and the data handling and validation on the backend (C#).

Because of this change, Umbraco introduced migrations that convert existing Data Types (which are essentially instances of a Property Editor) to the new format. In Umbraco 13 a Data Type only referenced a single editor alias, but in Umbraco 17 it contains two: an editor alias (backend) and an editor UI alias (frontend). This makes it possible, for example, to use multiple interchangeable UIs that work with the same underlying data.

Why won't my property editor work anymore?

After upgrading my database to Umbraco 17 I ran into a couple of issues:

How does Umbraco know that it should use my newly created Property Editor UI for existing properties?
Why does Models Builder suddenly return a JsonDocument instead of my custom VideoPlayerValueConverterModel?

The answer lies in understanding what the migration from Umbraco 13 to 14+ actually does and what you need to do with the result. This post walks through that process.

This blog explains how you can update your Property Editors to work in Umbraco 17 without having to create a custom migration. It also helps to read the Umbraco documentation on Property Editor composition. That documentation explains the different pieces that make up a Property Editor in Umbraco 17 and provides useful context for what follows.

The starting point before the migration

There are two different starting points for Property Editors in Umbraco 13, and each leads to a slightly different outcome during the migration to Umbraco 14+. The difference depends on whether the Property Editor is defined in a package.manifest file or in C# code.

Starting point 1: manifest-only Property Editor

In Umbraco 13 a Property Editor can be defined purely in a package.manifest, for example:

...
  "propertyEditors": [
    {
      "alias": "proudnerds.videoplayer.editor",
      "name": "Video player",
      "icon": "icon-play",
      "group": "Proud Nerds",
      "editor": {
        "view": "~/App_Plugins/ProudNerds.Umbraco.VideoPlayer/umbraco.videoplayer.html"
      }
    }
  ]
...

This is enough to create a simple data editor. The value is stored as a string in the database and there is no server-side validation. Anything can be stored as long as it fits into a string.

If needed, you can still transform that value later using a Property Value Converter before it ends up in the cache.

Starting point 2: Property Editor defined in code

You can also define a Property Editor in C#, for example:

using Umbraco.Cms.Core.PropertyEditors;

namespace YourProjectName;

[DataEditor(
    alias: "Suggestions editor",
    name: "Suggestions",
    view: "/App_Plugins/Suggestions/suggestion.html",
    Group = "Common",
    Icon = "icon-list")]
public class Suggestions : DataEditor
{
    public Suggestions(IDataValueEditorFactory dataValueEditorFactory)
        : base(dataValueEditorFactory)
    {            
    }
}

Defining a Property Editor in code gives you more control over validation and how the data is stored.

The resulting database records

When you create a Data Type in Umbraco 13 that uses a Property Editor, the resulting database record is almost identical for both approaches. Each Data Type simply stores a property editor alias and configuration in the umbracoDataType table.

If you register the editor in C#, the dbType may differ, but that detail is not important for this discussion.

The data migration (13 → 14+)

The difference between the two approaches becomes visible during migration.

In one of the later Umbraco 13 versions a pre-migration was introduced that prepares Property Editors for upgrading to Umbraco 14+. During this step, a record is written to the umbracoKeyValue table describing how each Data Type should be migrated.

For a manifest-only Property Editor, the record looks like this:

[{"DataTypeId":1055,
"EditorUiAlias":"proudnerds.videoplayer.editor",
"EditorAlias":"Umbraco.Plain.String"}]

However, if the editor was defined in C#, both aliases will be the same:

[{"DataTypeId":1055,
"EditorUiAlias":"proudnerds.videoplayer.editor",
"EditorAlias":"proudnerds.videoplayer.editor"}]

After the database upgrade to Umbraco 17, this information is used to populate the new propertyEditorAlias and propertyEditorUiAlias columns in the umbracoDataType table.

For the video player editor, the result of the migration looks like this:

Updating the code

Once you understand what the migration produced in the database, updating the code becomes much clearer.

Creating and registering the Property Editor UI

With the new backoffice introduced in Umbraco 14+, the UI part of your Property Editor needs to be recreated because AngularJS is no longer supported.

After creating the UI, you need to register it. I won't go into the details of building a Property Editor UI here (the documentation covers that), but the aliases you use during registration are important.

Based on the migration result:

alias should match PropertyEditorUiAlias
propertyEditorSchemaAlias should match PropertyEditorAlias

For example:

export const manifests: Array<UmbExtensionManifest> = [
{
    type: 'propertyEditorUi',
    alias: "proudnerds.videoplayer.editor",
    name: "Proud Nerds video player property editor",
    js: () => import("./proud-nerds-video-property-editor-ui.element"),
    meta: {
        label: "Video player",
        icon: "icon-play",
        group: "Proud Nerds",
        propertyEditorSchemaAlias: "Umbraco.Plain.Json",
        settings: {
            properties: [
                ...
            ]
        }
    }
}

Updating the DataEditor (if it already exists)

If your editor already had a DataEditor implementation, you can continue using it, but it needs to be updated for Umbraco 17.

Most of the implementation remains similar to Umbraco 13. The main difference is that several parameters have been removed from the DataEditor attribute because of the clearer separation between UI and backend logic.

// Umbraco 13
[DataEditor(
    alias: "proudnerds.videoplayer.editor",
    name: "Video Player",
    view: "/App_Plugins/VideoPlayer/videoplayer.html",
    Group = "Proud Nerds",
    Icon = "icon-play")]
public class VideoPlayerEditor : DataEditor
...

// Umbraco 17
[DataEditor("proudnerds.videoplayer.editor")]
public class VideoPlayerEditor : DataEditor
...

Updating the Property Value Converter (if needed)

If you used the manifest-only approach in Umbraco 13, there is a good chance your Property Value Converter no longer works.

During migration, the EditorAlias for the video editor changed from:

proudnerds.videoplayer.editor

to:

Umbraco.Plain.Json

So if your Property Value Converter checks the editor alias, it will no longer match:

public override bool IsConverter(IPublishedPropertyType propertyType) =>
propertyType.EditorAlias.Equals("proudnerds.videoplayer.editor");

The simplest fix is to check the EditorUiAlias instead:

public override bool IsConverter(IPublishedPropertyType propertyType) =>
propertyType.EditorUiAlias.Equals("proudnerds.videoplayer.editor");

This is not entirely semantically correct, but it is often the easiest solution without introducing additional migrations. After this, your Property Editor will work as expected again and the models builder will use your custom model instead of the generic JsonDocument.

Done

Once you understand how the Property Editor migration works, it becomes much easier to determine which aliases to use in umbraco-package.json and what code changes are required after upgrading.

The concepts themselves are straightforward, but the migration can be confusing the first time you encounter it. Hopefully this overview helps clarify what is happening behind the scenes.

EditorUiAlias or not?

Earlier I mentioned that checking EditorUiAlias inside the IsConverter method of a Property Value Converter is not entirely correct from a semantic point of view.

A Property Value Converter operates on the data stored in the database and converts that to something else to put in the cache. A Property Editor UI is only the interface used to edit that data. In fact, multiple UIs could theoretically exist for the same underlying editor.

Because of that, checking EditorUiAlias introduces some risk. If a different UI were introduced for the same editor, your converter might no longer match the correct data. Checking EditorAlias is the safest way to guarantee you are handling the expected data structure.

That said, in many real-world scenarios a Property Editor has exactly one UI and one DataEditor that always belong together. If you fully control the implementation, checking EditorUiAlias can be a pragmatic and perfectly workable solution that avoids writing additional migrations.

Opinions on this tend to differ. Some developers strongly prefer to always check EditorAlias for correctness, while others consider EditorUiAlias acceptable when the editor and UI are tightly coupled. In the end, the choice depends on how strictly you want to follow the separation between UI and data.

DevRel Deep Dive: Exploring Umbraco.AI with Matt Brailsford

Thu, 12 Mar 2026 10:24:56 Z

This week Sebastiaan and Lotte are joined by Matt Brailsford, Staff Engineer at Umbraco, to show Umbraco.AI in action. Umbraco.AI is Umbraco’s free and open source AI foundation and integration add-on for the CMS. It’s provider-agnostic, with NuGet packages for OpenAI, Anthropic and more. They also look at the other two main packages that Umbraco HQ has developed: Umbraco.AI.Prompt and Umbraco.AI.Agent. Watch, learn, and then try them for yourself! 📖 Matt’s "kitchen sink" getting started blog post: https://mattbrailsford.dev/umbraco-ai-kitchen-sink-install 👀 Umbraco.AI source code on GitHub: https://github.com/umbraco/Umbraco.AI -------- ❓ Looking for help with your Umbraco projects? Visit the Forum https://forum.umbraco.com 💬 Want to chat with the friendly Umbraco Community? Join our Discord server https://discord.umbraco.com ✉️ Got a question (or topic suggestion) for the HQ Developer Relations team? https://umbra.co/contact-devrel, or the ‘contact-devrel’ channel on Discord #Umbraco

Boost Your Website with Expert Umbraco Development Services

Thu, 12 Mar 2026 07:55:23 Z

In today’s competitive digital landscape, businesses need websites that are fast, scalable, and easy to manage.

Continue reading on Medium »

AI in Umbraco: Feature demo

Thu, 12 Mar 2026 07:16:58 Z

AI in Umbraco: Bolette Kern (CMS Product Manager) and Matt Brailsford (Staff Engineer) provide a deep dive into the rapid evolution of AI in Umbraco following the 2026 Winter Keynote. This update showcases how AI has transitioned from a nested setting to a core, dedicated section of the Umbraco back office, offering better organization and granular permission control for developers and content editors. The session covers significant functional upgrades to AI prompts and agents, including the ability to generate multiple content variations and the introduction of "Auto Agents" that intelligently select the best tool for your specific request. You will also get an exclusive first look at the upcoming Evaluation and Testing dashboard, designed to help organizations benchmark AI performance, accuracy, and cost. This video is for Umbraco developers, architects, and content strategists looking to leverage AI within their CMS workflows. Whether you are building custom AI integrations or using HQ packages, these updates provide the foundation for secure, scalable, and context-aware AI implementations. Video Chapters: 00:00 Introduction with Bolette Kern and Matt Brailsford 00:55 The New Dedicated AI Back Office Section 02:14 Enhanced Prompts: Generating Multiple Options 03:25 AI Agents vs. Prompts: Key Differences 04:05 Security: Permissions, Scopes, and User Group Overrides 05:30 Context Awareness and Location-Based Agents 06:35 The Auto Agent: Intelligent Prompt Routing 07:58 Preview: The AI Testing and Evaluation Dashboard 12:56 Developer Updates: Deploy, Notifications, and Field Validation 14:37 Future Outlook and Community Hackathons Key Takeaways: - Dedicated AI Workspace: AI now resides in its own back office section, improving discoverability and allowing for specific user permissions independent of the settings section. - Iterative Content Generation: Prompts can now return up to five different options simultaneously, allowing editors to compare and select the best result. - Granular Security: The new Scopes system allows administrators to group AI tools and manage access at the user group level for fine-grained control. - Intelligent Routing: The Auto Agent feature analyzes user intent to automatically trigger the most relevant specialist, such as a Legal Assistant or a Content Creator. - Quality Assurance: The upcoming Testing section allows for "mock data" evaluations and "graders" to ensure AI responses remain consistent as models evolve. Resources and Links: Umbraco AI Product Page: https://umbraco.com/ai/ Umbraco Winter Keynote (Reference): https://youtu.be/GK-eGhzZYpw Latest Release Blog Post: https://umbraco.com/blog/the-agent-ready-cms-what-are-agent-skills/ Umbraco Marketplace: https://marketplace.umbraco.com/package/umbraco.ai Developer Events and Hackathons: https://www.meetup.com/pro/umbraco/

Modgift.Umbraco.ImageUpload

Thu, 12 Mar 2026 00:00:00 Z

Automatically resizes and converts images uploaded to Umbraco CMS 17 media library.

Umbraco Product Update - Q1 2026

Thu, 12 Mar 2026 00:00:00 Z

Explore this update featuring the launch of Umbraco Compose, a new AI strategy, enhanced security in Umbraco Cloud, and a new era for Search.

Umbraco.Community.uSchema

Tue, 10 Mar 2026 00:00:00 Z

Validates JSON-LD structured data on published Umbraco content pages via a workspace tab in the backoffice.

Auto-Updating Your GitHub README with Your Latest Blog Posts

Tue, 10 Mar 2026 00:00:00 Z

Umbraco CMS Security Advisory, March 10, 2026

Tue, 10 Mar 2026 00:00:00 Z

Security patches are available for Umbraco versions 16 and 17 to fix three moderate-to-high vulnerabilities. Upgrade now to secure your CMS. Projects on Umbraco Cloud will automatically receive the fixes.

BackofficeThemes

Mon, 09 Mar 2026 00:00:00 Z

Extra themes for the Umbraco backoffice — including Christmas (theme plus snow, lights, tree, Santa hat) and popular editor-style themes: Neon, Cyberpunk, Dracula, Monokai, VS Blue, VS Cool Breeze, and VS Icy Mint.

One week left to submit your Umbraco Awards 2026 entry!

Fri, 06 Mar 2026 15:32:53 Z

One week left to submit your Umbraco Awards 2026 entry! 🕰️ No video needed - just the facts. Partners can turn entries into https://umbraco.com case studies for extra exposure. Streamlined form, minimal effort. Deadline: March 13. Submit: https://umbra.co/4l7zW42 #Umbraco

ValidationAttributes package now under the Umbraco Community GitHub account

Fri, 06 Mar 2026 09:59:31 Z

With blessings from the original author we have taken the ValidationAttributes package for Umbraco and forked it into a repo under the Umbraco Community GitHub account. I have released a stable for V17 that can be download now! https://marketplace.umbraco.com/package/umbraco.community.validationattributes #umbraco #community

The Umbraco Spark 2026 programme is now live

Thu, 05 Mar 2026 14:53:09 Z

The Umbraco Spark 2026 programme is now live 🎉Take a look at all the talks and timings for the day and start planning your day!It’s going to be a great one ✨👉 https://umbracospark.com/ #Umbraco #UmbracoSpark #WebCommunity

Securing Umbraco Images with HMAC

Thu, 05 Mar 2026 08:45:58 Z

Indexing media values for documents

Thu, 05 Mar 2026 00:00:00 Z

Leveraging the Umbraco Search extension model to index media ALT texts for their referenced documents.

How to Audit Umbraco Content for AI References (AEO / GEO Readiness)

Thu, 05 Mar 2026 00:00:00 Z

A practical Umbraco guide to AEO/GEO: how to structure content so AI systems can find, extract, and reference the right sections.

Umbraco.Community.ValidationAttributes

Thu, 05 Mar 2026 00:00:00 Z

[Umbraco v17+] Contains validation attributes to decorate your classes, but using Umbraco Dictionary as the resource.

Join Candid Contributions LIVE at Umbraco Spark

Wed, 04 Mar 2026 12:04:31 Z

🎙️ LIVE at Umbraco Spark!During lunch time, join us for a live session with Candid Contributions featuring special guests and open, honest conversations from the community.Grab your lunch, bring your thoughts and join the discussion.Details 👉 https://umbracospark.com/ #UmbracoSpark #OpenSource #CandidContributions

The Umbraco AI Kitchen Sink Install

Wed, 04 Mar 2026 11:19:26 Z

Since we released Umbraco AI, one of the most common bits of feedback I’ve heard is: “I want to try it, but I’m not sure which packages to...

AF.Umbraco.Redis.Connector

Wed, 04 Mar 2026 00:00:00 Z

Redis connector for Umbraco 15/16/17 (.NET 9/10). Auto-composes StackExchange.Redis distributed cache, persists ASP.NET Core Data Protection keys to Redis (default key: AF.Umbraco.Redis.Connector:_DataProtectionKeys), performs startup fail-fast connectivity validation, and includes optional smoke endpoints.

The Umbracian's Guide to Bristol (2026)

Tue, 03 Mar 2026 09:44:22 Z

Are you heading to Umbraco Spark and hoping to explore Bristol while you're here? I live near Bristol and now consider myself a Spark veteran, so thought I'd share my insights!

Skrift Issue #125

Tue, 03 Mar 2026 00:00:00 Z

Featuring guest posts by Nathaniel Grantham-Knight on "Building An Umbraco Property Editor With Vite" and Tim Payne on "Web Development and Ultrarunning Have More in Common Than You Might Think"

The Agent-Ready CMS: What are Agent Skills?

Tue, 03 Mar 2026 00:00:00 Z

Discover how Agent Skills and MCP are transforming Umbraco into an Agent-Ready CMS. Learn to power intelligent actions and future-proof your agency's workflow.

Umbraco MVP nominations deadline near

Tue, 03 Mar 2026 00:00:00 Z

Skybrud.Umbraco.Redirects 17.0.3

Mon, 02 Mar 2026 23:13:30 Z

Award winning redirects manager for Umbraco.

Umbraco Codegarden 2026 program is live

Mon, 02 Mar 2026 13:07:15 Z

“Should we just… put the program live?”“Yes.”“Like… now?”“Yes.”“Should our CEO hold a sign?”“Obviously.”So here we are.Codegarden 2026 program = LIVE 🪧💙Two full days.45+ sessions.60+ speakers.3 podcasts.4 workshops. Tech and business - all in one place.We’ll be there. Will you?Explore the full program and secure your spot 👇https://codegarden.umbraco.com/program/ #Umbraco

Koola.ParentDropDown

Sat, 28 Feb 2026 00:00:00 Z

Umbraco 17 property editor that resolves options from a parent-defined root picker and supports checkbox, radio, and dropdown selection modes.

Running GitHub Actions .NET and Azure workflows locally with Act

Fri, 27 Feb 2026 11:29:14 Z

Act is a fantastic tool for testing GitHub actions locally instead of pushing that 10th commit in a row called Testing GitHub Actions (again) but configuring it to work correctly can be a balancing act, so here are some tips for getting Act working with your .NET CI/CD flows.

Introducing docs.jcdc.dev

Fri, 27 Feb 2026 11:00:00 Z

Explore the new documentation website for all jcdcdev Umbraco packages. Built with Astro and Starlight for high performance and low carbon impact, featuring automated synchronisation across GitHub and the Umbraco Content Delivery API.

Battle scarred developer's guide to Umbraco v17 -Workspaces

Fri, 27 Feb 2026 09:50:36 Z

All the code for this series of posts is available in the DoStuffWithUmbraco Repository on GitHub

In the last article we got to the point where we had our own custom section, with a side menu (or "sidebarApp") and a basic menu item.
but for now clicking on that menu item just shows us some loading dots 😞

What we need to do know is define a workspace.

So what are workspaces ? well to lift the description directly from the umbraco docs :

Workspaces provide dedicated editing environments for specific entity types in Umbraco. They create isolated areas where users can edit content, media, members, or other entities with specialized interfaces and functionality.

basically menu items are assigned an 'entity type' and when you click on them Umbraco looks for the workspace that renders that entity type.

entity types are really just Identifiers at this point, usually you might have in two entity types a 'root' and and 'item' - the root is as you might expect the one at the root, and the item is an item in your tree (if you have one.

Item workspace

For our "simple" time item, we only have a single "do-stuff-time-item" entity type, and that's the one we need to build a workspace for to show information to the user.

Workspaces at their most basic have two things, a workspace context and a workspace element.

Workspace Context

Your workspace context is the code that controls the state and data for your workspace. here you have all your data and ways to fetch and save it.

To be clear, you don't need to do this in a context, you can just fetch , store and manipulate data in the element, but as you will see in a bit, that is probably going to lead to duplication and a more complex bunch of code

So without being to complicated a workspace will look something like this:

export class MySampleWorkspaceContext 
  extends UmbEditableWorkspaceContextBase<TimeSettings>
  implements UmbSubmittableWorkspaceContext
{
  #settingsRepository = new DoStuffTimeSettingsRepository(this);
  readonly unique: Observable<string | null | undefined>;

  public readonly workspaceAlias = DOSTUFF_WORKSPACE_ALIAS;

  constructor(host: UmbControllerHost) {
    super(host, DOSTUFF_WORKSPACE_ALIAS);
    this.provideContext(DOSTUFF_WORKSPACE_CONTEXT, this);
  }

  getUnique() {
    return undefined;
  }

  getData() {
    return this.#timeSettings.value;
  }

  getEntityType() {
    return DOSTUFF_TIME_ITEM_ALIAS;
  }

  protected submit() {
    const settings = this.#timeSettings.value;
    if (!settings) return;
    await this.#settingsRepository.saveTimeSettings(settings);
  }
}

Workspaces can even be simpler than this, but here we are implementing a UmbSubmittableWorkspaceContext because we want to be able to save things that we update on our context, if you don't want to tie into other things like workspace actions, you don't need to do this, but its a relatively simple implementation, so in my opinion it's worth it.

There are few things we are going to pick out in the context :

ProvideContext

You can see that inside the constructor for the context we are calling this.provideContext . this tells the rest of the app, that we are responsible for the DOSTUFF_WORKSPACE_CONTEXT so if anything wants to interact with this context they can. by asking for it in their own constructor.

For example - a view might ask for the context like this.

this.consumeContext(DOSTUFF_WORKSPACE_CONTEXT, (context) => {
  // do stuff with the context here.
});

Workspace contexts have a scope, they will only exist while you are in the workspace, you can't call a workspace context from somewhere else or another section - if you need to do that you might need a global context, which work in a similar way they are just defined slightly differently

Repositories

Another thing you might have noticed about this context is we randomly just call save in a #settingsRepository and we've haven't told you what one of them is yet - we will get to them in a bit.

But for now, that's just the place where the actual calls to API end points and the like are stored - it means our context doesn't need to know the inner workings of the API it can just say go get this or save that.

Views

So now we have registered our workspace and we have a workspace context, you will notice, we still have nothing to show to our user! So now its time to fix that, and present them with something. You define what things show in a workspace via workspaceView elements.

again we define these in a manifest.

   type: "workspaceView",
    alias: "DoStuff.DefaultWorkspaceView",
    name: "DoStuff Default Workspace View",
    js: () => import("./default-workspace-view.element.js"),
    weight: 500,
    meta: {
      label: "#doStuff_defaultWorkspaceViewName",
      pathname: "default",
      icon: "icon-alarm-clock",
    },
    conditions: [
      {
        alias: "Umb.Condition.WorkspaceAlias",
        match: DOSTUFF_WORKSPACE_ALIAS,
      },
    ],
  },

So the things to note :

the js entry points the file that will render the element
the meta data defines the name and icon for the view
the conditions make sure our view only shows up on our workspace.

View element

The view element is a UmbLitElement that renders what you want to show the user

@customElement("do-stuff-default-workspace-view-element")
export class DoStuffDefaultWorkspaceViewElement extends UmbLitElement {

  override render() {
    return html`<umb-body-layout>
      <div class="layout">
        <uui-box
          .headline=${this.localize.term("doStuff_defaultWorkspaceTitle")}
        >
          <h1>Hello Time</h1>
        </uui-box>
      </div>
    </umb-body-layout>`;
  }
}

With this in place we get something to show the user !

Multiple views, and icons.

So we defined that icon, and name, but it's not anywhere on the screen, what's up with that?.

Well the icon and name are used when we have multiple views in a workspace. so if we add another workspaceView manifest to the workspace

{
  type: "workspaceView",
  alias: "DoStuff.SettingsWorkspaceView",
  name: "DoStuff Settings Workspace View",
  js: () => import("./settings-workspace-view.element.js"),
  weight: 200,
  meta: {
    label: "#doStuff_settingsWorkspaceViewName",
    pathname: "settings",
    icon: "icon-settings",
  },
  conditions: [
    {
      alias: "Umb.Condition.WorkspaceAlias",
      match: DOSTUFF_WORKSPACE_ALIAS,
    },
  ],
},

We get our 'tabs'

Summarry

This gets us the skeleton of our workspace up and showing something to the user - there is much more to workspaces , and we will go into them in some later posts, but for now, we have a section, a menu and some workspaces. so 🎉

How I used Umbraco.AI for free

Fri, 27 Feb 2026 00:00:00 Z

How I used Umbraco.AI for free

Fri, 27 Feb 2026 00:00:00 Z

Umbraco testing examples now also for Umbraco 17

Wed, 25 Feb 2026 17:48:29 Z

I updated my testing examples repository to the latest Umbraco version.

D-Inventor / automated-testing-in-umbraco

A working example of integration- and unittests with Umbraco. A demonstration of various concepts for testing your Umbraco website

Umbraco 17 automated testing setup

This project is a fully functioning setup for automated testing with Umbraco 17. You can use this project as a reference or starting point to get started with testing on your Umbraco website. The tests are set up with Test Driven Development (TDD) in mind.

Tools

The most important tools that are used in the automated tests are as follows:

Name	Description
xUnit v3	The testing framework. You can use any testing framework that you like though
NSubstitute	Library for mocking. Any mocking library will work. This project doesn't do extensive mocking, but for example `IPublishedValueFallback` is a mandatory parameter for any published content item, even if you don't actually use it. It's just convenient to insert a mock.
Test Containers	Automatically creates docker containers while running tests. It is used to create an empty SQL Server database that is automatically cleaned up after testing.

…

View on GitHub

Though not much has changed, here are the most notable differences compared to the Umbraco 16 version

Database initialization

The SqlServerDatabase resource no longer creates a second database inside the SqlServer test container. While Umbraco 16 would happily create a new database on boot if it didn't exist yet, Umbraco 17 does not and will throw connection errors.

For your regular use of Umbraco, this change makes no significant difference. If you also use EF Core, you may need to pay some extra attention here!

A base URL for integration tests

The WebsiteFixture will now set a fixed base URL when creating a backoffice httpclient. If you need to use a different domain, this base URL can be adapted, but what is important is that the URL uses https protocol. Compared to Umbraco 16, Umbraco 17 requires https to backoffice endpoints by default and requests using http are rejected by default. That's at least what the error would indicate.

If you want to see all the changes, you can check out this commit:
https://github.com/D-Inventor/automated-testing-in-umbraco/commit/573ef96a155c390ba3d4383bf555f9ff5723b3b4

An additional note

I have given some attention to the example website under test in this repository. The homepage at least has a slightly more fancy template, but it's all static content. I haven't yet taken the time to really tie it all together, and I wanted to do so using Test Driven Development, which is the main focus of this example repository.

I noticed that the version of playwright for C# doesn't actually let you compare screenshots!? This was a mild surprise and disappointment, because that means I can't actually use snapshot testing to ensure my template doesn't accidentally change when I implement the logic. The Javascript version of playwright does seem to support it, so I guess for better end-to-end testing, we'd need to create an equivalent management API client and scenario builder. Oof!

That's all

that's all I wanted to share! Hope you check out the repository, give it a star and let me know if the testing examples have been helpful to you or not! Thank you for reading 😊

Battle scarred developer's guide to Umbraco v17 - Sections

Wed, 25 Feb 2026 17:21:17 Z

So now, we are getting into the code! as with all the bits in this series all the code is available on the DoStuffWithUmbraco repo.

1. Sections

(see DoStuffWithUmbracoRepo : Sections)

A section in umbraco is something accessed from the top bar navigation menu.

Its quite simple to add a new section - all you need is the manifest.

const sectionManifest: UmbExtensionManifest = {
  type: "section",
  alias: DOSTUFF_SECTION_ALIAS,
  name: "DoStuff Section",
  weight: 10,
  meta: {
    label: "#doStuff_sectionName",
    pathname: "do-stuff",
  },
};

Constants
Here we have used a constant for the alias, because its often true you will need to reference the section alias in other places on your site.

The alias is defined in another file.
export const DOSTUFF_SECTION_ALIAS = "DoStuff.Section";
and this replaces the string value in the manifest.

Localization
You might also notice that the label value starts with a '#', this tells umbraco that we want to use a localize value for the label. we will cover them a bit later, but for now just to so you know you can just put a string in for the label value if you want

2. Dashboard

(see DoStuffWithUmbraco repo : Dashboards)

At this point your section is quite empty, but you can add a dashboard quite easily to get some content in there.

Dashboards are pages that sit at the top level of a section, almost all the sections in umbraco already have dashboards (Content has news, and redirect, settings has, examine, health checks and profiling to name a few).

you can add your own dashboard to your own sections or existing sections as you choose.

const dashboardManifest: UmbExtensionManifest = {
  type: "dashboard",
  alias: "DoStuff.Dashboard",
  name: "DoStuff Dashboard",
  js: () => import("./dashboard.element.js"),
  meta: {
    label: "#DoStuff_DashboardName",
    pathname: "do-stuff-dashboard",
  },
  conditions: [
    {
      alias: "Umb.Condition.SectionAlias",
      match: DOSTUFF_SECTION_ALIAS,
    },
  ],
};

Here we define the alias and element we want to use for our dashboard, and the condition determines where it lives.

there are all sorts of conditions in umbraco, but here we are saying if the section alias is that of our custom section then we are happy. If we didn't have a condition the dashboard would appear in all sections

Again note the use of a constant for the section alias_

Dashboards are WebComponents, they are probibly the simplest ones in umbraco you don't have to inherit anything (if you don't want to) - there are no contexts, or stores or tree's required, you element can just render some HTML.

@customElement("do-stuff-dashboard-element")
export class DoStuffDashboardElement extends UmbLitElement {
  override render() {
    return html`<umb-body-layout
      .headline=${this.localize.term("doStuff_dashboardTitle")}
    >
      <uui-box>
        <umb-localize key="doStuff_dashboardIntro"></umb-localize>
      </uui-box>
    </umb-body-layout>`;
  }
}

export default DoStuffDashboardElement;

Note : We do inherit from UmbLitElement as opposed to LitElement, this gives you access to the localization helpers amongst other things, so it's worth doing, even though you don't have to.

3. Sidebar App.

You have probibly notices that almost all existing sections in umbraco have some form of menu or tree down the left hand side. In Umbraco speak this is a "SidebarApp" and it can contain almost anything! - but usually its menu items and trees.

A sidebar is registered in a manifest file.

const sidebarManifest: UmbExtensionManifest = {
  type: "sectionSidebarApp",
  kind: "menu",
  alias: "DoStuff.SectionSidebarApp",
  name: "DoStuff Section Sidebar App",
  meta: {
    label: "#doStuff_sidebarStaticAppName",
    menu: "DoStuff.Static.Menu",
  },
  conditions: [
    {
      alias: "Umb.Condition.SectionAlias",
      match: DOSTUFF_SECTION_ALIAS,
    },
  ],
};

On its own a sidebar app is quite empty.

So we need to add some menus and items.

4. Menus

Within a standard sidebar you can have a number of 'menus' these are the sections you see in the settings section, "Structure", "Templating" and "Advanced" are Menus

to add your own, we have a manifest.

const menuManifest: UmbExtensionManifest = {
  type: "menu",
  alias: "DoStuff.Static.Menu",
  name: "DoStuff Static Menu",
};

but with out any menu items you won't see much , so lets add a menu item.

const timeItemManifest: UmbExtensionManifest = {
  type: "menuItem",
  alias: "DoStuff.TimeItem",
  name: "DoStuff Time Item",
  weight: 10,
  meta: {
    label: "#doStuff_timeItemName",
    icon: "icon-time",
    entityType: DOSTUFF_TIME_ITEM_ALIAS,
    menus: ["DoStuff.Static.Menu"],
  },
};

You can see how we assign the menu item to the menu, and the menu is actually assigned in the section definition.

Don't worry to much about the entityType just yet, its going to get funky when we talk about workspaces. but for now lets just bask in the menu glory.

All the client code in this article is available in the DoStuffWithUmbraco Client repo

Battle scarred developer's guide to Umbraco v17 - Entry Points

Wed, 25 Feb 2026 17:21:02 Z

So now that bundles have replaced entry points as the place to integrate your Umbraco extension, do we still need entry points?

Yes, i most cases you will still need an entry point, to initialize things like the authentication for your client to talk to the server. or if you are feeling really mischievous to unload other entries from the umbraco registry !

Register your entry point via a manifest.

all the extension template will do this one for you, but to show the process

export const manifests: Array<UmbExtensionManifest> = [
  {
    name: "Do Stuff Client Entrypoint",
    alias: "DoStuff.Client.Entrypoint",
    type: "backofficeEntryPoint",
    js: () => import("./entrypoint.js"),
  },
];

this is then imported and registered via your bundle.manifest.ts file.

Auth.

The examples that you get with the templates contain most of the code you will need here for authentication.

 _host.consumeContext(UMB_AUTH_CONTEXT, async (authContext) => {
    // Get the token info from Umbraco
    const config = authContext?.getOpenApiConfiguration();

    client.setConfig({
      auth: config?.token ?? undefined,
      baseUrl: config?.base ?? "",
      credentials: config?.credentials ?? "same-origin",
    });
  });
};

As we've said in another post we like to add a bit - which keeps the token fresh for each request.

    // client interceptor will get the latest token for the auth
    // context for a request, so if the token has been refreshed
    // since we first got it, we'll still have a valid token.
    client.interceptors.request.use(async (request, _options) => {
      const token = await authContext?.getLatestToken();
      request.headers.set("Authorization", `Bearer ${token}`);
      return request;
    });

honesty - i am not 100% sure this extra bit is in fact needed - it's something we might revisit.

Unregistering things!

So your onInit method runs when your extension is loaded, and you can if you want start to manipulate Umbraco's register, you could for example remove the welcome dashboard this way.

extensionRegistry.unregister('Umb.Dashboard.UmbracoNews');

Be carefull! removing things from the register might well make bits of the umbraco backoffice unstable.

Battle scarred developer's guide to Umbraco v17 - Bundles

Wed, 25 Feb 2026 17:20:52 Z

With the Early adopters guide we talked about Entry points as the start of your front end code journey, but now with a few tweaks since v14 bundles are where it's at.

What's a bundle.

A bundle is an extension point in Umbraco's Backoffice that lets you load JavaScript files and register manifests inside Umbraco's system so your code is loaded as part of the Backoffice.

Put simply it's the loader of your extension.

typically your entry point javascript file will only import manifest from around your project and return them for umbraco to ingest.

export const manifests: Array<UmbExtensionManifest> = [
  ...entrypoints,
  ...sectionManifests,
  ...dashboardManifests,
  ...localizationManifests,
  ...menuManifests,
  ...workspaceManifests,
  ...editorManifests,
  ...modalManifests,
];

As your project grows so will this list, to keep it simple and organised i would recommend that at each level you have manifest that might also import from child folders, before finally having everything brought into the bundle file.

For example in the DoStuffWithUmbraco repository. we might have a /workspaces/views/manfiest.ts file, that is then imported into the /workspace/manifest.ts file which is the one we import into our bundle file.

+-- src
  - bundle.manifest.ts
  +-- workspaces
    - manifest.ts
    +-- views
      - manifest.ts

This means everything needed for the workspace is in /workspace/manifest.ts and we can if need be move it about knowing it's all there. It also means any one manifest definition file doesn't contain two much information.

What about manifests in umbraco-package.json

There is quite a bit in the umbraco docs about how you can define your manifests inside the umbraco-package.json file, and you can, but once you go beyond something very very basic (e.g. not just adding localization). you will want to do it via a bundle.

Adding all the manifests via the bundle gives you better typescript & checking support in your project, its neater and it catches the errors quicker.

Adding via the umbraco-package.json also requires that the site be restarted for the packages to be loaded (these files are read in by the Backoffice code on start-up). using a bundle as the entry point you can add new things build the scripts and it all appears.

Battle scarred developer's guide to Umbraco v17 - Setup

Wed, 25 Feb 2026 17:20:43 Z

In our previous post we've gotten our basic structure for our umbraco extension, but before we dive into code. there are a couple things i like to tweak.

You can choose to ignore this post!, these are my personal preferences for some of the more obscure bits of the setup, they are not required but they can make things a bit easier later on.

PackageManifestReader vs umbraco-package.json

umbraco-package.json

When you create a new umbraco extension you will get a umbraco-package.json file created in your client/public folder. this file defines the entry point for Umbraco to fetch and initialize your package

{
  "id": "MySuperPackage",
  "name": "MySuperPackage",
  "version": "0.0.0",
  "allowTelemetry": true,
  "extensions": [
    {
      "name": "My Super Package Bundle",
      "alias": "MySuperPackage.Bundle",
      "type": "bundle",
      "js": "/App_Plugins/MySuperPackage/my-super-package.js"
    }
  ]
}

and this works fine - but it has one or two issues.

1. the version number is just sitting there in a json file.
This can be a pain, because what happens when you release a new version ?well you either have to change this value or run some form of build script to change it for you.

2. the JavaScript file never changes and might be cached between releases
Because the main JavaScript file is in this file it doesn't change between releases, this means if someone updates your package to a new version this file URL is still the same and their browser might not fetch the newer version from the server.

IPackageManaifestReader

Another alternative is to use a IPackageManifestReader (https://dev.to/skttl/server-side-registering-of-package-manifest-in-umbraco-14-49go by @skttl) which allows you to register your package via your backend code (see DoStuffPackageManifestReader.cs

public Task<IEnumerable<PackageManifest>> ReadPackageManifestsAsync()
{
  var version = Assembly.GetAssembly(typeof(DoStuffPackageManifestReader))?
   .GetName()
   .Version?.ToString() ?? "1.0.0";

  return Task.FromResult<IEnumerable<PackageManifest>>(new[]
  {
    new PackageManifest
    {
      Id = "DoStuff.Client",
      Name = "DoStuff with Umbraco client",
      AllowTelemetry = true,
      Version = version,
      Extensions = [
        new {
          name = "DoStuff Client Bundle",
          alias = "DoStuff.Client.Bundle",
          type = "bundle",
          js = "/App_Plugins/DoStuffClient/do-stuff-client.js?v=" + version
        }
     ]
   }
  });
}

You can see there is a little bit more code here but the basic information is the same as the umbraco-package.json file.

The key difference is we can fetch the version from the running assembly(dll).

When you build your NuGet packages of your extension the version will be stamped on the dll's in the package by NuGet's pack process. and once its there the code in your IPackageManifestReader will use that version value to update your package version and add it to the end of the JavaScript file's URL. meaning for each new version the browser will fetch the file again.

You need to remember to register your package manifest in a composer
builder.Services
  .AddSingleton<IPackageManifestReader, DoStuffPackageManifestReader>();

Entry points Auth.

Another change that we will go into more detail in, when we talk about entry points and APIs is the code for setting up the authentication between sites.

if you use the opinionated starter kit (or the umbraco-extension with the `-ex' flag) you will get the skeleton of the code for communicating with the server from your font end code.

`ts
_host.consumeContext(UMB_AUTH_CONTEXT, async (authContext) => {
// Get the token info from Umbraco
const config = authContext?.getOpenApiConfiguration();

client.setConfig({
auth: config?.token ?? undefined,
baseUrl: config?.base ?? "",
credentials: config?.credentials ?? "same-origin",
});
});
`

This is fine and it works - but from a bit of experience there is another bit you can add, that helps to keep things fresh should you have the browser open all day

ts // client interceptor will get the latest token for the auth // context for a request, so if the token has been refreshed // since we first got it, we'll still have a valid token. client.interceptors.request.use(async (request, _options) => { const token = await authContext?.getLatestToken(); request.headers.set("Authorization",Bearer ${token}); return request; });
A client interceptor will run when the requests are fired and just make sure you have the latest token from the user send over as part of the request.

Again this isn't something you have to do, everything works fine in the examples, this just smooths the odd edge I have seen during development.

Battle scarred developer's guide to Umbraco v17 - Getting Started

Wed, 25 Feb 2026 17:20:29 Z

umbraco-extensions

If you are starting out on a new umbraco extension or package you will probably want to start with the umbraco-extension template that comes as part of the Umbraco templates.

So if you haven't already you will want the Umbraco templates

dotnet new install Umbraco.Templates@17.*

and once you have these templates installed you 'could' just run the umbraco extension.

dotnet new umbraco-extension -n MySuperNewUmbracoPackage

and this will crate you a new package to pay about with, but at this point you won't have an Umbraco site just an extension, so you will probably want to think about that.

Opinionated starter kit template.

if you actually want to have a site and a bit more structure around your development then you might want to consider @lottepitcher's Opinionated starter kit template, this adds stuff around the edges of the standard umbraco-extension, such as a test site, GitHub scripts and umbraco-marketplace files which will help when you come to release your super package.

You can install the templates for the Opinonated starter kit like so:

dotnet new install Umbraco.Community.Templates.PackageStarter

you can then start a new project

dotnet new umbracopackagestarter -n MySuperPackage

after this you get your extension and a test site, and scripts all nicely laid out for you.

Project Structure

For the DoStuffWithUmbraco repository that we are using as a reference for these blog posts you will notice there are a few slight differences with both the umbraco-extensions and the opinionated starter kit.

These changes are not major, and for the most part you can ignore them, but for information we have laid the project out like so.

+-- src
  +-- DoStuff
  +-- DoStuff.Client
  +-- DoStuff.Core
+-- demo
  +-- DoStuff.Website

DoStuff.Client

Client contains all the "front end" code and API controllers for the extension to render inside Umbraco. There is no real 'business logic' inside this layer, it's the UI and the c# code required to get data to the UI.

DoStuff.Core

The core project contains the backend logic for the application - this is where services, repositories, data layers etc all live. we sperate this out from the client, because then well it's separate and we can in theory use the core logic of our code without the front end, or on a different front end should it ever change 😧

DoStuff

The parent to all of these projects is the 'DoStuff' library - no really this has no code it in, but it would be the library that became the NuGet package that people would install (if we made the library a package).

The "DoStuff" has dependencies on the .Client and .Core projects so when someone would install the "DoStuff" NuGet package that would also fetch the client and the core.

DoStuff.Website

Our website is off in a 'demo' folder, just so we can have it separate from our project. If this wasn't a reference library we would probably exclude the 'demo' folder from the source repository, then the site is independent of our package's code.

Battle scarred developer's guide to Umbraco v17 - Intro

Wed, 25 Feb 2026 17:20:19 Z

Introduction

It's almost two years now since I wrote a quite large series of blog posts about the then very new umbraco Backoffice.

The early adopters' guide to the Umbraco Backoffice was really just a way for me to write down my thoughts and discoveries as I started the process of moving our packages to the brave new world.

As it turned out quite a few people found those posts useful, and they are still being referenced by people today (the Umbraco.AI Skills even use them), but you can learn a lot in two years and Umbraco has gone from v14 to v17, and there has been loads of refinements and tweaks. as such the early adopters guide series are good, but they could be a lot better.

So - now that we've come out of the other side of two years of upgrading and developing packages for the "new" Umbraco back office, I thought it was time to dust off the code and re-visit the guides.

So today, we are starting the "Battle scarred developer's guide to Umbraco v17" - this is a series of blog posts aimed at package and extension developers - giving them a leg up for a quick start, and tips and tricks on how to do things 'right'

It's also worth noting the Umbraco documentation has also improved greatly since we did the first round of posts - so you should check out https://docs.umbraco.com/umbraco-cms/customizing/overview it may already tell you what you need to know.

All of the code referenced in these blogs is available via GitHub:
https://github.com/KevinJump/DoStuffWithUmbraco/tree/v17/main

umbraCoffee - Compose Yourself

Wed, 25 Feb 2026 13:10:06 Z

Welcome to your monthly dose of #umbraCoffee! Your hosts - Marcin and Callum - together with their guest(s) will drive through all of the community news and happenings in the Umbraco world. So... grab a cuppa, join us LIVE and enjoy! This time we're joined by Umbraco CTO Filip Bech-Larsen, and Head of Orchestration Jordan McFarlane, to talk all things Umbraco Compose... See ya?! --- ☕ Wanna buy us a coffee/pizza/donuts? https://www.buymeacoffee.com/umbracoffee --- Notes: // TODO

MCP vs Agent Skills: Why They're Different, Not Competing

Tue, 24 Feb 2026 13:01:29 Z

Introduction

When Agent Skills launched in October 2025, they sparked immediate debate in the AI tooling community. Some prominent voices, including developer Simon Willison, suggested Skills might be "a bigger deal than MCP," noting his waning interest in MCPs due to their token consumption issues(Claude Skills are awesome, maybe a bigger deal than MCP). The timing seemed damning for MCP—barely a year after Anthropic introduced the Model Context Protocol in November 2024, a lighter-weight alternative emerged that appeared to solve MCP's biggest problem: context window exhaustion.

I've heard plenty of people discount MCP now, thinking we should all just be using Skills instead. But here's what we've learned after using both technologies side by side: Skills and MCPs aren't competing solutions to the same problem. They're fundamentally different architectures serving different purposes.

Skills excel at information delivery and adaptive context management, functioning as ephemeral clouds of knowledge that LLMs can pull from as needed. MCPs provide structured tool integration, giving LLMs deterministic ways to speak to the outside world through well-defined protocols. Rather than replacement, they serve complementary roles. And with MCP's recent adoption of progressive discovery in January 2026, the original context efficiency advantage that Skills held has disappeared(What is MCP Tool Search? The Claude Code Feature).

What remains are two distinct approaches to two distinct challenges in LLM integration. Think of it like a painter's easel—different brushes for different strokes, different tools for different purposes. This article explains why Skills aren't a replacement for MCP, and why both technologies matter for building the future of AI integration.

What is MCP and Why It Mattered

When Anthropic launched the Model Context Protocol in November 2024, it was genuinely revolutionary(One Year of Model Context Protocol: From Experiment to Industry Standard). The protocol simplified the entire process of connecting LLMs to the outside world. Before MCP, tool calling was difficult, non-standardized, and inconsistent across platforms. MCP made it dramatically easier and enabled people to build integrations that actually worked.

The impact was immediate. Within months, thousands of MCPs were created and deployed—tens of thousands, even hundreds of thousands. The protocol shipped with SDKs in Python, TypeScript, C#, and Java, making it accessible across the ecosystem. Major platforms adopted it quickly: ChatGPT, Claude, Cursor, Gemini, Microsoft Copilot, and Visual Studio Code all added first-class MCP support(One Year of Model Context Protocol: From Experiment to Industry Standard). By early 2026, MCP was seeing over 97 million monthly SDK downloads with more than 10,000 active servers deployed.

MCP genuinely revolutionized how we connect LLMs to external systems. That's what MCPs are—and they're brilliant at it.

The Original Context Window Problem

But people quickly realized there were some serious downsides to MCP, especially as more developers got used to how LLMs actually work. The problem? Your context window—that finite space where you can influence what the LLM will output—is precious real estate. It's critical that you manage it carefully and only put things in there that you need, because otherwise you'll get hallucinations and unreliable outputs.

When MCP first launched, it put everything into the context window upfront. Every tool's name, description, output schema, input schema—everything loaded immediately. That was extraordinarily wasteful. A single tool could consume 500 to 900 tokens before you'd even started any actual work.

With only a handful of tools, you could easily end up with no context available to do anything useful.

This became particularly painful for us at Umbraco when we looked at composing tools together to create magic—MCPs where tools could combine to make impossible things happen. That led to a lot of tools. The Umbraco MCP currently has around 345 tools(Available Tools - Umbraco Documentation). When you compose all those together, you end up consuming around 30,000 tokens just for tool definitions. That's more than most entire context windows.

This was definitely seen as a critical design flaw that limited MCP usability and scalability.

The Rise of Skills and Progressive Discovery

Skills were introduced in October 2025, almost a year after MCP was created(Equipping agents for the real world with Agent Skills). They launched to considerable acclaim and gained traction incredibly quickly. And the reason Skills caught fire so fast? They had a clever trick up their sleeve.

Core Innovation: Progressive Discovery

Skills introduced progressive discovery. The idea: start with the smallest amount of information possible and put only that into the context window. It's remarkably context-efficient.

At the start, the only information in context about a particular skill is the name and a very short description. That might take up between 20 and 50 tokens out of 200,000. Incredibly efficient. Then when the LLM decides it wants to use a particular skill, it pulls in the skill markdown file and the rest of the instructions linked to it. Brilliant!

In that skill markdown file, you can link to other files within the skill. The LLM only loads those if it decides it needs more information. There might be links in there, and it might decide to go out to the internet. This progressive discovery that Skills have as a key advantage made real waves.

Skills were released as an open standard by Anthropic on December 18, 2025, with enterprise partnerships including Canva, Notion, Figma, and Atlassian providing prebuilt skills(Equipping agents for the real world with Agent Skills). The approach quickly gained traction across agentic tools and platforms. Most agentic tools out there now support Skills.

When Skills first came out, Simon Willison said they could be a bigger deal than MCPs. He expected thousands upon thousands of Skills just like when MCP first launched, making a real impact on software engineering and development(Claude Skills are awesome, maybe a bigger deal than MCP). I think that's probably going to happen—we've seen momentum building, and people are discovering how useful they can be.

But I very much disagree that they're a replacement for MCP. I don't think that's the case at all.

MCP's Recent Catch-Up: Progressive Discovery Arrives

In January 2026—just last month—Claude Code introduced something I'd been genuinely waiting for ever since Skills launched(What is MCP Tool Search? The Claude Code Feature). Anthropic took the same progressive discovery trick that made Skills so context-efficient and applied it directly to MCP.

So when you load an MCP now, you get the name and description of each tool—really small and compact, taking up around 20 to 50 tokens each. Exactly the same as Skills. Absolutely incredible.

Then if the LLM decides it wants to use a particular tool for the task at hand, it loads in the input schema, output schema, full description, and everything around it. That means you can host many more MCP tools, and it won't decimate your context window. It makes your conversations far more efficient and practical.

The impact was immediate and measurable. Token overhead dropped by 85%—from around 77,000 tokens to just 8,700 tokens for setups with 50+ tools(What is MCP Tool Search? The Claude Code Feature). Tool calling accuracy improved significantly as well: Claude Opus 4 jumped from 49% to 74% accuracy, while Opus 4.5 went from 79.5% to 88.1%.

For me, this means that initial problem with MCP—the concern that haunted it from launch—has actually been solved. I think MCP has some catching up to do in terms of perception. But that context window problem? It's gone.

Active Context Management: The Real Game-Changer

This trick that Skills and now MCPs both use is something I call active context management. Last year, the phrase was "context engineering"—ensuring your context window only includes what it needs for a given task. That's genuinely hard work to make work well, and it's time-consuming to curate exactly what you want into the context window to support the tasks you have.

Active context management is something different—a step forward. This is what Skills and MCP tools now do: they allow you to put a small amount of information into context, and then if it needs to be used, the rest gets pulled in afterward.

The challenge is a bit of a chicken-and-egg situation. How much information do you put into the context window to make it obvious for the LLM when to trigger it and progressively load the rest? That's really tricky to get right, and that's the real benefit of active context management—nailing that balance.

This active approach enables LLMs to work with dozens or hundreds of tools while minimizing context exhaustion. It's the key innovation that makes modern LLM integration practical at scale.

This Is Where They Diverge

I firmly believe there's a real divergence between Skills and MCPs. It's important to recognize that there are things MCPs are better at doing than Skills, and vice versa. There are areas where you'd choose one over the other. This is where the boundary between determinism and non-determinism becomes the key differentiator.

Skills Are Ephemeral Information Clouds

Skills, by their very nature, are extraordinarily easy to set up. It's literally just a directory with a file in it—that's the minimum you need. They're trivial to build and start using.

But this also means that Skills can be quite ephemeral. They have an element of non-determinism in them, which makes them absolutely amazing—but at the same time, it makes them a little unstructured.

What we're finding is that Skills work best as information clouds. They're things that exist to provide information. They're really about automated context management—bringing in the right context at the right time to improve the LLM's ability to make good decisions across a whole range of tasks.

Skills support progressive discovery beautifully. You start with a single piece of information, and from there, it can link out to related context, code examples, and deeper guidance as needed. The LLM can reach into, pulling out as much or as little as it needs for the task at hand, following the most direct path to exactly the right context at the right time. It's about information efficiency for the LLM, and it's crucial to understand that's one of the most important things about Skills.

Their advantage is their flexibility—their ability to adapt and change, to be used as much or as little as needed. That's really the essence of what Skills are and why they matter.

Skills excel at:

Supporting diverse, exploratory LLM tasks
Providing knowledge libraries and best practices
Delivering automated context management
Offering information guidance that adapts to the conversation

But they're fundamentally different from what an MCP is.

MCPs Are Defined, Structured Tools

MCP is really about tools. It's about structure. It's about defined, stable architecture. It's about giving an LLM a deterministic way to connect to things.

With Skills, you have that boundary and ability to move between non-determinism and determinism. With MCP, you don't really have that—and that can actually be a really good thing. When you trigger a tool, you know you're triggering it. It's much easier to get tools that compose together to complete agentic flows. Whereas with Skills, that's trickier and less predictable because triggering Skills can be somewhat uncertain.

With MCP, because it's a well-defined and structured architecture, you have SDKs for it. You can build proper structures with testing, helpers, core systems, shared code, and all the infrastructure that comes with mature software development. That's something you really can't do with Skills in the same way. They look similar, but they're actually very different.

You can have MCPs that chain into other MCPs for hierarchical composition. You have MCPs that are hosted on the internet with persistent connections. You can do dynamic tool loading with infrastructure designed for it. You can't do any of that with Skills.

So it may look like Skills are a basic thing—and they're not. Whereas MCP may be seen as enterprise or more grown-up—and that's not what it's about at all. It's about structure. MCPs are structured. They're precise. They work in well-defined ways. They have hard edges. Whereas Skills don't. Skills are there to provide information, and maybe provide a little bit of deterministic information as well.

MCPs provide the technical capabilities that enable:

Enterprise integrations where reliability matters
Complex multi-step processes with predictable workflows
Agentic systems that compose tools together reliably
Infrastructure with shared code, testing, and helpers

The key strength of MCPs is structure and composability.

Where They Converge: Scripts and Code Execution

But there is a similarity—something that confuses people about Skills and maybe led people to think Skills could replace MCPs. That's the way you can put scripts into Skills and have script files run in the sandboxed environment. On first pass, it looks like these things could replace MCPs.

But it's not really the case.

Scripts in Skills are quite basic. I wouldn't want to create full structures behind them that the skill can trigger, and it's very difficult to share scripts between Skills or fit them into a stable architecture. Skills scripts are really there to allow a level of determinism—to use them for things like reports.

Getting an LLM to create a report on something is difficult because it will give you a different answer every time. But when you need something deterministic, you can run a skill that will return the same data every time it makes that call, and then the LLM can use it with much less likelihood of hallucination.

Dynamic Code Execution: A False Equivalence

With MCP, there's this thing called code execution that emerged in November 2025(Code execution with MCP: building more efficient AI agents). The idea is that the LLM generates code on the fly—writing raw API calls, scripts, or queries at runtime rather than invoking pre-built tool endpoints. Instead of calling a well-defined MCP tool like createContent(title, body), the LLM dynamically writes a fetch call or script to hit an API endpoint directly.

Skills are very good at that pattern too—their sandboxed script environment can run LLM-generated code in a similar way. And the problem is, with code execution, you're ignoring all the benefits of systemizing and the difference between an API endpoint and what the LLM is most efficient for.

You lose the optimization of well-defined tool schemas: parameter validation, consistent output formats, and composability between tools. You're ignoring the work of manipulating and shaping API structures specifically to make them LLM-friendly. Raw API calls are often verbose, poorly documented for LLM consumption, and inconsistent.

Both Skills scripts and MCP code execution become less effective when used this way—you trade reliability and composability for flexibility you rarely need.

This is the problem. Skills are brilliant, but they're brilliant at what they do. It's the lack of structure that makes them unsuitable for providing tools that need to be well-defined and highly structured. That's where the difference lies, because MCP is there to provide structure. It exists within a framework, within a collection of tools that are all similar, all there to support the same set of functionality. It's also much easier to compose tools to bring the magic out.

The better approach: Use scripts for deterministic outputs where consistency matters, and use properly structured MCP tools for integration and action. Don't treat dynamic code generation as a substitute for purpose-built tool architecture.

Where Umbraco Uses Skills

We've thought long and hard about this. Given what we've said here, we see Skills as ephemeral, like a cloud of information that the LLM can call on. It can pull as much or as little as it needs to extract the information.

We use Skills for information delivery—functioning as libraries of knowledge and best practices. That information might include code examples. It might include scripts that make small calls somewhere. But it's in no way structured in the way MCPs are.

Structured Skill Sets Aligned With Extension Points

The Skills we have may be structured. There may be lots—like the back office skills we've got. We have a structure of Skills defined to match the extension points in the back office. But there's no shared code between them, and they're really seen as a library of information.

We include real-world code examples in Skills—runnable samples that developers and LLMs can use directly. These aren't just snippets; they're practical, executable examples of proper setup and implementation patterns. This grounds the LLM's output in tested, working code rather than generated approximations, significantly reducing hallucination.

We also provide direct links to Umbraco source code and the UUI (Umbraco UI) component library as authoritative references. Skills point the LLM to actual source repositories and component libraries, grounding responses in the ultimate source of truth rather than potentially outdated or hallucinated documentation. This ensures best practices come directly from Umbraco's own codebase and UI patterns, not from the LLM's general training data.

That's where I see Skills going—there to provide information to the LLM and help manage the context it has given the task at hand.

Where Umbraco Uses MCPs

I don't think anything's going to change in our strategy around MCP now that Skills are part of the agentic world. We're going to continue using MCP to provide tools into Umbraco, to open up Umbraco so you can use an LLM to talk to it, manipulate it, compose it, and use it in amazing and interesting ways.

The Umbraco Developer MCP currently exposes over 330 tools spanning 36 endpoint groups, providing near-complete parity with the Umbraco Management API(Available Tools - Umbraco Documentation). An LLM with access to this MCP can create document types, manage media, configure members, set up cultures, define data types—essentially all the operations you'd normally perform through the back office interface or API calls.

We're continuing to build MCPs based on our add-on products and to create MCPs around different use cases. I don't see that changing at all because of Skills.

From our perspective, I see them as quite different things with quite different use cases, and that's definitely going to be apparent in how we use these two separate technologies at Umbraco with LLMs.

Can They Work Together?

I see MCP and Skills both being used at Umbraco and both being leveraged heavily to make using LLMs with Umbraco as easy and fulfilling as possible. I don't see any problem with using them together either.

We have plans to create content modeling Agent Skills to help you develop your content structures and provide information, expertise, and best practices on how to set up and generate your own Umbraco sites.

The Powerful Combination

What you'll have is the skill providing all the knowledge, best practices, and information on how to do it right, and then the MCP actually doing the action. The skill is the brain—it knows what to do, what to create, how to update things, and how to create good structures for content in Umbraco. The MCP is the muscle that actually implements it.

That's where I see things going—an example of collaboration between the two. I see that as genuinely important.

Conclusion

Skills and MCPs are very different things—and both are critically important for the future of how LLMs integrate with and enhance Umbraco.

Skills function as information clouds with flexible context management, excelling at knowledge delivery and adaptive context enrichment. MCPs provide structured tools with reliable composition and integration, excelling at deterministic workflows and system integration.

Claims that Skills replace MCPs misunderstand these architectural differences. Skills adoption doesn't diminish MCP value—they solve different problems. Now that both support progressive discovery, the context efficiency question is settled. What remains are the real differences: structure versus flexibility, determinism versus adaptation, tools versus knowledge.

The future belongs to thoughtful use of both. Neither technology is universally better. Architecture should drive the choice, not hype or convenience. When Skills and MCPs work together, each playing to its strengths, you get the most powerful LLM integration possible.

So when evaluating these technologies for your use case, don't ask "Which one is better?" Ask "Do I need information delivery or tool execution?" The answer to that question will point you in the right direction.

Get your Umbraco Spark ticket before midnight on 28th Feb

Tue, 24 Feb 2026 12:36:14 Z

⏳ 4 days to go! Get your Umbraco Spark ticket before midnight on 28th Feb to secure ALL perks and goodies.After midnight, perks won’t be included — don’t miss out! 🎟️https://www.tickettailor.com/events/umbukfdn/1896581#UmbracoSpark #Umbraco #Countdown #LastChance

DigitalWonderlab.MediaFinder

Mon, 23 Feb 2026 00:00:00 Z

An Umbraco backoffice dashboard that lets you search for media items by name, size, or type.

DigitalWonderlab.BackofficeAnnouncement

Mon, 23 Feb 2026 00:00:00 Z

A backoffice announcement bar for Umbraco. Toggle on/off a simple text announcement visible to all backoffice users.

Skybrud.Umbraco.Redirects 17.0.2

Sun, 22 Feb 2026 18:39:58 Z

Award winning redirects manager for Umbraco.

Skybrud.Umbraco.Redirects 16.0.3

Sun, 22 Feb 2026 18:32:06 Z

Award winning redirects manager for Umbraco.

Skybrud.Umbraco.Redirects 13.0.9

Sun, 22 Feb 2026 18:21:20 Z

Award winning redirects manager for Umbraco.

uSupport.uSync

Sun, 22 Feb 2026 00:00:00 Z

uSupport is an feature rich ticketing system designed specifically for the Umbraco. It is a complete ticketing solution that enables users to create, manage, and view tickets and their associated comments. With uSupport, you can quickly and easily create and manage tickets. uSupport is highly customizable, allowing users to set up their own ticket types and define ticket statuses.

SBD.ContentInsights

Sun, 22 Feb 2026 00:00:00 Z

This package for Umbraco aims to provide insights into the content, specifically the created documents and document types, using Chart.js.

What Being an Umbraco MVP Really Means

Fri, 20 Feb 2026 11:38:05 Z

Journey to MVP | Ravi Motha | Innerworks

Phases.Umbraco.NeatTip

Fri, 20 Feb 2026 00:00:00 Z

NeatTip is an Umbraco package that automatically converts long property descriptions into compact, interactive tooltips. Instead of cluttering your content editing interface with lengthy descriptions, NeatTip displays a small icon next to property labels. Click or hover the icon to view the full description in a styled tooltip. Reduces visual clutter, supports draggable tooltips, and only activates in content editing pages.

Vettvangur.UmbracoAzureStorageProvider

Fri, 20 Feb 2026 00:00:00 Z

Azure Blob Storage provider for Umbraco CMS.

Vettvangur.UmbracoStorageProviders

Fri, 20 Feb 2026 00:00:00 Z

Shared storage providers infrastructure for Umbraco CMS

Vettvangur.UmbracoAzureStorageProvider.ImageSharp

Fri, 20 Feb 2026 00:00:00 Z

Adds ImageSharp support using the Azure Blob Storage provider for Umbraco CMS.

Tracking Bouldering Sessions with a Garmin Watch App and Umbraco Dashboard

Fri, 20 Feb 2026 00:00:00 Z

Tracking Bouldering Sessions with a Garmin Watch App and Umbraco Dashboard

Fri, 20 Feb 2026 00:00:00 Z

Umbraco Compose demo by CTO, Filip Bech-Larsen.

Thu, 19 Feb 2026 07:12:54 Z

In this demo, Umbraco CTO Filip Bech-Larsen showcases Umbraco Compose, a data orchestration platform built to power modern composable architecture. You’ll see how Compose connects multiple data sources — including Umbraco CMS, Google Sheets, Algolia search, and Cloudflare — into a single GraphQL layer designed for scalability, performance, and maintainability. Instead of building custom integrations for every client, Compose centralizes and shapes data for delivery across websites, apps, dashboards, and other digital channels. Filip demonstrates how to ingest 10,000 products in seconds, achieve a 99 Lighthouse performance score, switch data sources without breaking the frontend, and unlock new search capabilities simply by updating a GraphQL query — no backend rewrites required. If you're building composable digital platforms and want fewer integrations, less maintenance, and faster iteration, this demo shows what composable done right looks like. Chapters: 00:00 The Problem: Rebuilding custom integrations for every customer 00:24 What Umbraco Compose Is: Data orchestration + GraphQL at scale 02:21 Composable Architecture Demo: CMS, Google Sheets, Algolia, Cloudflare 04:54 High-Volume Ingestion + Performance (10,000 products, Lighthouse 99) 06:29 Switching Data Sources + Enhancing Search with GraphQL Discover more about Umbraco Compose: https://umbraco.com/products/umbraco-compose/

Why Choose Umbraco Development Services in 2026

Wed, 18 Feb 2026 12:01:10 Z

In 2026, digital performance defines business success. For UK B2B companies and growing enterprises, choosing the right CMS is critical…

Continue reading on Medium »

uSkinned Nominated for Best Website Builder | CMS Critic Awards

Wed, 18 Feb 2026 11:25:15 Z

Nominated for Best Website Builder | CMS Critic Awards We’re pleased to share that uSkinned has been nominated once again for Best Website Builder in the CMS Critic Awards. Voting closes 27th February.

Umbraco Spark Low Ticket Alert!

Tue, 17 Feb 2026 12:11:18 Z

@umbfyi tip

uProfile February 2026 - Jenny Bradshaw

Tue, 17 Feb 2026 00:00:00 Z

Meet Jenny Bradshaw - From "Um-WHAT?" to Umbraco MVP

BlockFarmEditor.Umbraco

Tue, 17 Feb 2026 00:00:00 Z

Block Farm Editor for Umbraco. Allows for easy on-page editing using built-in Umbraco data types and property editors.

Truthwillout.Umbraco.RteStylesManager

Tue, 17 Feb 2026 00:00:00 Z

A visual dashboard for managing Umbraco Rich Text Editor styles and colors. Easily add, edit, and organize text styles with color pickers, live previews, and automatic CSS generation.

ContentTrace.Umbraco

Tue, 17 Feb 2026 00:00:00 Z

Content activity tracking for Umbraco 17. Logs save and publish actions and displays them in a backoffice dashboard.

AF.Umbraco.Azure.Blob.Media.Storage

Mon, 16 Feb 2026 00:00:00 Z

Azure Blob media storage provider for Umbraco 15/16/17 (.NET 9/10). Built on Umbraco.StorageProviders.AzureBlob and Umbraco.StorageProviders.AzureBlob.ImageSharp, it configures Azure Blob media filesystem and ImageSharp cache with auto-composition (no Program.cs changes required), startup fail-fast checks (required settings, connectivity, container checks) and configurable ImageSharp cache-retention cleanup.

Umbraco.Community.Merchello

Mon, 16 Feb 2026 00:00:00 Z

Enterprise ecommerce for Umbraco - making enterprise ecommerce simple

OC.MultiHotspot

Mon, 16 Feb 2026 00:00:00 Z

A property editor that allows a backoffice user to add multiple hotspots on an image along with descriptions. Render the image with hotspots on the frontend with Leaflet JS

A CLI tool to audit Umbraco 13 LTS projects and estimate upgrade effort to Umbraco 17 LTS.

Sat, 14 Feb 2026 11:04:22 Z

millnut/umbraco_lts_upgrade_audit: A CLI tool to audit Umbraco 13 LTS projects and estimate upgrade effort to Umbraco 17 LTS.

uAdvancedButton

Sat, 14 Feb 2026 00:00:00 Z

Enterprise-level CTA system with advanced buttons, button groups, dropdown menus, analytics hooks, and full accessibility. Works in Block Grid, Block List, and as standalone ViewComponent.

Umbraco 17 Package Updates

Fri, 13 Feb 2026 20:30:00 Z

Explore my updated suite of packages for Umbraco 17 and enhance your next Umbraco project with tools for relations, custom trees, and content editor experience.

Limbo.Umbraco.BlockList 13.0.3

Fri, 13 Feb 2026 10:20:28 Z

Umbraco package that extends the functionality of Umbraco's build-in block list.

Umbraco Developer MCP 17.1.0 is here!

Fri, 13 Feb 2026 09:03:27 Z

Umbraco Developer MCP 17.1.0 is here! Enjoy precise content updates, fine-grained tool control, structured and validated tooling, improved testing, and more - laying a solid foundation for future AI-powered workflows with Umbraco. Release notes: https://github.com/umbraco/Umbraco-CMS-MCP-Dev/releases/tag/v17.1.0 Documentation: https://docs.umbraco.com/umbraco-cms/reference/developer-mcp #Umbraco

Announcing: Umbraco Contributing Partners 2025

Fri, 13 Feb 2026 00:00:00 Z

64 Platinum & Gold Partners have earned the badge of being this year's Contributing Partners

Merchello MVP Walkthrough For Umbraco v17+

Thu, 12 Feb 2026 20:20:00 Z

Our.Umbraco.GitHubIssues

Thu, 12 Feb 2026 00:00:00 Z

Our.Umbraco.GitHubIssues is a small Umbraco package that brings open GitHub issues from the Umbraco project right into your backoffice.

Crumpled.RobotsTxt

Thu, 12 Feb 2026 00:00:00 Z

A flexible, configuration-driven robots.txt solution for Umbraco v13, v14, v15, v16 and v17 that protects your non-production environments from search engine indexing by default. Supports multi-site configurations, environment-aware rules, and flexible user-agent patterns with zero code setup.

DevRel Deep Dive: Creating Backoffice Extensions with AI Skills

Wed, 11 Feb 2026 15:11:36 Z

This week Sebastiaan and Lotte are joined by Phil Whittaker, AI Staff Engineer at Umbraco to talk about what AI “skills” are and how you can use them to extend the Umbraco Backoffice. Phil talks us through installing the Umbraco Backoffice Skills, and then Seb demos using them to create a GitHub User Picker property editor. 👀 Umbraco Backoffice Skills on GitHub: https://github.com/umbraco/Umbraco-CMS-Backoffice-Skills

GitHub Action for Umbraco Cloud Deployments Released

Wed, 11 Feb 2026 14:57:41 Z

Released my GitHub Action for Umbraco Cloud Deployments - Umbraco community forum

Our.Umbraco.Extensions.Variables

Wed, 11 Feb 2026 00:00:00 Z

Variables property editor for Umbraco

Umbraco.Community.BetterIcons

Wed, 11 Feb 2026 00:00:00 Z

BetterIcons is a modern, powerful property editor for Umbraco CMS that provides access to 200,000+ icons from popular icon libraries including Material Design Icons, Font Awesome, Bootstrap Icons, and 100+ more. Built with React for a smooth, responsive user experience with smart search, color customization, and zero configuration.

Our.Umbraco.Extensions.Theming

Wed, 11 Feb 2026 00:00:00 Z

Theme picker and view engine for Umbraco

Submissions for the Umbraco Awards 2026 are now open!

Tue, 10 Feb 2026 10:55:38 Z

🏆 Submissions for the #Umbraco Awards 2026 are now open! Show off your work, get recognized, and inspire others!✅ Fast & easy - no video required👉 Submit now: https://codegarden.umbraco.com/awards/umbraco-awards

Umbraco Skills for AI Agents - A Game Changer for Backoffice Development

Tue, 10 Feb 2026 10:21:53 Z

Umbraco Skills for AI Agents - A Game Changer for Backoffice Development | skttl.dev

SeoToolkit 6.1.0 is now available for the latest Umbraco version

Tue, 10 Feb 2026 08:34:13 Z

uSync compatability, page title template, content checks and much more! SeoToolkit 6.1.0 is now available for the latest Umbraco version. Check it out if you are interested in easy to use SEO! https://github.com/patrickdemooij9/SeoToolkit.Umbraco/releases/tag/6.1.0

AI in Umbraco in 2026: choices, governance, and day-to-day use

Tue, 10 Feb 2026 06:54:05 Z

https://www.linkedin.com/posts/phases_ai-in-umbraco-2026-governance-choice-and-activity-7426869425099792385-Jjq7?utm_source=share&utm_medium=member_ios&rcm=ACoAAABj9KwBjr581HKBv-M3TbQu69Ia79rmfPw

Storage.HealthChecks

Tue, 10 Feb 2026 00:00:00 Z

Health checks for monitoring and maintaining Umbraco media storage. Identifies duplicate files, large media, missing files, orphaned files and unused media items.

UmbMetrics

Tue, 10 Feb 2026 00:00:00 Z

Package Description

ModuLabry.Umbraco.Suite

Tue, 10 Feb 2026 00:00:00 Z

A streamlined property editor suite for Umbraco (verified stable for v14-v17). Includes Enum-driven and simple list components for Dropdowns, Checkboxes and RadioButtons with full localization support.

UmbracoPrism

Sat, 07 Feb 2026 00:00:00 Z

Multi-tenancy for Umbraco (v17+) with dynamic branding and stateless identity. Prism resolves branding, identity, and content context at runtime based on the incoming domain.

UmbracoMediaSnapshot

Sat, 07 Feb 2026 00:00:00 Z

Umbraco Media Snapshot adds lightweight media version history to Umbraco by automatically adding a File Version History property (fileVersionHistory) to common media types and creating the required Media Snapshot data type during installation/upgrade.

Umbraco SQL query to get a list of content using Macros in V13

Thu, 05 Feb 2026 11:46:34 Z

If anyone needs an #Umbraco SQL query to get a list of content using Macros in V13... I've dropped what I've used here:https://gist.github.com/AaronSadlerUK/f2bb83ccaf0b23840f6c06b45e536de1

Introducing Umbraco AI

Thu, 05 Feb 2026 11:00:00 Z

If you caught the Umbraco Winter keynote webinar, you’ll have seen us announce something I’ve been working on for a while now - Umbraco AI. I’ve...

Umbraco Highlights 2025

Thu, 05 Feb 2026 10:47:52 Z

Creating and updating your website should be the least of your worries. With Umbraco, you get a content management system known and loved for its flexibility and great editing experience. Umbraco is easy to get started with install, set up, and host it yourself or let us take care of it all for you on Umbraco Cloud. https://try.umbraco.com Learn more about Umbraco on our website https://umbraco.com Discover our Umbraco Community: https://community.umbraco.com/ Find the Umbraco source code on Github: https://github.com/umbraco/Umbraco-CMS Visit the Umbraco Documentation: https://docs.umbraco.com

Case Study: Thames Water UK x Umbraco

Thu, 05 Feb 2026 10:32:55 Z

How Thames Water built a secure, scalable and high-performance digital platform with Umbraco. Thames Water, the largest water company in the UK, serves more than 16 million people and relies on a highly available digital platform to support customers during critical situations. In this case study, the team explains why they moved to Umbraco CMS and how the transition improved performance, stability, and cost efficiency. The video covers Thames Water’s gradual migration approach, how risk was reduced during the transition, and how the intuitive editor experience enabled the content team to work efficiently with minimal training. The result is a modern, scalable solution that supports high traffic volumes, improves customer communication, and delivers long-term value through reduced infrastructure and licensing costs.

Umbraco Winter Keynote 2026

Thu, 05 Feb 2026 08:13:37 Z

At the Winter Keynote 2026, we look back on a strong year for Umbraco and share what’s next for the platform, partners, and community. The keynote covers highlights from 2025, including company growth, product milestones, global expansion, and the continued strength of the Umbraco community. We introduce major announcements such as 24/5 support, a new partner portal, and ISO 27001 certification. A key focus is Umbraco’s approach to AI - built for choice, flexibility, and real-world use - with live demos of new AI capabilities inside Umbraco. The keynote also features the launch of Umbraco Compose, a new data orchestration platform designed to simplify composable architectures at scale. Finally, we share what’s coming next for the CMS, the ecosystem, and the community including events, roadmap highlights, and a look ahead to Codegarden 2026.

From Umbraco 13 to 17: My Upgrade Journey and Lessons Learned

Thu, 05 Feb 2026 00:00:00 Z

Arroact.Umbraco.GraphQL

Thu, 05 Feb 2026 00:00:00 Z

A powerful GraphQL API package for Umbraco with built-in authentication, interactive IDE dashboard, and comprehensive content/media querying capabilities. Features include lazy loading, BlockGrid support, MultiNodeTreePicker handling, and configurable API key authentication.

AF.Umbraco.S3.Media.Storage

Thu, 05 Feb 2026 00:00:00 Z

AWS S3 media storage provider for Umbraco 17 (.NET 10). Based on original Our.Umbraco.StorageProviders.AWSS3 project (not compatible with Umbraco 17), the new project is fully refactored, optimized and extended for .NET 10 and Umbraco 17. Includes S3-backed IFileSystem integration, media delivery middleware, ImageSharp provider/cache, localized upload validation and configurable cache-retention cleanup. For ease management, the cache folder replicates the media folder hierarchy, ensuring a one-to-one correspondence between each media folder and its cache folder.

AI, intentionally

Thu, 05 Feb 2026 00:00:00 Z

Discover how Umbraco is building AI with purpose, putting choice, governance, and long-term value at the centre of digital experiences.

Umbraco Compose example project

Wed, 04 Feb 2026 09:22:23 Z

YouTube: Umbraco Compose example project: https://www.youtube.com/watch?v=tXdbHn14Gn8

Mitigating CVE-2025-67288 in Umbraco 13 (if you feel you need to)

Wed, 04 Feb 2026 02:49:57 Z

Firstly, this is a really ill-informed CVE. If you've not read my comment on the Umbraco Forum, I'll repeat the key bits, otherwise feel free to scroll down to the good stuff.

A bit about CVE-2025-67288

If you want the details you can read the full CVE at nvd.nist.gov. Umbraco is in the process of disputing it.

Let me break down why I think it's mostly nonsense...

Remote Code Execution?

It’s an attention grabbing PoC..

Upload a crafted PDF file containing embedded JavaScript.
Observe that JavaScript from the PDF executes in the browser.

But what does Umbraco have to do with that? You could upload the file anywhere - in fact, and click this link if you dare, I've uploaded that file to a GitHub pages site.
Does that mean GitHub is vulnerable to a CWE-434…? No, and neither is Umbraco.

This is what a CWE-434 means...

The product allows the upload or transfer of dangerous file types that are automatically processed within its environment.

Emphasis mine, but this "CVE" doesn’t pass that test. Umbraco doesn't process the PDF such that arbitrary code can be run on your Umbraco site.

So, remote code execution worthy a CVSS score of 10.0? No.

Is is really XSS?

Look more closely at the XSS (Cross Site Scripting) claim. Where does the JavaScript actually run? In the browser, sure, but it’s not run in the context of the Umbraco site (or GitHub.io, if you were brave and clicked the link above). It’s sandboxed by the browser and not treated like it’s running on your domain at all.

This is such a common misconception that Chromium has an FAQ titled "Does executing JavaScript in a PDF file mean there's an XSS vulnerability?". Spoiler alert, the answer is no.

It's JavaScript, but not as we know it

It doesn’t have access to any important browser APIs - i.e. no fetch() or document.cookies etc. in fact if you look at the alert itself you’ll see it’s calling app.alert()… that’s not a web browser API but a PDF one :face_with_monocle:

If you try and craft a more complex JavaScript payload you’ll quickly find that the browser will block any APIs that could present a real risk to the user.

Even if you could craft malicious JavaScript that executes in a browser, that CVE would really be the browser’s problem, not Umbraco’s.

If you're feeling extra nerdy, you can have a read of the design doc for the PDF Viewer in Chromium. It talks about sandboxing, what kinds of JavaScript execution are allowed, and why.

Obviously there’s still a potential social engineering/phishing angle with these crafted PDFs… but that’s a whole different issue.

But good news, you can still mitigate against it!

Enter the IFileStreamSecurityAnalyzer

It's a simple interface you can implement that Umbraco will then run uploaded filestreams through so you can add any logic you want to check if the files are safe.

public interface IFileStreamSecurityAnalyzer
{
    /// <summary>
    /// Indicates whether the analyzer should process the file
    /// The implementation should be considerably faster than IsConsideredSafe
    /// </summary>
    /// <param name="fileStream"></param>
    /// <returns></returns>
    bool ShouldHandle(Stream fileStream);

    /// <summary>
    /// Analyzes whether the file content is considered safe
    /// </summary>
    /// <param name="fileStream">Needs to be a Read/Write seekable stream</param>
    /// <returns>Whether the file is considered safe</returns>
    bool IsConsideredSafe(Stream fileStream);
}

The docs have a nice example showing you how to protect against a potentially malicious SVG file.

In a similar fashion we can implement our own class that will read a PDF< look for any JavaScript, and return false when IsConsideredSafe() is called.

Notice the ShouldHandle() method only takes the stream. File extensions don't necessarily match up with what's actually in a file so we need to check the contents first to see if this is actually a PDF. A quick way of doing that is to parse just the file signature in the file header.

There's a package for that!

dotnet add package FileSignatures

Then for the PDF reading, I'm using PdfPig:

dotnet add package PdfPig

Here I need to add a disclaimer. The following code is based on something I'm using in production but the PDF library I'm using has rather restrictive/expensive licensing and I wanted to give you a demo that "Just Works" with some friendly OSS libraries - so I asked AI to help me rewrite this for PdfPig.

internal class PdfSecurityAnalyzer(
    ILogger<PdfSecurityAnalyzer> logger,
    IFileFormatInspector fileFormatInspector) : IFileStreamSecurityAnalyzer
{
    private static readonly HashSet<string> _suspiciousKeys =
    [
        "AA",           // Additional Actions
        "OpenAction",   // Actions triggered on document open
        "JS",           // JavaScript Stream
        "JavaScript",   // Explicit JavaScript name
        "Launch",       // Launch external applications
        "SubmitForm",   // Form submission (potential data exfiltration)
        "ImportData"    // Import external data
    ];

    public bool IsConsideredSafe(Stream fileStream)
    {
        fileStream.Position = 0;

        var options = new ParsingOptions { UseLenientParsing = true };

        try
        {
            using var document = PdfDocument.Open(fileStream, options);
            var visited = new HashSet<IndirectReference>();

            // Check the entire document structure starting from catalog
            if (ContainsSuspiciousContent(document.Structure.Catalog.CatalogDictionary, document, visited))
            {
                return false;
            }

            return true;
        }
        catch (Exception ex)
        {
            logger.LogWarning(ex, "Failed to parse PDF for security analysis");
            return false;
        }
    }

    private bool ContainsSuspiciousContent(IToken token, PdfDocument document, HashSet<IndirectReference> visited)
    {
        return token switch
        {
            null => false,
            DictionaryToken dict => CheckDictionary(dict, document, visited),
            ArrayToken array => CheckArray(array, document, visited),
            IndirectReferenceToken refToken => CheckIndirectReference(refToken, document, visited),
            StreamToken stream => ContainsSuspiciousContent(stream.StreamDictionary, document, visited),
            ObjectToken objToken => ContainsSuspiciousContent(objToken.Data, document, visited),
            _ => false
        };
    }

    private bool CheckDictionary(DictionaryToken dict, PdfDocument document, HashSet<IndirectReference> visited)
    {
        // Check for suspicious keys
        foreach (var keyName in dict.Data.Keys)
        {
            if (_suspiciousKeys.Contains(keyName)) return true;

            // Subtype Check: /S /JavaScript
            if (keyName == "S" 
                && dict.TryGet(NameToken.S, out NameToken subtype)
                && subtype.Data == "JavaScript")
            {
                return true;
            }
        }

        // Recurse into all dictionary values
        return dict.Data.Values.Any(value => ContainsSuspiciousContent(value, document, visited));
    }

    private bool CheckArray(ArrayToken array, PdfDocument document, HashSet<IndirectReference> visited)
    {
        return array.Data.Any(item => ContainsSuspiciousContent(item, document, visited));
    }

    private bool CheckIndirectReference(IndirectReferenceToken refToken, PdfDocument document, HashSet<IndirectReference> visited)
    {
        if (visited.Contains(refToken.Data)) return false;

        visited.Add(refToken.Data);

        try
        {
            var actualToken = document.Structure.GetObject(refToken.Data);
            return ContainsSuspiciousContent(actualToken, document, visited);
        }
        catch
        {
            return false;
        }
    }

    public bool ShouldHandle(Stream fileStream)
    {
        var format = fileFormatInspector.DetermineFileFormat(fileStream);

        if (format is Pdf)
        {
            return true;
        }

        return false;
    }
}

And then to register it, use an IComposer:

public class RegisterFileStreamSecurityAnalysers : IComposer
{
    public void Compose(IUmbracoBuilder builder)
    {
        var recognised = FileFormatLocator.GetFormats().OfType<Pdf>();
        var inspector = new FileFormatInspector(recognised);
        builder.Services.AddSingleton<IFileFormatInspector>(inspector);

        builder.Services.AddSingleton<IFileStreamSecurityAnalyzer, PdfSecurityAnalyzer>();
    }
}

Notice I'm configuring the FileFormatInspector to only look for PDFs, which is better for performance but you can add multiple file types or configure it to look for all types known by the library - have a look at the GitHub Repo for more info.

With the above code implemented, try and upload a PDF containing JavaScript (like the perfectly benign one I linked to above), and you'll get this lovely error message.

You may get some false positives, but this was all about false positives really, wasn't it...

Jumoo.TranslationManager.UmbracoAi

Wed, 04 Feb 2026 00:00:00 Z

UmbracoAi Connector for Jumoo.TranslationManager

Umbraco.AI.Persistence

Wed, 04 Feb 2026 00:00:00 Z

EF Core persistence layer for Umbraco AI

Umbraco.AI.Core

Wed, 04 Feb 2026 00:00:00 Z

Contains core logic for Umbraco AI

Umbraco.AI.Agent.Startup

Wed, 04 Feb 2026 00:00:00 Z

Startup and DI registration for Umbraco AI Agent

Umbraco.AI.Persistence.SqlServer

Wed, 04 Feb 2026 00:00:00 Z

SQL Server migrations for Umbraco AI persistence

Umbraco.AI.Prompt.Core

Wed, 04 Feb 2026 00:00:00 Z

Core domain models and services for Umbraco AI Prompt

Umbraco.AI.Agent.Persistence.Sqlite

Wed, 04 Feb 2026 00:00:00 Z

SQLite migrations for Umbraco AI Agent

Umbraco.AI.Agent.Web

Wed, 04 Feb 2026 00:00:00 Z

Management API for Umbraco AI Agent

Umbraco.AI.Prompt.Startup

Wed, 04 Feb 2026 00:00:00 Z

Startup and DI registration for Umbraco AI Prompt

Umbraco.AI.Prompt.Persistence.SqlServer

Wed, 04 Feb 2026 00:00:00 Z

SQL Server migrations for Umbraco AI Prompt

Umbraco.AI.Startup

Wed, 04 Feb 2026 00:00:00 Z

Contains startup logic for Umbraco AI

Umbraco.AI.Prompt.Persistence

Wed, 04 Feb 2026 00:00:00 Z

EF Core persistence layer for Umbraco AI Prompt

Umbraco.AI.Prompt.Persistence.Sqlite

Wed, 04 Feb 2026 00:00:00 Z

SQLite migrations for Umbraco AI Prompt

Umbraco.AI.Agent.Persistence

Wed, 04 Feb 2026 00:00:00 Z

EF Core persistence layer for Umbraco AI Agent

Upgrading Umbraco 13 to Umbraco 17 issue

Wed, 04 Feb 2026 00:00:00 Z

Umbraco.AI.Agent.Persistence.SqlServer

Wed, 04 Feb 2026 00:00:00 Z

SQL Server migrations for Umbraco AI Agent

Umbraco.AI.Prompt.Web

Wed, 04 Feb 2026 00:00:00 Z

Management API for Umbraco AI Prompt

Upgrading Umbraco 13 to Umbraco 17 issue

Wed, 04 Feb 2026 00:00:00 Z

Umbraco.AI.Agent.Core

Wed, 04 Feb 2026 00:00:00 Z

Core domain models and services for Umbraco AI Agent

Umbraco.AI.Persistence.Sqlite

Wed, 04 Feb 2026 00:00:00 Z

SQLite migrations for Umbraco AI persistence

Umbraco.AI.Web

Wed, 04 Feb 2026 00:00:00 Z

Management API for Umbraco AI

Umbraco Compose Unboxing

Tue, 03 Feb 2026 15:45:36 Z

Umbraco Compose eases the management of data flows in complex enterprise projects. It’s the “in between” data orchestration layer between your tech stack and your frontend(s) that ensures clean and streamlined connections, freeing you from hours of setting up custom endpoints, ongoing maintenance, and time-consuming debugging. In this unboxing video, Lasse and Allen provide you with a technical deep dive into how Umbraco Compose works.

Umbraco Compose - From Complexity to Clarity

Tue, 03 Feb 2026 15:45:22 Z

No more "Spaghetti Knot" Architecture. With Umbraco Compose, you can build Clean Composable Architecture. Some call it data orchestration. Others, a fully managed backend-for-frontend. We call it Umbraco Compose. Learn more about Umbraco Compose here: www.umbraco/compose.com

Skrift Issue #124

Tue, 03 Feb 2026 00:00:00 Z

Featuring guest posts by Nathaniel Nunes on "Using Serilog Enrichers with Umbraco" and Georgina Bidder on "Not Your Usual Compliance Monitoring Tool"

Umbraco.Commerce.PaymentProviders.Kustom

Tue, 03 Feb 2026 00:00:00 Z

Kustom payment provider for Umbraco Commerce

Umbraco.AI.Prompt

Tue, 03 Feb 2026 00:00:00 Z

Prompt management plugin for Umbraco AI

Introducing Umbraco Compose

Tue, 03 Feb 2026 00:00:00 Z

We’re proud to launch our new Data Orchestration Platform: Umbraco Compose. A platform that’ll ease the management of data flows in complex enterprise projects. Discover how Compose can save you hundreds of development hours and struggles.

Umbraco.AI.Agent

Tue, 03 Feb 2026 00:00:00 Z

Agent management plugin for Umbraco AI

Umbraco.AI.Anthropic

Tue, 03 Feb 2026 00:00:00 Z

Anthropic provider for Umbraco AI

Umbraco.AI.MicrosoftFoundry

Tue, 03 Feb 2026 00:00:00 Z

Microsoft AI Foundry provider for Umbraco AI

Umbraco.AI.Amazon

Tue, 03 Feb 2026 00:00:00 Z

Amazon Bedrock provider for Umbraco AI

uHeroSlider

Tue, 03 Feb 2026 00:00:00 Z

A commercial-grade, advanced hero slider solution for Umbraco 17+. Features image/video support, custom animations per slide, scheduling with timezone support, festival scheduling, auto-slide, loop controls, and fallback images.

Umbraco.AI.OpenAI

Tue, 03 Feb 2026 00:00:00 Z

OpenAI provider for Umbraco AI

Umbraco.AI.Google

Tue, 03 Feb 2026 00:00:00 Z

Google provider for Umbraco AI

Umbraco.AI

Tue, 03 Feb 2026 00:00:00 Z

Umbraco AI

Solving Port Conflicts in AI-Assisted Development: HTTP over Named Pipes

Mon, 02 Feb 2026 19:00:00 Z

The way I work day to day has changed quite a lot over the last 6 months. AI coding assistants like Claude Code aren’t just speeding up individual...

UmbNav 4.1.0 for Umbraco V17+

Mon, 02 Feb 2026 13:10:16 Z

UmbNav 4.1.0 for Umbraco V17+ is here! This update is a biggy: ✅ Enhances drag and drop functionality. ✅ Reworks the menu service. ✅ Simplifies extension points. ✅ Implements package migration for legacy data format. ✅ Adds unit tests for increased code reliability. ✅ Introduces code analysis and review workflows. ✅ Bumps version number to 4.1.0. ✅ IsActive extension method overhauled h5yr to hotchillicode for the migration PR! Grab it here: https://www.nuget.org/packages/Umbraco.Community.UmbNav

Customizing Umbraco ModelsBuilder Output

Mon, 02 Feb 2026 11:33:05 Z

Umbraco's ModelsBuilder is a fantastic tool that generates strongly-typed models from your document types. But what if you want to customize the generated output? Maybe you want to add property alias constants or other custom code to your models.

In this article, I'll show you how to create a custom ModelsGenerator that post-processes the generated files to add your own customizations.

The Problem

When working with Umbraco, you often need to reference property aliases as strings - for example, when using SetValue() while creating or editing content through the ContentService, or maybe you need the dynamic property access from IPublishedContent. This means scattering magic strings throughout your codebase:

// setting a property value on IContent
var title = content.SetValue("pageTitle", "New Title");

// checking for a property on IPublishedContent
var items = content.Children.Where(x => x.HasValue("featuredImage"));

If a property alias changes, you'll need to hunt down every occurrence. It would be much better to have strongly-typed constants for each property alias, so you get compile-time safety and IntelliSense support.

ModelsBuilder does provide a way to get the property aliases from the document type, but it is rather verbose, and it requires a dependency on IPublishedContentTypeCache:

@using Umbraco.Cms.Core.PublishedCache
@inject IPublishedContentTypeCache _contentTypeCache;
@{
    var blocksPropertyAlias = ContentPage.GetModelPropertyType(_contentTypeCache, x => x.Blocks)?.Alias;
}

The Solution

We can create a custom ModelsGenerator that runs after the standard generation and post-processes the output files. This approach:

Doesn't require modifying Umbraco's source code
Works with the existing ModelsBuilder pipeline
Allows for any kind of text manipulation on generated files

Here's the full implementation:

using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Options;
using System.Text;
using System.Text.RegularExpressions;
using Umbraco.Cms.Core.Configuration.Models;
using Umbraco.Cms.Infrastructure.ModelsBuilder;
using Umbraco.Cms.Infrastructure.ModelsBuilder.Building;
using Umbraco.Extensions;

namespace MyProject.ModelsGenerators;

public class MyOwnModelsGenerator(
    UmbracoServices umbracoService,
    IOptionsMonitor<ModelsBuilderSettings> config,
    OutOfDateModelsStatus outOfDateModels,
    IHostEnvironment hostingEnvironment)
    : ModelsGenerator(umbracoService, config, outOfDateModels, hostingEnvironment), IModelsGenerator
{
    public new void GenerateModels()
    {
        base.GenerateModels();

        var modelsDirectory = config.CurrentValue.ModelsDirectoryAbsolute(hostingEnvironment);
        if (!Directory.Exists(modelsDirectory)) return;

        foreach (var file in Directory.GetFiles(modelsDirectory, "*.generated.cs"))
        {
            var fileContents = File.ReadAllText(file);
            var newFileContents = AddPropertyAliasConstants(fileContents);

            if (newFileContents != fileContents)
            {
                File.WriteAllText(file, newFileContents);
            }
        }
    }

    private static string AddPropertyAliasConstants(string fileContents)
    {
        var marker = "public new const string ModelTypeAlias =";
        var index = fileContents.IndexOf(marker, StringComparison.Ordinal);
        if (index == -1) return fileContents;

        var pattern = @"\[.*ImplementPropertyType\(""([^""]+)""\)\][\s\S]*?public\s+(?:virtual\s+)?[\w\.:<>]+\s+([A-Za-z0-9_]+)\s*(?:{|=>)";
        var matches = Regex.Matches(fileContents, pattern);

        var sb = new StringBuilder();
        sb.Append("public new static class ModelPropertyAliases\n\t\t{\n");
        foreach (Match match in matches)
        {
            var alias = match.Groups[1].Value;
            var propName = match.Groups[2].Value;
            sb.Append($"\t\t\tpublic const string {propName} = \"{alias}\";\n");
        }
        sb.Append("\t\t}\n\n\t\t");

        return fileContents.Insert(index, sb.ToString());
    }
}

How It Works

The custom generator does a few key things:

1. Inheriting from ModelsGenerator

By inheriting from ModelsGenerator and implementing IModelsGenerator, we can override the generation behavior while still using all the built-in functionality.

public class MyOwnModelsGenerator : ModelsGenerator, IModelsGenerator

2. Post-Processing Generated Files

The GenerateModels() method first calls base.GenerateModels() to run the standard generation, then iterates through all *.generated.cs files to apply our customizations:

public new void GenerateModels()
{
    base.GenerateModels();

    var modelsDirectory = _config.ModelsDirectoryAbsolute(_hostingEnvironment);
    foreach (var file in Directory.GetFiles(modelsDirectory, "*.generated.cs"))
    {
        // Post-process each file...
    }
}

3. Adding Property Alias Constants

The AddPropertyAliasConstants method uses regex to find all properties marked with [ImplementPropertyType] and extracts both the alias and property name. It then generates a nested static class containing constants for each property:

public new static class ModelPropertyAliases
{
    public const string PageTitle = "pageTitle";
    public const string FeaturedImage = "featuredImage";
    public const string Blocks = "blocks";
}

Registering the Custom Generator

To use your custom generator, you need to register it with Umbraco's dependency injection. Add this to your startup configuration:

builder.Services.AddSingleton<IModelsGenerator, MyOwnModelsGenerator>();

Or if you're using a composer:

public class ModelsGeneratorComposer : IComposer
{
    public void Compose(IUmbracoBuilder builder)
    {
        builder.Services.AddSingleton<IModelsGenerator, MyOwnModelsGenerator>();
    }
}

Using the Generated Constants

Once the models are regenerated, you can use the constants throughout your code:

// Before: magic strings
content.SetValue("pageTitle", "New Title");

// After: strongly-typed constants
content.SetValue(HomePage.ModelPropertyAliases.PageTitle, "New Title");

// Works great in LINQ queries too
var featured = content.Children
    .Where(x => x.HasValue(Article.ModelPropertyAliases.FeaturedImage));

Now if a property alias changes, you'll get a compile-time error instead of a runtime surprise.

Final Thoughts

Customizing ModelsBuilder output gives you more control over your generated code without fighting against the built-in tooling. By post-processing the generated files, you can add compile-time safety features like property alias constants while keeping all the benefits of automatic model generation.

The approach shown here - inheriting from ModelsGenerator and processing files after generation - is clean, maintainable, and survives Umbraco upgrades since it doesn't modify any core code.

Umbraco media search with Azure AI Vision

Mon, 02 Feb 2026 00:00:00 Z

Integrating Azure AI Vision and Umbraco Search to implement image content search powered by image recognition.

Umbraco.Community.CustomValidator

Mon, 02 Feb 2026 00:00:00 Z

A comprehensive document validation framework for Umbraco CMS that provides real-time content validation with a backoffice UI. Display validation results directly in the Umbraco backoffice with support for multi-culture content, severity levels (Error, Warning, Info), and automatic publish blocking when errors are present.

AI.Diagnostics

Sun, 01 Feb 2026 00:00:00 Z

AI Diagnostics analyzes application logs using AI to simplify complex issues by identifying possible root causes and providing actionable suggestions to fix them.

ArroSimpleForm

Sat, 31 Jan 2026 00:00:00 Z

Arro Simple Form is a tool that allows Umbraco users to create dynamic forms without writing code and integrate them into their Umbraco websites. It saves user-submitted data and can automatically send emails upon form submission.

DJRetailing.Umbraco.Suite

Sat, 31 Jan 2026 00:00:00 Z

umbraCoffee - New Year, new U?!

Fri, 30 Jan 2026 11:00:08 Z

Welcome to your monthly dose of #umbraCoffee! Your hosts - Marcin and Callum - together with their guest(s) will drive through all of the community news and happenings in the Umbraco world. So... grab a cuppa, join us LIVE and enjoy! See ya?! --- ☕ Wanna buy us a coffee/pizza/donuts? https://www.buymeacoffee.com/umbracoffee --- Notes: // TODO

Handling editor-injected JavaScript in Umbraco v17 with Umbraco Community CSPManager

Fri, 30 Jan 2026 00:00:00 Z

Handling editor-injected JavaScript in Umbraco v17 with Umbraco.Community.CSPManager

Fri, 30 Jan 2026 00:00:00 Z

@umbraco-cms/mcp-dev

Fri, 30 Jan 2026 00:00:00 Z

An MCP (Model Context Protocol) server for Umbraco CMS that unlocks AI-powered content management via the Umbraco Management API.

TagHelpers v2.0.0 with Umbraco v16+ support

Thu, 29 Jan 2026 10:02:29 Z

Released: Umbraco Compose example project

Thu, 29 Jan 2026 08:03:27 Z

Released: Umbraco Compose example project - jeroenbreuer.nl

Find the right Umbraco icon with "Umbraco Iconomancer"

Tue, 27 Jan 2026 17:24:19 Z

While fondly remembering going to the ucreate umbraco icons github page, I did some digressing today trying to make the process of "finding-the-right-icon™" even more enjoyable. Meet the "Umbraco Iconomancer", a Custom GPT with the sole purpose of making your "finding-the-right-icon™" experience umbazing. 😁🤭 https://chatgpt.com/g/g-697788bd87888191aefe76e552c70820-umbraco-iconomancer

Package.json as Single Source of Truth: How Umbraco Auto-Generates TypeScript Paths and Browser Import Maps

Tue, 27 Jan 2026 15:34:30 Z

Summary

Building an extensible web application with 120+ shared packages creates a unique challenge: the same import must resolve to different locations during development (TypeScript source files), build time (external dependencies), and runtime (browser-served files). Traditional approaches require maintaining this mapping in three different config formats - TypeScript paths, test runner, and browser import maps - leading to inevitable configuration drift and an entire class of "works in dev, breaks in production" bugs.

Umbraco CMS solves this through code generation: treating package.json exports as a single source of truth and automatically generating all configurations from it. A 200-line transformation script reads the exports field and produces TypeScript paths (with dist-cms → src transformations), browser import maps (with dist-cms → /umbraco/backoffice/ transformations), and test runner configs - all from one edit point. This makes configuration drift architecturally impossible: if TypeScript can find it, the browser can load it.

The result is a pattern that scales to 120+ packages while maintaining correctness guarantees, enabling internal refactoring without breaking consumers, and providing the foundation for a professional, extensible package system built on web standards.

The Problem with Raw File Paths

When building extensions for Umbraco's backoffice, you've probably written code like this:

import { UmbElementMixin } from '@umbraco-cms/backoffice/element-api';
import { UMB_NOTIFICATION_CONTEXT } from '@umbraco-cms/backoffice/notification';

But have you ever wondered how this actually works?

You DO install the @umbraco-cms/backoffice NPM package for types, yet the browser doesn't load code from node_modules. Instead, it loads from the Umbraco server. How does TypeScript know about the types during development, while the browser loads different files at runtime?

This is the dual-resolution problem - the same import must resolve to different locations at development time versus runtime. Umbraco solves it elegantly through a three-layer implementation combining TypeScript paths, Vite's external configuration, and browser import maps.

The Traditional Approach (And Why It's Problematic)

Before Umbraco 14, you might have seen Umbraco extensions written with AngularJS having magical service injections based on strings like this:

// ❌ Old approach: magic strings (entityService)
angular.module('umbraco').directive(function (entityService) {
    // Do work with entityService
});

You may even have imported modules of your own by virtue of Require.js or similar:

// ❌ Old approach: raw file paths
require('/App_Plugins/MyPackage/utils.js');

This works, but it has several problems:

Brittle: If you move files, all imports break
Exposes Implementation: Everyone sees your internal file structure
Not Refactorable: IDEs can't help you rename or move things
Unprofessional: Looks like a hack rather than proper module architecture
Hard to Type: TypeScript struggles to provide IntelliSense for dynamic imports with string paths

The Umbraco Solution: Three Layers for Dual Resolution

Umbraco CMS version 14 and beyond solves the dual-resolution problem (development vs runtime) through a three-layer implementation that makes imports work in different contexts:

Development (TypeScript): Resolves to source files for type-checking
Build (Vite/Rollup): Marks as external, leaves imports as-is
Runtime (Browser): Resolves to built files via importmap

Let's see how each layer works.

Layer 1: TypeScript Resolution

TypeScript needs to know what @umbraco-cms/backoffice/notification means for type-checking.

For Umbraco Core Development (working on the backoffice itself):

{
    "compilerOptions": {
        "paths": {
            "@umbraco-cms/backoffice/notification": ["./src/packages/core/notification/index.ts"]
        }
    }
}

This maps imports to source files for development on Umbraco itself.

Note for Umbraco core developers: This tsconfig.json is auto-generated from package.json exports by a build script. See the next section to understand how this works.

For Extension Authors (building backoffice extensions):

Just install the NPM package:

npm install -D @umbraco-cms/backoffice

TypeScript automatically finds type definitions from node_modules/@umbraco-cms/backoffice - no paths config needed!

Result: Full IntelliSense, type-checking, and refactoring support in your IDE.

Why: Because the package.json file contains an "exports" field that defines the public API (more on that later).

Layer 2: Build Resolution (Vite)

When building an extension, Vite needs to know not to bundle Umbraco's code. This is the key step - even though you installed the NPM package, you mark it as external:

// vite.config.ts
export default defineConfig({
    build: {
        rollupOptions: {
            external: [
                /^@umbraco-cms/, // Don't bundle - even though it's in node_modules!
            ],
        },
    },
});

This tells Vite: "When you encounter @umbraco-cms/backoffice/*, don't bundle it from node_modules. Leave the import statement as-is in the output."

Result: Your built JavaScript contains import('@umbraco-cms/backoffice/notification') exactly as written - no bundled code from the NPM package. The NPM package was only used for TypeScript types during development.

Note: This is important for versioning. You may, in fact, multi-target your package regardless of the version of the installed NPM package, as it only provides types.

Layer 3: Runtime Resolution (Importmap)

When the browser loads your extension, it needs to know where to find the actual files:

{
    "importmap": {
        "imports": {
            "@umbraco-cms/backoffice/notification": "/umbraco/backoffice/packages/core/notification/index.js"
        }
    }
}

This is defined in the backoffice's package manifest and tells the browser: "When you see an import for @umbraco-cms/backoffice/notification, load this actual file."

Result: The browser successfully loads the real JavaScript file at runtime.

How It All Works Together

Let's follow an import through all three layers:

You write:

import { UMB_NOTIFICATION_CONTEXT } from '@umbraco-cms/backoffice/notification';

During Development:

TypeScript sees the import
Finds types from the installed NPM package (@umbraco-cms/backoffice in node_modules)
Provides IntelliSense from the .d.ts files
✅ Full type safety and autocomplete

During Build:

Vite encounters the import
Checks rollupOptions.external - matches /^@umbraco-cms/
Doesn't bundle the code from node_modules - leaves import as-is
✅ Output contains: import('@umbraco-cms/backoffice/notification') (no bundled code!)

At Runtime:

Browser encounters the import
Checks the importmap
Resolves to /umbraco/backoffice/packages/core/notification/index.js
✅ Loads the actual file

The Innovation: Code Generation from package.json

Now here's where Umbraco's solution gets clever. With 120+ packages in the backoffice, manually maintaining TypeScript paths, Vite externals, and import maps would be a nightmare.

The Scale Problem

Consider what's required for each of those 120+ packages:

TypeScript tsconfig.json: Map @umbraco-cms/backoffice/notification to ./src/packages/core/notification/index.ts
Vite config: Mark as external (regex pattern handles this automatically)
Runtime umbraco-package.json: Map @umbraco-cms/backoffice/notification to /umbraco/backoffice/packages/core/notification/index.js
Test runner configs: Various formats for Web Test Runner

That's 120+ entries in tsconfig.json, 120+ entries in the import map, and keeping them all in sync. A single typo breaks everything. Adding a new package requires updating multiple files in different formats.

This is untenable.

Umbraco's Solution: Single Source of Truth

Umbraco solves this with code generation, treating package.json as the golden source of truth:

package.json exports (source of truth)
    ↓
devops/importmap/index.js (reads and transforms)
    ↓
    ├→ devops/tsconfig/index.js → tsconfig.json (120+ paths)
    ├→ devops/build/create-umbraco-package.js → umbraco-package.json (import map)
    └→ Test runner configuration

One edit point. Four outputs. Always in sync.

Why package.json as the Source?

The package.json already defines the public API contract with its exports field:

{
    "name": "@umbraco-cms/backoffice",
    "exports": {
        ".": null,
        "./notification": "./dist-cms/packages/core/notification/index.js",
        "./content": "./dist-cms/packages/content/content/index.js",
        "./modal": "./dist-cms/packages/core/modal/index.js"
        // ... 117+ more packages
    }
}

Why this is the perfect source:

✅ Already required: Published to npm, consumed by TypeScript naturally
✅ Defines the contract: Lists every public import path
✅ Standard format: Uses Node.js package exports (not a custom format)
✅ Single edit point: Add/remove/rename a package in one place

The ".": null is intentional - it prevents importing the root package and forces consumers to use specific subpaths like @umbraco-cms/backoffice/notification.

Implementation: The Transformation Pipeline

Here's how Umbraco's build scripts transform this single source into multiple formats.

Step 1: Create Import Map Structure

The devops/importmap/index.js script reads package.json exports and creates an intermediate import map:

export const createImportMap = (args) => {
    const imports = {
        ...args.additionalImports,
    };

    // Iterate over the exports in package.json
    for (const [key, value] of Object.entries(packageJsonExports || {})) {
        // Skip null exports and non-JS files
        if (value && value.endsWith('.js')) {
            const moduleName = key.replace(/^\.\//, '');

            // Transform the path based on context
            let modulePath = value;
            if (typeof args.rootDir !== 'undefined') {
                modulePath = modulePath.replace(/^\.\/dist-cms/, args.rootDir);
            }
            if (args.replaceModuleExtensions) {
                modulePath = modulePath.replace('.js', '.ts');
            }

            const importAlias = `${packageJsonName}/${moduleName}`;
            imports[importAlias] = modulePath;
        }
    }

    return { imports };
};

Step 2: Generate TypeScript Paths

The devops/tsconfig/index.js script uses createImportMap() with transformations for TypeScript:

const importmap = createImportMap({
    rootDir: './src', // dist-cms → src
    additionalImports: {
        '@umbraco-cms/internal/test-utils': './utils/test-utils.ts',
    },
    replaceModuleExtensions: true, // .js → .ts
});

// Convert to tsconfig.json format
const paths = {};
for (const [key, value] of Object.entries(importmap.imports)) {
    paths[key] = [value]; // tsconfig expects arrays
}

tsConfigBase.compilerOptions.paths = paths;

Generated output (tsconfig.json):

{
    "compilerOptions": {
        "paths": {
            "@umbraco-cms/backoffice/notification": ["./src/packages/core/notification/index.ts"],
            "@umbraco-cms/backoffice/content": ["./src/packages/content/content/index.ts"],
            "@umbraco-cms/backoffice/modal": ["./src/packages/core/modal/index.ts"]
            // ... 117+ more
        }
    }
}

Step 3: Generate Runtime Import Map

The devops/build/create-umbraco-package.js script transforms for browsers:

const importmap = createImportMap({
    rootDir: '/umbraco/backoffice', // dist-cms → server path
    replaceModuleExtensions: false, // Keep .js for runtime
});

// Write to umbraco-package.json
const manifest = {
    name: '@umbraco-cms/backoffice',
    version: packageVersion,
    importmap: {
        imports: importmap.imports,
    },
};

Generated output (umbraco-package.json):

{
    "name": "@umbraco-cms/backoffice",
    "importmap": {
        "imports": {
            "@umbraco-cms/backoffice/notification": "/umbraco/backoffice/packages/core/notification/index.js",
            "@umbraco-cms/backoffice/content": "/umbraco/backoffice/packages/content/content/index.js",
            "@umbraco-cms/backoffice/modal": "/umbraco/backoffice/packages/core/modal/index.js"
            // ... 117+ more
        }
    }
}

The Key Transformations

From the same package.json export "./notification": "./dist-cms/packages/core/notification/index.js", we generate:

Context	Transformation	Output
TypeScript	`dist-cms` → `src` `.js` → `.ts`	`./src/packages/core/notification/index.ts`
Runtime	`dist-cms` → `/umbraco/backoffice/` Keep `.js`	`/umbraco/backoffice/packages/core/notification/index.js`
Package Name	Prepend package name and subpath	`@umbraco-cms/backoffice/notification`

Same logical structure. Different physical paths for different contexts.

Build Pipeline Integration

These scripts run at specific points in the development lifecycle:

During development:

npm run generate:tsconfig  # Regenerates tsconfig.json from package.json

Before build:

npm run generate:manifest  # Generates umbraco-package.json with import map

In CI/CD:

npm run package:validate   # Validates that exports, paths, and imports are in sync

Adding a new package:

Edit package.json: Add one line to exports
Run npm run generate:tsconfig
Run npm run generate:manifest
Done ✅

No manual editing of configs. No risk of typos or drift.

The Result: Impossible to Have Config Drift

Because everything is generated from the same source, it's architecturally impossible for configs to drift out of sync. If TypeScript can find it, the browser can load it. If the import map has it, TypeScript knows about it.

This eliminates an entire class of bugs:

❌ Import works in TypeScript but fails at runtime
❌ Import works at runtime but TypeScript can't find types
❌ Test runner can't resolve import that works everywhere else

With code generation, these bugs cannot exist.

Why This Architecture Works at Scale

The code generation approach provides significant advantages in production:

1. Eliminates Config Drift

Manual maintenance inevitably leads to drift. A developer adds a TypeScript path but forgets the import map. Tests pass locally but production breaks.

With code generation, this is impossible. One source of truth means one failure mode: if package.json is wrong, everything is wrong. Easy to catch, easy to fix.

2. Maintainability

Manual approach:

120 packages × 3 configs = 360 entries to maintain
Each in a different format
Spread across 4+ files

Generated approach:

120 entries in package.json (source of truth)
1 script that generates everything else
~200 lines of transformation logic (vs 360+ lines of config)

3. Type Safety

TypeScript provides full autocomplete and refactoring support. If you rename a package in package.json, regenerate configs, and TypeScript immediately shows you every place that needs updating.

4. Refactorability

Internal file structure can change without breaking consumers. As long as package.json exports stay the same, consumers see a stable API. The generation scripts handle the internal path changes.

Example: Moving notification from packages/core/ to packages/alerts/ requires:

Updating one path in package.json
Regenerating configs
Zero changes for extension authors

The NPM Package: Types and Code, But Not Bundled

Here's where the pattern gets clever. Umbraco publishes an NPM package that contains both runtime JavaScript and TypeScript definitions:

npm install -D @umbraco-cms/backoffice

Extension authors install this package, but here's the trick: they mark it as external in vite.config.ts (as shown above), which prevents Vite from bundling the runtime code even though it's present in node_modules.

This means:

TypeScript uses the package for types and IntelliSense during development
Vite sees it's external and doesn't bundle it
The browser loads the actual runtime code from the server at runtime

The complete picture:

Development: TypeScript finds types from the installed NPM package
Build: Vite sees external config and doesn't bundle the code from node_modules
Runtime: Browser uses importmap to load actual files from /umbraco/backoffice/

The magic: Same NPM package name (@umbraco-cms/backoffice/*), but:

In development → resolved to types from node_modules for IntelliSense
At build → marked external, not bundled
At runtime → resolved to server files via importmap

Why Alternatives Don't Work

At this point, you might be wondering: "If import maps create all this config duplication, why use them at all? Are there better alternatives?"

It's a fair question. Let's consider what else we could have done.

Alternative 1: Traditional NPM Package (Bundle Our Code)

What if we published the runtime code to NPM and let extension authors bundle it?

npm install @umbraco-cms/backoffice

Extension authors would import and bundle our code into their extensions.

Why this doesn't work:

❌ Code duplication: Every extension bundles the same 22kb of Search code
❌ Version conflicts: Extension A uses Search v1.0, Extension B uses v1.1 - both loaded
❌ No shared state: Global contexts can't communicate across separately bundled instances
❌ Bundle bloat: The backoffice loads the same code 5 times for 5 extensions
❌ Defeats code-splitting: We carefully split global/core bundles - all wasted

Verdict: This defeats the entire architectural purpose. We'd be back to the jQuery plugin days where every extension bundles duplicate dependencies.

Alternative 2: Raw File Paths (Skip the Abstraction)

What if we skipped logical imports and used raw paths?

// Extension authors would write:
api: () => import('/umbraco/backoffice/packages/content/index.js').then((m) => ({ default: m.UmbContentRepository }));

Why this doesn't work:

❌ Brittle: If we reorganize files, every extension breaks
❌ No abstraction: Exposes implementation details to consumers
❌ No TypeScript support: How do extension authors get types?
❌ Unprofessional: Looks like a hack rather than proper package architecture
❌ Non-refactorable: IDEs can't help with renames or moves

Alternative 3: Custom Vite Plugin

What if we built a Vite plugin that understands Umbraco packages?

import { umbracoPlugin } from '@umbraco-cms/vite-plugin';

export default defineConfig({
    plugins: [
        umbracoPlugin({
            externalPackages: ['@umbraco-cms/backoffice'],
        }),
    ],
});

The plugin could auto-configure externals, generate TypeScript paths, and validate imports.

Why this doesn't solve it:

⚠️ Still need import maps: Browsers still need runtime resolution somehow
⚠️ Another tool to maintain: We'd have to build, document, and support it
⚠️ Adoption barrier: Extension authors must learn our custom tooling
✅ Could reduce duplication: Might generate configs from a single source

Verdict: This could be a nice developer experience improvement, but it doesn't eliminate the fundamental need for import maps at runtime.

The Real Problem: Ecosystem Gap, Not the Pattern

Here's the critical insight: The problem isn't import maps - it's that the tooling ecosystem hasn't standardized on them yet.

Import maps are:

✅ Browser-native: WHATWG standard, shipped in all modern browsers
✅ Semantically correct: Designed exactly for this use case
✅ The future: The direction web standards are moving

But JavaScript tooling is:

❌ Behind the curve: TypeScript, Vite, NPM don't understand import maps
❌ Fragmented: Each tool has its own config format for the same concept
❌ Slow to adapt: Browser standards move faster than tooling

We're not working around a limitation of import maps - we're working around tooling that hasn't caught up to the browser standard.

What Our Constraints Actually Are

When building a package for third-party extension authors, we must support:

Type definitions at development time - Extension authors need IntelliSense
No runtime bundling - Can't have code duplication and version conflicts
Shared runtime state - Global contexts must be singletons
Standard tools - Must work with TypeScript, Vite, standard browsers
Clean API - Professional package names, not raw file paths

Import maps are the only solution that satisfies all five constraints.

What Would Actually Improve Things?

Umbraco can control:

✅ Build code generation scripts (we did this)
✅ Document the pattern for extension authors
✅ Provide templates and examples
⚠️ Build Vite plugins to improve DX (nice-to-have, doesn't eliminate import maps)

The ecosystem needs:

❌ Native import map support in TypeScript
❌ Native import map support in Vite/Rollup
❌ Standardized tooling that treats import maps as first-class
❌ Better coordination between browser standards and build tool vendors

Until the tooling catches up, patterns like Umbraco's code generation are the pragmatic solution.

Conclusion

The import map pattern is more than just a clever trick - it's a fundamental architectural pattern that solves the dual-resolution problem (development vs runtime) elegantly through a three-layer implementation. By using logical module identifiers with different resolution strategies for TypeScript, Vite, and browsers, Umbraco creates a professional, maintainable, and extensible package system.

The real innovation is treating package.json as a single source of truth and generating all configs from it. This eliminates an entire class of bugs, improves developer velocity, and makes it architecturally impossible for configs to drift out of sync.

For 120+ packages, code generation isn't just an optimization - it's a requirement. Manual maintenance at this scale is untenable.

The three-layer system (TypeScript paths → Vite externals → import maps) might seem complex at first, but once you understand how each layer works, you'll appreciate the elegance of the solution. It's a pattern that makes modern web development with extensible packages possible.

Appendix A: Building Extensions with This Pattern

Note: The following sections provide guidance for developers who want to build Umbraco extensions using this pattern.

You can use the same pattern for your own Umbraco packages. Here's how you might implement it for a Search package:

1. Choose Your Namespace

Use @organization/your-package to stay within a self-defined scope, if you eventually publish this to an NPM feed.

@organization/search/core
@organization/search/global

2. Configure TypeScript (`tsconfig.json`)

Map logical imports to your source files:

{
    "compilerOptions": {
        "baseUrl": ".",
        "paths": {
            "@organization/search/global": ["./src/global/index.ts"],
            "@organization/search/core": ["./src/core/index.ts"]
        }
    }
}

3. Configure Vite (`vite.config.ts`)

Mark your package as external so it's not self-bundled:

export default defineConfig({
    build: {
        lib: {
            entry: {
                'search-global': 'src/global/search-global.ts',
                'search-core': 'src/core/search-core.ts',
            },
            formats: ['es'],
        },
        rollupOptions: {
            external: [/^@umbraco-cms/, /^@organization/],
        },
    },
});

4. Add Importmap (`umbraco-package.json`)

Tell browsers where to find your built files:

{
    "id": "Your.Package.Id",
    "name": "@organization/search",
    "extensions": [
        {
            "type": "bundle",
            "alias": "Your.Package.Bundle",
            "js": "/App_Plugins/YourPackage/bundle.js"
        }
    ],
    "importmap": {
        "imports": {
            "@organization/search/global": "/App_Plugins/YourPackage/search-global.js",
            "@organization/search/core": "/App_Plugins/YourPackage/search-core.js"
        }
    }
}

Note how we use the same namespace scope in the importmap as in TypeScript and package.json. This way everything aligns.

5. Use Logical Imports in Manifests

Now use logical imports instead of raw paths:

// ✅ New approach: logical imports
export const manifests: Array<UmbExtensionManifest> = [
    {
        type: 'repository',
        alias: 'My.Repository',
        api: () => import('@organization/search/core').then((m) => ({ default: m.MyRepository })),
    },
];

// ✅ New approach: import values
import { UMB_SEARCH_CONTEXT_TOKEN } from '@organization/search/global';
console.log(UMB_SEARCH_CONTEXT_TOKEN); // logs: context token instance

6. Export Your Types (`package.json`)

If you want others to extend your package, publish TypeScript definitions:

{
    "name": "@organization/search",
    "version": "1.0.0",
    "type": "module",
    "exports": {
        "./core": {
            "types": "./dist/core/index.d.ts",
            "default": "./dist/core/index.js"
        },
        "./global": {
            "types": "./dist/global/index.d.ts",
            "default": "./dist/global/index.js"
        }
    }
}

When to Add Code Generation

For a small package with 2-3 subpaths, manual config maintenance is fine. But consider building a generation script (like Umbraco's) when:

✅ You have 4+ subpaths
✅ You're frequently adding new exports
✅ You're building a package ecosystem
✅ You want others to extend your work
✅ Config drift has caused bugs

The script doesn't need to be complex - just read package.json exports and generate the various config formats. You can use Umbraco's scripts as a reference: devops/importmap/index.js

Appendix B: Advanced Usage - Multiple Subpaths

You can split your package into multiple logical subpaths:

import { GlobalContext } from '@organization/search/global';
import { Repository } from '@organization/search/core';
import { Helpers } from '@organization/search/utils';

Each subpath can have different loading characteristics:

global: Loaded upfront for event listeners
core: Lazy-loaded on demand
utils: Shared utilities

Just add each to your importmap:

{
    "importmap": {
        "imports": {
            "@organization/search/global": "/App_Plugins/Search/global.js",
            "@organization/search/core": "/App_Plugins/Search/core.js",
            "@organization/search/utils": "/App_Plugins/Search/utils.js"
        }
    }
}

Benefits of Multiple Subpaths

Code splitting: Users only load what they use
Lazy loading: Core functionality loads on-demand
Clear organization: API surface is explicit
Independent updates: Update one subpath without affecting others

Appendix C: Common Pitfalls

1. Forgetting to Mark as External

If you don't mark your package as external in Vite config, it will bundle itself, breaking the lazy-load pattern:

// ❌ Wrong: Will self-bundle
rollupOptions: {
    external: [/^@umbraco-cms/]; // Missing your own package!
}

// ✅ Correct: Mark your own package as external
rollupOptions: {
    external: [
        /^@umbraco-cms/,
        /^@organization/, // Add this!
    ];
}

2. Mismatched Paths

The tsconfig path must point to the exports file (usually index.ts), not the entry file:

// ❌ Wrong: Points to entry file
"@organization/search/core": ["./src/core/search-core.ts"]

// ✅ Correct: Points to exports file
"@organization/search/core": ["./src/core/index.ts"]

3. Missing Importmap Entry

If you add a new subpath, don't forget to add it to the importmap:

{
    "importmap": {
        "imports": {
            "@organization/search/global": "/App_Plugins/Search/global.js",
            "@organization/search/core": "/App_Plugins/Search/core.js"
            // Don't forget to add new subpaths here!
        }
    }
}

4. Config Drift

Manually maintaining multiple configs leads to drift. If you have more than a few subpaths, consider implementing code generation like Umbraco does.

Further Reading:

Umbraco Spark Opportunity Programme applications close Wednesday 28 January

Mon, 26 Jan 2026 15:55:44 Z

⏰ Closes Wednesday 28 January 2026Our Opportunity Programme (with @MikeMasey at Huskey) offers free #Umbraco Spark tickets for people who might not otherwise attend tech conferences.🚨 Only 2 tickets left✔ No sponsored labels Apply or nominate:https://docs.google.com/forms/d/e/1FAIpQLSfeqxcsCukFFrW7KI5MZJROKB1KUNy1q5j_E1nPCmVG_x7Bxg/viewform

Grab your Umbraco Spark ticket before prices increase

Mon, 26 Jan 2026 15:08:15 Z

⏳ 6 days left to grab Umbraco Spark tickets at £125 + VATA strong speaker line-up, practical sessions, and a brilliant Umbraco crowd.Prices increase at the end of January.🎟️ https://www.tickettailor.com/events/umbukfdn/1896581👀 https://umbracospark.com/#what#UmbracoSpark #Umbraco #BristolTech #WebDev #DotNet

DevRel Deep Dive: Sitemap & Robots.txt Packages from Blend Interactive

Mon, 26 Jan 2026 13:49:49 Z

This week Sebastiaan and Lotte look at two packages from Blend Interactive for adding and configuring your site’s (or sites’) sitemap.xml and robots.txt. During the demo Sebastiaan sets up Claude Code to use the Umbraco MCP Server, and uses that to save some time, or perhaps mouse clicks! 📦 Blend Interactive Umbraco Sitemap on the Umbraco Marketplace: https://marketplace.umbraco.com/package/blendinteractive.umbraco.sitemap 📦 Blend Interactive Umbraco RobotsTxt on the Umbraco Marketplace: https://marketplace.umbraco.com/package/blendinteractive.umbraco.robotstxt -------- ❓ Looking for help with your Umbraco projects? Visit the Forum https://forum.umbraco.com 💬 Want to chat with the friendly Umbraco Community? Join our Discord server https://discord.umbraco.com ✉️ Got a question (or topic suggestion) for the HQ Developer Relations team? https://umbra.co/contact-devrel, or the ‘contact-devrel’ channel on Discord #Umbraco

Enhanced Event Logs and Deployment Monitoring for Kudu in Umbraco Cloud

Mon, 26 Jan 2026 09:11:18 Z

When working with Umbraco Cloud, I occasionally need to access Kudu for debugging and deployment tasks. You can access Kudu by clicking the "Kudu" button in your site's dashboard, or directly via the URL: https://<site-name>.scm.<cloud-region>.umbraco.io (where the cloud region might be euwest01, for example).

When a site fails to start or a deployment fails without clear errors, the event log in Kudu can provide crucial insights. However, the raw experience leaves much to be desired.

To solve this problem, I created two userscripts that enhance the Kudu interface.

What is a userscript?

A userscript is a program, usually written in JavaScript, for modifying web pages to augment browsing. Uses include adding shortcut buttons and keyboard shortcuts, controlling playback speeds, adding features to sites, and enhancing the browsing history.

To use a userscript, you need a userscript manager. There are several available, but the most popular is Tampermonkey. Tampermonkey is available for Chrome, Firefox, and Edge.

Visualizing Event Logs

First thing to look at is the event log of the site. The event log contains information from IIS, and tells you any problems when starting the site. It can also contain information about failed deployments, and other issues.

But, it's not the most user-friendly experience. It's a raw XML file, and you have to manually parse it.

The event log is located at /LogFiles/eventlog.xml
It can be a massive XML file with thousands of entries
The most recent (and relevant) information is at the bottom
There's no syntax highlighting or formatting
You have to manually parse XML in your head

This userscript adds a new "Event Log" tab to the Kudu interface, providing a much better experience:

Parsed and formatted: Events are displayed in a clean table format
Most recent first: The latest events appear at the top (no more scrolling)
Color-coded: Each event type has its own color for quick identification
Structured columns: Event time, type, message, and source are clearly separated

The event log helps you diagnose issues like missing DLLs, IIS startup failures, configuration problems, and data-related errors.

How to use it

Install the Kudu Event Log Viewer userscript from my umbraco-userscripts repository
Navigate to your Umbraco Cloud Kudu interface (e.g., *.scm.euwest01.umbraco.io)
Click the "Event Log" link in the navbar
Click "Load Event Log" to fetch and display events
Events are displayed in Bootstrap panels with full details

Tracking Deployments

When using CI/CD with Umbraco Cloud, deployment visibility is limited compared to traditional git push deployments. You lose the immediate feedback from git logs about build status and deployment progress.

Normally, when a deployment fails, you need to manually navigate through files in /site/deployments to find:

Which deployment is currently active
Individual deployment folders with logs and status files
Scattered information across multiple locations

The Deployment Viewer userscript consolidates all this information into a single dashboard:

Deployment status: See the current state of all deployments
Live logs: View logs for each deployment
Auto-refresh: Enable live updates to monitor deployments in real-time
Manual triggers: Start a new deployment without making a git change

How to use it

Install the Umbraco Cloud Deployment Viewer userscript from my umbraco-userscripts repository
Navigate to your Umbraco Cloud Kudu interface (e.g., *.scm.euwest01.umbraco.io)
Click the "Deployments" link in the navbar
View the latest deployment status and log
Click "Auto-refresh" to enable live log and status updates
Click "Trigger New Deployment" to start a new deployment
Click on any deployment in the history table to view full details in a modal
Click file counts to view the deployment manifest

Final Thoughts

While Umbraco Cloud's dashboard provides excellent visibility for most scenarios, these userscripts fill important gaps when you need to dig deeper. They transform Kudu from a basic file browser into a powerful debugging and deployment monitoring tool.

Both userscripts are available on GitHub. Give them a try the next time you're troubleshooting a deployment issue or investigating a site failure.

Umbraco Contentment 6.1.0 is out now

Sat, 24 Jan 2026 15:03:32 Z

#umbraco #Contentment 6.1.0https://github.com/leekelleher/umbraco-contentment/releases/tag/6.1.0TL;DR, bug fixes and new Liquid.js-powered "Block Editor Custom View" feature.

uNavbar

Sat, 24 Jan 2026 00:00:00 Z

A commercial-grade, dynamic navigation solution for Umbraco 17+. easily manage menus, branding, and responsive layouts from the backoffice.

Fix Draft Block Grid/List Items After Upgrading from Umbraco 13 to 17 (Vary by Culture Element Types)

Fri, 23 Jan 2026 15:15:00 Z

Upgrading from Umbraco 13 to 17 and suddenly seeing Draft blocks or empty content in other languages? This post shows the cause, the SQL fix to apply before upgrading, and how to validate everything after the migration....

Umbraco achieves ISO 27001 certification

Fri, 23 Jan 2026 11:35:11 Z

🎉 Confetti alert!Even though we’ve been playing with the big boys for years… we’ve now got the ISO 27001 certification to prove it! ✅This means our product teams follow audited, structured, and continuously improved security practices, giving partners and customers even more reason to trust Umbraco in enterprise and regulated environments.A massive shout-out to the teams who made this happen 👏Read more on https://umbra.co/4r3RDTT#Umbraco

Top 10 Umbraco Security Vulnerabilities that You Must know in 2026

Fri, 23 Jan 2026 08:10:11 Z

Top 10 Umbraco Security Vulnerabilities that You Must know in 2026

Umbraco's product organisation achieves ISO 27001 certification

Fri, 23 Jan 2026 00:00:00 Z

The Umbraco product organisation achieves ISO 27001 certification to strengthen security and enterprise readiness.

Rock Solid Knowledge continuing their support as a sponsor of UmbracoSpark 2026

Thu, 22 Jan 2026 12:09:08 Z

Great to have Rock Solid Knowledge continuing their support as a sponsor of #UmbracoSpark 2026 🙌It's always a pleasure to work with teams that consistently invest in the Umbraco community.👀 We still have ONE sponsor spot available🎟️ 2 free tickets + extra tickets at £75pp and more!More info:🔗 https://umbracospark.com🔗 https://www.rocksolidknowledge.com/#UmbracoSpark #Umbraco #BristolTech #TechEvents #WebDev #DotNet

Upgrading from Umbraco 13 to 17 LTS: Lessons from the Trenches

Thu, 22 Jan 2026 10:20:17 Z

Upgrades, upgrades, upgrades! Upgrades are a hot topic in the Umbraco community ever since version 17 was released last November. There are a lot of great reasons to upgrade to this major version besides simply moving to the latest Long-Term Supported (LTS) version. Our team here at ProWorks has a ton of Umbraco upgrade experience and are here to help you make your upgrade a success. This article will update as we learn about new challenges and find solutions. Ready? Let's do this!

See the changelog at the bottom if you're coming back to this after a while - Updated: January 22, 2026

Why Upgrade?

Let's look at why you would upgrade to the latest v17 version:

Most recent LTS version - stay up to date with security patches and easiest to keep up to date in the future. Umbraco 17 is supported through November 27, 2028.
Performance improvements - The rebuilt HybridCache speeds up startups especially on large sites. The latest .NET version 10 framework also improves performance.
Modern back-office SPA - Rebuilt back-office allows for standards-based extensions and future-proofed architecture that no longer relies on Angular or other external large frameworks.
Deep AI Chat Integrations with Umbraco MCP - The official Umbraco MCP Server only works on version 17 and allows AI to "talk" to your specific Umbraco back-office to report on, add, or modify content.
Full Management API - This allows for automation of everything that can be done by a content editor or developer in the back-office.
Load-balancing the Back-office - This allows the back-office to scale out like the front-end and simplifies hosting load-balanced Umbraco websites.
Read even more on the official v17 release article: Umbraco 17 LTS: Final Release

There is really a lot of truly great features available in version 17 and many more on the horizon in 18 and 19. It's a perfect time to get this upgrade done so those other upgrades are less painful later.

Prepare for Your Upgrade

A good result always starts with a good plan, right?

Current Umbraco Version?

First, you should assess where your site currently is. Are you on version 13? Or something older?

Version 8-9: You will need to upgrade to v10, then v13, then v17 - in fact, in general it is recommended to upgrade to each LTS version on your path to the latest. There may need to be custom migrations if the site uses Grid or other unsupported editors. Content migration may be preferable is some cases. v8 has API changes that could mean major code refactoring.
Version 10-12: Upgrade to the latest v13, then to v17. Getting to v13 should be relatively straight-forward, but an assessment is always helpful for planning.
Version 13: Upgrade to the latest version of v13, currently 13.13.0.

Learn more about each version here: https://releases.umbraco.com/all-releases

(Please feel free to contact ProWorks and get our recommendations)

Using Outdated Property Editors?

If you are using any deprecated or legacy property editors, its best to update them to use the latest version in v13 before upgrading.

Property editors to migrate to in v13:

MediaPicker -> MediaPicker3
Nested Content -> Block List
Stacked Content -> Block List
Grid -> Block Grid
Macros -> Blocks (Or remove if unused)
XPath in pickers -> Plan for a change to use the new dynamic root setup

By addressing these structural elements first, the content will migrate much easier to v17.

v17 Package Support?

Do you have Umbraco Packages installed (it's likely)? Go to the Umbraco Marketplace (https://marketplace.umbraco.com/) or the package Repository and verify that each package supports v17. Many of the most used packages are ready for v17 now. Some are working on it and may have a beta version that likely works well. Some may not have any v17 support.

If you're unsure and its not clear from the repo, then asking on the Umbraco Forums (https://forum.umbraco.com/) would be a good way to see how others are dealing with this package. Is there a new version coming soon? Is there a new package that effectively replaces this one?

As always, we can help give you a recommendation to move forward on. We have been doing this a long time and would love to help! Connect with us below

Custom/Bespoke Back-Office Extensions?

If your site has custom Angular.js extensions, then those will need to be re-written in the new Typescript/Lit/Web Components extension model. For the initial upgrade you can simply disable or remove them and address them after the main upgrade is complete.

Using Smidge?

Smidge was removed in v17 and you will need to reinstall it if used by any custom code or by the site in general. It is straight-forward to re-add to your site and you can learn more on the Github repo: https://github.com/Shazwazza/Smidge.

There is also an Umbraco-specific package that you can install here: https://marketplace.umbraco.com/package/umbraco.community.smidge

TipTap or TinyMCE?

Umbraco has migrated to a new RTE component called TipTap. It will migrate all of your RTEs to this new editor by default unless you install a community package, TinyMCE.Umbraco. This package will prevent the migration and keep the TinyMCE editor installed and used as in previous versions. Read more about TinyMCE.Umbraco v17 in this post.

You will need to decide if you want to keep using TinyMCE or move to TipTap. If you have TinyMCE customizations or complex RTE setups, you may want to keep TinyMCE. The package also gives you the option of easily adding premium features like AI tools. TipTap is based on ProseMirror and is more lightweight so may be preferred in some use cases.

Use Umbraco Forms?

If you use Umbraco Forms, then you may need to migrate to the new licensing structure. It is now licensed annually instead of a one-time cost. Umbraco Forms is included with Umbraco Cloud so this is less of a concern if you are hosted on Umbraco Cloud. Your choice is to license Umbraco Forms going forward or remove it in favor of a different solution.

Review Official Documentation:

Take a look at the Version Specific Upgrades documentation guide in the Official Umbraco Documentation: Version Specific Upgrades

There may be other key breaking changes highlighted there that will be important for your site.

Also, the Upgrade Details document has information on some edge cases and older versions as well: Upgrade Details

Pre-Upgrade Process

I'll assume you have solutions for all the above issues and are ready to try out an upgrade! Great! Now, take a step to make sure you have all of this in place:

Backup Your Database / Media

Always backup your database before starting. You will miss something and may need to iterate a few times to get the migrations just right.

Also, now is a good time to get a backup of the latest media and pull it locally.

Side-by-Side Setup

Ideally, you have a v13 site for reference running locally and your future v17 site ready to upgrade. These should be using separate databases and be able to run completely side-by-side. This lets you quickly iterate with v13 changes and re-run the v17 upgrade as needed. In addition, this allows you to quickly verify that the site looks and works as expected.

If you're using Git, make sure you have each version on separate feature branches.

Verify Dev Setup

Get your development setup ready for .NET 10 and Umbraco v17:

Install .NET 10 SDK
Update Visual Studio (2022 v17.12+ or 2026)

Verify Latest v13

One last check to make sure you're on the latest Umbraco v13 release. If not, do this first.

Upgrade Time!

Let's do this.

1. Update Project Target Frameworks

This can be done directly in the .csproj files through the TargetFramework element:

    <!-- Change target framework -->
    <TargetFramework>net10.0</TargetFramework>

2. Update Nuget Packages

Update all Umbraco packages to version 17.latest:

Umbraco.Cms
Umbraco.Cms.Web.Website

If using Umbraco Cloud update these as well:

Umbraco.Cloud.Cms
Umbraco.Cloud.StorageProviders.AzureBlob
Umbraco.Deploy.Cloud
Umbraco.Deploy.Contrib

Remove these packages as they aren't needed for v17:

Umbraco.Cloud.Cms.PublicAccess
Umbraco.Cloud.Identity.Cms
Umbraco.Cms.Web.BackOffice

Update all other packages used including Umbraco Extensions like:

Umbraco.Community.Contentment
Umbraco.Forms
Any other packages used that support v17

3. Delete Build Artifacts

Delete all of the bin and obj directories in each of the projects of your solution. Umbraco has reported that Visual Studio's "Clean Solution" option is sometimes not enough.

4. Code Changes

There are a few code changes needed to get the Solution compiling.

Program.cs:

Remove UseInstallerEndpoints() as this is now automatically setup in v17
Consider comparing a fresh installed Umbraco v17 Program.cs with your current code and verify that you have the latest patterns in place. I have found other areas that were missing and easy to miss.

_ViewImports.cshtml:

Remove Smidge references:

@* REMOVE these lines: *@
@addTagHelper *, Smidge
@inject Smidge.SmidgeHelper SmidgeHelper

Generated Models

If you used strongly typed models and have Umbraco generate them to code files in your project/solution, then the solution likely won't compile.

You have two options:

Delete all generated models from the directory in your project and set the Umbraco.Cms.ModelsBuilder.ModelsMode to "InMemoryAuto" from "SourceCodeAuto" or "SourceCodeManual". This will allow you to run the upgrade then switch it back and regenerate them after the v17 back-office is working. If you do this, you will need to install the Umbraco.Cms.DevelopmentMode.Backoffice to allow the "InMemoryAuto" mode to work in v17.
Tweak the v13 generated models so they compile and regenerate them after the v17 back-office is working. This involves:

Changing IPublishedContent from:

global::Umbraco.Cms.Core.Models.PublishedContent.IPublishedContent Image { get; }

To MediaWithCrops:


global::Umbraco.Cms.Core.Models.MediaWithCrops Image { get; }

Watch for IEnumerable references as well as they need to be changed to use MediaWithCrops as well. Then fix any other build errors that you see.

Ultimately you want to run the back-office so you can regenerate them. So editing them manually is a temporary solution if you're having trouble compiling the solution.

5. Configure Razor Files for .NET v10

Verify Runtime Modes

.NET 10 deprecated runtime Razor compilation. Views are now compiled at build time by default.

Verify your .csproj has the following:

   <PropertyGroup>
      <CopyRazorGenerateFilesToPublishDirectory>true</CopyRazorGenerateFilesToPublishDirectory>
   </PropertyGroup>

I recommend compiling your Razor files to find any issues at build time instead of at runtime. Remove these lines from your .csproj:

      <RazorCompileOnBuild>false</RazorCompileOnBuild>
      <RazorCompileOnPublish>false</RazorCompileOnPublish>

More on Runtime modes from the Umbraco Documentation: https://docs.umbraco.com/umbraco-cms/fundamentals/setup/server-setup/runtime-modes

If you need to restore the runtime Razor view compilation or want to use InMemoryAuto model building, then you will need to install this package:

dotnet add package Umbraco.Cms.DevelopmentMode.Backoffice

Read more in the Version Specific Guide to determine if you need this package: https://docs.umbraco.com/umbraco-cms/fundamentals/setup/upgrading/version-specific#umbraco-17

6. Optional: Disable Custom Packages

If you are planning to migrate custom back-office packages after the initial upgrade is complete, then you could simply disable any custom code and exclude it from the project.

Rename folders in App_Plugins with custom extensions to have ".disabled" at the end of the folder name.
Update the App_Plugins content include entry in the .csproj to exclude any folders with ".disabled" at the end:

      <Content Include="App_Plugins\**" Exclude="App_Plugins\*.disabled\**">

If you have extensions added via Razor Class Library, you may need to remove the reference or delete the .dll from the bin folder.

7. Optional: Explicitly Set LocalTimeZone

The change to use UTC by default for System Dates may have implications for your site. Read more in the Version Specific Guide on whether you want to explicitly set a server time zone in appsettings.json.

https://docs.umbraco.com/umbraco-cms/fundamentals/setup/upgrading/version-specific#umbraco-17

{
   "Umbraco": {
      "CMS": {
         "SystemDateMigration": {
            "LocalServerTimeZone": "Eastern Standard Time"
         }
      }
   }
}

8. Licensing Changes

If you are using Umbraco Deploy or Umbraco Forms, then you will need to migrate the licensing from the file-based .lic to the configuration settings in appsettings.json

Remove .lic Files

Remove the .lic files inside of the umbraco/Licenses folder for Umbraco Deploy and Umbraco Forms.

Add Licensing Configuration

For Umbraco Cloud sites, you can add these settings to your appsettings.json file. If you have a different hosting setup, you will need to replace "UMBRACO-CLOUD" with your license key.

{
  "Umbraco": {
    "Licenses": {
      "Products": {
        "Umbraco.Forms": "UMBRACO-CLOUD",
        "Umbraco.Deploy": "UMBRACO-CLOUD"
      }
    }
  }
}

Build, Run, and Test!

Is the site rendering as expected? Does the back-office load and you are able to login? If yes, you're on your way to v17.

Now its time to perform your detailed regression testing by verifying all the packages migrated as expected, all property editors are working as expected, and you can make changes as you would expect.

Here are some items you may want to focus on to verify the upgrade:

The site builds without errors
All pages render correctly
Backoffice login works
Content editing works
No console errors/warnings
Block List editors function
Rich text editors function
Media uploads work
Search returns results
Licenses show as valid
Forms submit and save entries

Migrating Custom Extensions to v17

Once the back-office and site appear to be working, it's time to migrate those custom extensions to v17. That process is out of scope for this article, but here are some resources to get you started:

Building Property Editors in v17
Umbraco UI Library
Migrating Extensions from v13 to v17 by Kenn Jacobsen
From AngularJS to Web Components by Jesper Mayntzhusen

Final Thoughts

Upgrading to v17 is worth the effort as it is the Umbraco version to take the community into the future. AI, modern web frameworks, enterprise features, and so much more make this an upgrade to prioritize. With v13 support ending December 14th, 2026 the time to start planning an upgrade is now.

Need help with your Umbraco upgrade?

Reach out to us for an initial consultation so we can help make your upgrade a success!

Schedule a Consultation

Change Log

2026-01-22: Initial Version

Upgrading from Umbraco 13 to 17 LTS: Lessons from the Trenches

Thu, 22 Jan 2026 10:20:17 Z

See the changelog at the bottom if you're coming back to this after a while - Updated: January 22, 2026

Why Upgrade?

Let's look at why you would upgrade to the latest v17 version:

Timely Security Updates - As a LTS version, your site can stay up to date with security patches and easiest to keep up to date in the future. Umbraco 17 is supported through November 27, 2028.
Better Site Performance - The rebuilt HybridCache speeds up startups especially on large sites. This means less down time after deploys to live. The latest .NET version 10 framework also improves performance which helps with your page speeds.
Better Back-Office Performance - The rebuilt back-office is faster and allows for standards-based extensions and future-proofed architecture that no longer relies on Angular or other external large frameworks that could no longer be supported.
Deep AI Chat Integrations - The official Umbraco MCP Server only works on version 17 and allows AI to "talk" to your specific Umbraco back-office to report on, add, or modify content.
Better Automation and Integration Support - The new Management API allows for automation of everything that can be done by a content editor or developer in the back-office. This is important for deep integrations with external tools, marketing automations, and AI Agent connections.
Scalable Back-office - Version 17 supports load-balancing the back-office. This allows the back-office to scale out like the front-end for performance and simplifies hosting load-balanced Umbraco websites.
Read even more on the official v17 release article: Umbraco 17 LTS: Final Release

The sections below dive into the technical details of upgrading. If you'd rather have a conversation about what an upgrade means for your organization (timeline, budget, and business impact) we're happy to help.

Schedule a Consultation

Prepare for Your Upgrade

A good result always starts with a good plan, right?

Current Umbraco Version?

First, you should assess where your site currently is. Are you on version 13? Or something older?

Version 8-9: You will need to upgrade to v10, then v13, then v17 - in fact, in general it is recommended to upgrade to each LTS version on your path to the latest. There may need to be custom migrations if the site uses Grid or other unsupported editors. Content migration may be preferable is some cases. v8 has API changes that could mean major code refactoring.
Version 10-12: Upgrade to the latest v13, then to v17. Getting to v13 should be relatively straight-forward, but an assessment is always helpful for planning.
Version 13: Upgrade to the latest version of v13, currently 13.13.0.

Learn more about each version here: https://releases.umbraco.com/all-releases

(Please feel free to contact ProWorks and get our recommendations)

Using Outdated Property Editors?

If you are using any deprecated or legacy property editors, its best to update them to use the latest version in v13 before upgrading.

Property editors to migrate to in v13:

MediaPicker -> MediaPicker3
Nested Content -> Block List
Stacked Content -> Block List
Grid -> Block Grid
Macros -> Blocks (Or remove if unused)
XPath in pickers -> Plan for a change to use the new dynamic root setup

By addressing these structural elements first, the content will migrate much easier to v17.

v17 Package Support?

As always, we can help give you a recommendation to move forward on. We have been doing this a long time and would love to help! Connect with us below

Custom/Bespoke Back-Office Extensions?

Using Smidge?

There is also an Umbraco-specific package that you can install here: https://marketplace.umbraco.com/package/umbraco.community.smidge

TipTap or TinyMCE?

Use Umbraco Forms?

Review Official Documentation:

Take a look at the Version Specific Upgrades documentation guide in the Official Umbraco Documentation: Version Specific Upgrades

There may be other key breaking changes highlighted there that will be important for your site.

Also, the Upgrade Details document has information on some edge cases and older versions as well: Upgrade Details

Pre-Upgrade Process

I'll assume you have solutions for all the above issues and are ready to try out an upgrade! Great! Now, take a step to make sure you have all of this in place:

Backup Your Database / Media

Always backup your database before starting. You will miss something and may need to iterate a few times to get the migrations just right.

Also, now is a good time to get a backup of the latest media and pull it locally.

Side-by-Side Setup

If you're using Git, make sure you have each version on separate feature branches.

Verify Dev Setup

Get your development setup ready for .NET 10 and Umbraco v17:

Install .NET 10 SDK
Update Visual Studio (2022 v17.12+ or 2026)

Verify Latest v13

One last check to make sure you're on the latest Umbraco v13 release. If not, do this first.

Upgrade Time!

Let's do this.

1. Update Project Target Frameworks

This can be done directly in the .csproj files through the TargetFramework element:

    <!-- Change target framework -->
    <TargetFramework>net10.0</TargetFramework>

2. Update Nuget Packages

Update all Umbraco packages to version 17.latest:

Umbraco.Cms
Umbraco.Cms.Web.Website

If using Umbraco Cloud update these as well:

Umbraco.Cloud.Cms
Umbraco.Cloud.StorageProviders.AzureBlob
Umbraco.Deploy.Cloud
Umbraco.Deploy.Contrib

Remove these packages as they aren't needed for v17:

Umbraco.Cloud.Cms.PublicAccess
Umbraco.Cloud.Identity.Cms
Umbraco.Cms.Web.BackOffice

Update all other packages used including Umbraco Extensions like:

Umbraco.Community.Contentment
Umbraco.Forms
Any other packages used that support v17

3. Delete Build Artifacts

Delete all of the bin and obj directories in each of the projects of your solution. Umbraco has reported that Visual Studio's "Clean Solution" option is sometimes not enough.

4. Code Changes

There are a few code changes needed to get the Solution compiling.

Program.cs:

Remove UseInstallerEndpoints() as this is now automatically setup in v17
Consider comparing a fresh installed Umbraco v17 Program.cs with your current code and verify that you have the latest patterns in place. I have found other areas that were missing and easy to miss.

_ViewImports.cshtml:

Remove Smidge references:

@* REMOVE these lines: *@
@addTagHelper *, Smidge
@inject Smidge.SmidgeHelper SmidgeHelper

Generated Models

If you used strongly typed models and have Umbraco generate them to code files in your project/solution, then the solution likely won't compile.

You have two options:

Delete all generated models from the directory in your project and set the Umbraco.Cms.ModelsBuilder.ModelsMode to "InMemoryAuto" from "SourceCodeAuto" or "SourceCodeManual". This will allow you to run the upgrade then switch it back and regenerate them after the v17 back-office is working. If you do this, you will need to install the Umbraco.Cms.DevelopmentMode.Backoffice to allow the "InMemoryAuto" mode to work in v17.
Tweak the v13 generated models so they compile and regenerate them after the v17 back-office is working. This involves:

Changing IPublishedContent from:

global::Umbraco.Cms.Core.Models.PublishedContent.IPublishedContent Image { get; }

To MediaWithCrops:


global::Umbraco.Cms.Core.Models.MediaWithCrops Image { get; }

Watch for IEnumerable references as well as they need to be changed to use MediaWithCrops as well. Then fix any other build errors that you see.

Ultimately you want to run the back-office so you can regenerate them. So editing them manually is a temporary solution if you're having trouble compiling the solution.

5. Configure Razor Files for .NET v10

Verify Runtime Modes

.NET 10 deprecated runtime Razor compilation. Views are now compiled at build time by default.

Verify your .csproj has the following:

   <PropertyGroup>
      <CopyRazorGenerateFilesToPublishDirectory>true</CopyRazorGenerateFilesToPublishDirectory>
   </PropertyGroup>

I recommend compiling your Razor files to find any issues at build time instead of at runtime. Remove these lines from your .csproj:

      <RazorCompileOnBuild>false</RazorCompileOnBuild>
      <RazorCompileOnPublish>false</RazorCompileOnPublish>

More on Runtime modes from the Umbraco Documentation: https://docs.umbraco.com/umbraco-cms/fundamentals/setup/server-setup/runtime-modes

If you need to restore the runtime Razor view compilation or want to use InMemoryAuto model building, then you will need to install this package:

dotnet add package Umbraco.Cms.DevelopmentMode.Backoffice

Read more in the Version Specific Guide to determine if you need this package: https://docs.umbraco.com/umbraco-cms/fundamentals/setup/upgrading/version-specific#umbraco-17

6. Optional: Disable Custom Packages

If you are planning to migrate custom back-office packages after the initial upgrade is complete, then you could simply disable any custom code and exclude it from the project.

Rename folders in App_Plugins with custom extensions to have ".disabled" at the end of the folder name.
Update the App_Plugins content include entry in the .csproj to exclude any folders with ".disabled" at the end:

      <Content Include="App_Plugins\**" Exclude="App_Plugins\*.disabled\**">

If you have extensions added via Razor Class Library, you may need to remove the reference or delete the .dll from the bin folder.

7. Optional: Explicitly Set LocalTimeZone

https://docs.umbraco.com/umbraco-cms/fundamentals/setup/upgrading/version-specific#umbraco-17

{
   "Umbraco": {
      "CMS": {
         "SystemDateMigration": {
            "LocalServerTimeZone": "Eastern Standard Time"
         }
      }
   }
}

8. Licensing Changes

If you are using Umbraco Deploy or Umbraco Forms, then you will need to migrate the licensing from the file-based .lic to the configuration settings in appsettings.json

Remove .lic Files

Remove the .lic files inside of the umbraco/Licenses folder for Umbraco Deploy and Umbraco Forms.

Add Licensing Configuration

For Umbraco Cloud sites, you can add these settings to your appsettings.json file. If you have a different hosting setup, you will need to replace "UMBRACO-CLOUD" with your license key.

{
  "Umbraco": {
    "Licenses": {
      "Products": {
        "Umbraco.Forms": "UMBRACO-CLOUD",
        "Umbraco.Deploy": "UMBRACO-CLOUD"
      }
    }
  }
}

Build, Run, and Test!

Is the site rendering as expected? Does the back-office load and you are able to login? If yes, you're on your way to v17.

Here are some items you may want to focus on to verify the upgrade:

The site builds without errors
All pages render correctly
Backoffice login works
Content editing works
No console errors/warnings
Block List editors function
Rich text editors function
Media uploads work
Search returns results
Licenses show as valid
Forms submit and save entries

Migrating Custom Extensions to v17

Once the back-office and site appear to be working, it's time to migrate those custom extensions to v17. That process is out of scope for this article, but here are some resources to get you started:

Building Property Editors in v17
Umbraco UI Library
Migrating Extensions from v13 to v17 by Kenn Jacobsen
From AngularJS to Web Components by Jesper Mayntzhusen

Final Thoughts

Need help with your Umbraco upgrade?

Reach out to us for an initial consultation so we can help make your upgrade a success!

Schedule a Consultation

Change Log

2026-01-22: Initial Version

The Pre Spark Umbraco Hackathon and Package Jam is back!

Wed, 21 Jan 2026 12:11:39 Z

🎉 The Pre Spark Umbraco Hackathon and Package Jam is back! 🎉Sign-ups are now open 👉 https://www.meetup.com/umbristol/events/312954840If you’re heading to #UmbracoSpark (tickets: https://www.tickettailor.com/events/umbukfdn/1896581) and taking part in the Package Jam, this is a great chance to collaborate in person as a team beforehand.#Umbraco #truedigital #umbristol #Bristol #TechCommunity

UmbHost GreenStack is now live!

Mon, 19 Jan 2026 09:43:34 Z

🚀 GreenStack is LIVE!After months of development, our load-balanced Umbraco hosting platform is here.✅ Multi-replica infrastructure✅ 99.9% uptime guarantee✅ Zero-downtime deployments✅ Powered by 100% renewable energyFrom £20/mo https://umbhost.net/gb/blog/2026/01/greenstack-is-live-load-balanced-umbraco-hosting-is-here #GreenStack #Umbraco #WebHosting #SustainableHosting #CloudHosting #UmbHost

Make Umbraco’s Welcome Dashboard Your Own

Mon, 19 Jan 2026 07:26:41 Z

Umbraco comes with a default Welcome dashboard in the backoffice. It displays news from Umbraco HQ along with handy links to documentation, training, and other community resources.

That’s great for developers, but when you’re building Umbraco sites for clients, those links are often not the most relevant. In fact, the traditional recommendation has often been to simply remove the Welcome dashboard entirely.

But with the current backoffice (which I should probably stop calling new by now), there are plenty of extension points - and the Welcome dashboard is one of them.

So instead of removing it, why not use it for your own content?

Extending the Welcome dashboard

The Welcome dashboard is powered by a service in the backend, and you can replace or extend its behaviour by implementing the INewsDashboardService interface in your own C# code.

Once you do that, Umbraco will use your implementation to populate the dashboard.

All you need to return is a NewsDashboardResponseModel, which contains a collection of items to display. Each item supports:

A header
Body text
An image (URL + alt text)
A link URL
Button text
A priority (High, Medium, or Low)

The dashboard will automatically sort the items by priority before rendering them.

A (slightly useless) example implementation

As a simple demonstration, here’s an intentionally useless implementation that displays the weather from 12 random locations on Earth every time the dashboard loads.

using System.Text.Json;
using Umbraco.Cms.Api.Management.Services.NewsDashboard;
using Umbraco.Cms.Api.Management.ViewModels.NewsDashboard;

public class UselessNewsDashboardService : INewsDashboardService
{
    private readonly HttpClient _httpClient;
    private readonly AppCaches _appCaches;

    public GiNewsDashboardService(HttpClient httpClient, AppCaches appCaches)
    {
        _httpClient = httpClient;
        _appCaches = appCaches;
    }

    public async Task<NewsDashboardResponseModel> GetItemsAsync()
    {
        // fetch some data - this depends on your usecase!
        var locations =
            await _appCaches.RuntimeCache.GetCacheItemAsync(
                "randomWeather",
                async () => await GetWeatherFromRandomLocationsAsync(),
                TimeSpan.FromHours(1)
            ) ?? [];

        // build the response model
        var response = new NewsDashboardResponseModel()
        {
            Items = locations.Select(x => new NewsDashboardItemResponseModel()
            {
                Header = x.Title,
                Priority = "High", // or Medium or Low
                Url = x.Url,
                ImageUrl = x.ImageUrl,
                Body = x.ShortDescription,
                ButtonText = "Go to website",
            }),
        };

        return response;
    }

    // below are methods for communicating with the weather API 
    // - you don't need these

    public async Task<WeatherResult> GetWeatherAsync(double lat, double lon)
    {
        // this is just to prevent 529 Too many requests
        await Task.Delay(Random.Shared.Next(100, 1000));

        var url =
            $"https://api.open-meteo.com/v1/forecast"
            + $"?latitude={lat}&longitude={lon}"
            + $"&current_weather=true";

        var json = await _httpClient.GetStringAsync(url);
        using var doc = JsonDocument.Parse(json);

        var current = doc.RootElement.GetProperty("current_weather");

        var temperature = current.GetProperty("temperature").GetDouble();
        var weatherCode = current.GetProperty("weathercode").GetInt32();

        var description = GetDescription(weatherCode);
        var imageUrl = GetImageUrl(weatherCode);

        return new WeatherResult(
            Title: $"{description}, {temperature}°C",
            ShortDescription: $"Weather at {lat}/{lon}",
            ImageUrl: imageUrl,
            Url: $"https://www.open-meteo.com/en/forecast?latitude={lat}&longitude={lon}"
        );
    }

    public record WeatherResult(string Title, string ShortDescription, string ImageUrl, string Url);

    public static string GetDescription(int code) =>
        code switch
        {
            0 => "Clear sky",
            1 or 2 or 3 => "Partly cloudy",
            45 or 48 => "Fog",
            51 or 53 or 55 => "Drizzle",
            61 or 63 or 65 => "Rain",
            71 or 73 or 75 => "Snow",
            80 or 81 or 82 => "Rain showers",
            95 => "Thunderstorm",
            _ => "Unknown weather",
        };

    public static string GetImageUrl(int code) =>
        code switch
        {
            0 => "https://cdn-icons-png.flaticon.com/512/869/869869.png",
            1 or 2 or 3 => "https://cdn-icons-png.flaticon.com/512/1163/1163661.png",
            61 or 63 or 65 => "https://cdn-icons-png.flaticon.com/512/3351/3351979.png",
            71 or 73 or 75 => "https://cdn-icons-png.flaticon.com/512/642/642102.png",
            95 => "https://cdn-icons-png.flaticon.com/512/1146/1146869.png",
            _ => "https://cdn-icons-png.flaticon.com/512/1779/1779940.png",
        };
}

You also have to register the service with a Composer, like so:

using Umbraco.Cms.Core.Composing;

public class UselessNewsDashboardComposer : IComposer
{
    public void Compose(IUmbracoBuilder builder)
    {
        builder.Services.AddSingleton<INewsDashboardService, UselessNewsDashboardComposer >();
    }
}

And there you have it:

This example obviously isn’t very useful - but it shows how little code is required to take control of the dashboard content.

A practical use case

Where this does become useful is for agencies and teams building Umbraco sites for clients.

Instead of showing Umbraco HQ news, you can use the Welcome dashboard to:

Share important project updates
Announce new features or releases
Provide onboarding instructions
Link to internal documentation or support channels
Communicate maintenance windows or known issues

In other words, it becomes a direct communication channel inside your client’s CMS.

Final thoughts

Rather than removing the Welcome dashboard altogether, extending it allows you to turn an otherwise generic screen into something genuinely valuable for your clients.

With just a small custom service, you can make the Umbraco backoffice feel more tailored, more informative, and more aligned with the people actually using it.

uProfile January 2026 - Adam Prendergast

Mon, 19 Jan 2026 00:00:00 Z

Meet Helen Chaplin — a passionate sustainability advocate and avid world traveller

Umbraco US Festival looking for community feedback

Sat, 17 Jan 2026 07:38:26 Z

👋 #Umbraco community! We’d love your input as we plan this year’s Umbraco US Festival!What topics would you like to see discussed? Are there people (or you!) who would be great to speak on those subjects?We’re also looking for folks who want to help behind the scenes, reviewing sessions, helping with comms, social posts, website updates, and more. All skill sets welcome!💬 Reply with ideas, tag someone, or reach out at events@umbracousfoundation.org to get involved.

BlendInteractive.Umbraco.Sitemap

Sat, 17 Jan 2026 00:00:00 Z

sitemap.xml dynmically generated using the AppSettings and can be configured per environment.

DJRetailing.Umbraco.Dropdown

Sat, 17 Jan 2026 00:00:00 Z

Sleek dropdown suite for Umbraco. Verified stable for v14-v17. Supports C# Enums and Simple Dropdowns with full localization.

BlendInteractive.Umbraco.RobotsTxt

Sat, 17 Jan 2026 00:00:00 Z

robots.txt dynmically generated using the AppSettings and can be configured per environment.

Umbraco Spark 2026 speaker line-up is live

Thu, 15 Jan 2026 14:17:07 Z

🚀 The Umbraco Spark 2026 speaker line-up is live!From Niels Lyngsø on the backoffice, to Carl Sargunar’s live load balancing, and Georgina & Matt’s AI-driven humor—this year’s Spark has something for every web professional.🎟️ Tickets are limited! £125 + VAT until 31 Jan. Check out the full line-up & get tickets https://umbracospark.com/ #UmbracoSpark #Umbraco #WebDev #TechEvents

DevRel Deep Dive: Table Editing Community Packages

Wed, 14 Jan 2026 15:41:21 Z

This week Sebastiaan and Lotte take a look at two community packages that landed recently on the Umbraco marketplace, both adding the ability to allow editors to manage tabular data for properties: Webwonders Umbraco TableEditor and UmbHost Tables. 📦 Webwonders Umbraco TableEditor on the Umbraco Marketplace: https://marketplace.umbraco.com/package/webwonders.umbraco.tableeditor 📦 UmbHost Tables on the Umbraco Marketplace: https://marketplace.umbraco.com/package/umbhost.tables -------- ❓ Looking for help with your Umbraco projects? Visit the Forum https://forum.umbraco.com 💬 Want to chat with the friendly Umbraco Community? Join our Discord server https://discord.umbraco.com ✉️ Got a question (or topic suggestion) for the HQ Developer Relations team? https://umbra.co/contact-devrel, or the ‘contact-devrel’ channel on Discord #Umbraco

Sponsor the Umbraco Spark Pre-Party in Bristol

Wed, 14 Jan 2026 14:55:16 Z

💡 Want your brand at the heart of the Umbraco community?Sponsor the Umbraco Spark Pre-Party in Bristol @ Roxy Lanes, Bristol 🍻✔️ Sole sponsor✔️ 2 free Spark 2026 tickets✔️ Food, drinks & good vibes for the community #UmbracoSpark #Umbraco #BristolTech #WebDev #DotNet

What Working in Forensic Psychiatry Has Taught Me About the Umbraco Community - DEV Community

Wed, 14 Jan 2026 09:13:40 Z

What Working in Forensic Psychiatry Has Taught Me About the Umbraco Community - DEV Community

Using Umbraco Media Picker Crops with Next.js

Tue, 13 Jan 2026 11:00:28 Z

https://www.nathanielnunes.com/blog/using-umbraco-media-picker-crops-with-nextjs @UMB.FYI#3772 tip

Our.Umbraco.Extensions.Polyfills

Tue, 13 Jan 2026 00:00:00 Z

Polyfills for broader compatibility in Umbraco

Perplex.ContentBlocksToBlockList

Tue, 13 Jan 2026 00:00:00 Z

Migrates Perplex.ContentBlocks data types and property data to Umbraco.BlockList

Our.Umbraco.Extensions.Localization

Tue, 13 Jan 2026 00:00:00 Z

Extensions for improved localization in Umbraco

Our.Umbraco.Extensions.Blocks

Tue, 13 Jan 2026 00:00:00 Z

Extensions for working with Blocks in Umbraco

Merchello, the community ecommerce package for Umbraco is making a come back

Mon, 12 Jan 2026 10:31:32 Z

Merchello

Upgrading from Umbraco 13 to 17: My Practical Approach

Mon, 12 Jan 2026 09:07:29 Z

...

DevRel Deep Dives are back!

Sun, 11 Jan 2026 11:44:18 Z

Yes, DevRel Deep Dives are back after a bit of a longer break.In this episode @lotte and I have special guest @leekelleher in to show us around some new goodies in yesterday's Umbraco 17.1.0 release. https://www.youtube.com/watch?v=9PtP2qIfYM0#Umbraco

Anthem | TryHackMe | Walkthrough

Sat, 10 Jan 2026 17:13:35 Z

Initial Access

Continue reading on Medium »

Umbraco 17.1 highlights with Lee Kelleher

Fri, 09 Jan 2026 10:46:25 Z

Sebastiaan and Lotte look at some highlights of the latest Umbraco release - version 17.1 - with the help of Lee Kelleher from the Umbraco CMS team. Umbraco 17.1 brings a lot of accessibility and UX improvements, bug fixes and other enhancements. Learn about Block Sort Mode, configuring Additional Preview Environments for headless implementations, and more! 👀 Check out the 17.1 release notes: https://releases.umbraco.com/release/umbraco/Umbraco-CMS/17.1.0 📕Additional preview environments support: https://docs.umbraco.com/umbraco-cms/reference/content-delivery-api/additional-preview-environments-support -------- ❓ Looking for help with your Umbraco projects? Visit the Forum https://forum.umbraco.com 💬 Want to chat with the friendly Umbraco Community? Join our Discord server https://discord.umbraco.com ✉️ Got a question (or topic suggestion) for the HQ Developer Relations team? https://umbra.co/contact-devrel, or the ‘contact-devrel’ channel on Discord #Umbraco

Readable, simple Chinese URL segments in Umbraco with NPinyin

Fri, 09 Jan 2026 08:29:17 Z

On a recent project, the client had a Chinese version of their site. The texts and titles were, of course, written using Chinese characters, which meant that the URLs were automatically generated using those characters as well.

For SEO and UX reasons, we wanted the URLs to use Latin characters instead. While search engines are perfectly capable of indexing Chinese URLs, we felt that Latin URLs would perform better in practice.

Our reasoning was:

Latin URLs are more readable (especially since the audience was not exclusively Chinese), which we assumed would lead to higher click-through rates
Hyphenated Latin words provide clearer URL keyword signals
Sharing URLs and linking to them is much easier with Latin characters than with encoded Chinese characters

For example, a title like:

击掌！你太棒了！

would normally generate a URL segment using Chinese characters. With pinyin conversion applied, it instead becomes:

/ji-zhang-ni-tai-bang-le

The latter is much easier to read, share, and reason about, especially in mixed-language environments.

Converting Chinese characters to Latin using pinyin

Umbraco already tries to convert special characters when generating URLs, but the default character replacement set is quite limited. You can see the default configuration in the request handler settings in the documentation article about Request Handler Settings.

Because of the nature of Chinese characters, having more than 50,000 of them, mapping each character to a Latin equivalent is not feasible. Instead, we can use pinyin, which is a Latin-based phonetic transcription system for Chinese characters.

Using pinyin allows us to convert Chinese text into readable Latin equivalents without maintaining huge character maps. There is an open-source NuGet package called NPinyin.Core that makes this conversion straightforward. It’s lightweight and integrates cleanly into existing logic.

This approach also works well for mixed-language titles, such as:

击掌！You Rock!

which results in:

/ji-zhang-you-rock

Using a custom URL segment provider in Umbraco

With the conversion logic in place, the next step was to make Umbraco use it when generating URL segments.

When Umbraco generates URL segments, it runs through a set of URL segment providers, and it’s possible to create a custom one. The process is simple and well documented.

By adding a small amount of additional logic to separate Chinese characters with dashes, we ended up with a short and simple custom segment provider that generates readable, SEO-friendly Latin URLs for Chinese pages.

** Note: **
This approach converts each Chinese character to its pinyin representation and inserts dashes between characters. While this is not full linguistic word segmentation, it produces consistent, readable URL segments without adding unnecessary complexity.

Example implementation

using System.Text;
using NPinyin;
using Umbraco.Cms.Core.Models;
using Umbraco.Cms.Core.Strings;

namespace Project.Core.Urls;

// Custom URL segment provider that wraps Umbraco's default provider
// and applies Chinese to Pinyin conversion on top.
public class ChineseUrlSegmentProvider : IUrlSegmentProvider
{
    // We delegate to the default provider first, so we keep
    // Umbraco's built-in behavior for non-Chinese characters.
    private readonly DefaultUrlSegmentProvider _defaultUrlSegmentProvider;

    public ChineseUrlSegmentProvider(IShortStringHelper shortStringHelper)
    {
        _defaultUrlSegmentProvider = new DefaultUrlSegmentProvider(shortStringHelper);
    }

    public string? GetUrlSegment(IContentBase content, string? culture = null)
    {
        // Let Umbraco generate the initial URL segment,
        // then post-process it with our custom logic.
        return ChineseToPinyinWithDashes(
            _defaultUrlSegmentProvider.GetUrlSegment(content, culture)
        );
    }

    // Converts Chinese characters to pinyin and inserts dashes
    // between consecutive Chinese characters to improve readability.
    private static string? ChineseToPinyinWithDashes(string? input)
    {
        if (input is null)
        {
            return input;
        }

        var sb = new StringBuilder();
        var lastWasChinese = false;

        foreach (var c in input)
        {
            if (IsChinese(c))
            {
                // Insert a dash between consecutive Chinese characters
                if (sb.Length > 0 && lastWasChinese)
                {
                    sb.Append('-');
                }

                // Convert the individual character to pinyin
                sb.Append(Pinyin.GetPinyin(c.ToString()));
                lastWasChinese = true;
            }
            else
            {
                // Non-Chinese characters are passed through unchanged
                sb.Append(c);
                lastWasChinese = false;
            }
        }

        return sb.ToString();
    }

    // Simple Unicode range check for CJK Unified Ideographs
    private static bool IsChinese(char c)
    {
        return c >= 0x4E00 && c <= 0x9FFF;
    }
}

Results

With this approach in place, Chinese pages now automatically generate clean, readable, and shareable URL segments without any manual intervention. It works equally well for fully Chinese titles and mixed-language content, and it integrates cleanly into Umbraco’s existing routing pipeline.

The solution is lightweight, easy to maintain, and avoids the complexity of large character-mapping tables or full linguistic word segmentation — making it a practical choice for real-world Umbraco projects.

FastGooey

Fri, 09 Jan 2026 00:00:00 Z

Render content into native iOS and macOS UI directly from your Umbraco projects.

Umbraco CMS Developer MCP v17.0.1-beta.3 is out!

Thu, 08 Jan 2026 17:51:47 Z

https://www.linkedin.com/posts/phil-whittaker-82481716_umbraco-ai-mcp-activity-7415068292215930880-0KRg?utm_source=share&utm_medium=member_ios&rcm=ACoAAABj9KwBjr581HKBv-M3TbQu69Ia79rmfPw

UmBootstrap-17.1.0 released to match the release of Umbraco-17.1.0

Thu, 08 Jan 2026 13:27:19 Z

I have just released #UmBootstrap-17.1.0 to match the release of #Umbraco-17.1.0.It includes a some new features, content and bugfixeshttps://umbootstrap.com/

The Call for Speakers for Umbraco Spark is now closed!

Thu, 08 Jan 2026 12:02:37 Z

🎤 The Call for Speakers for Umbraco Spark is now closed!Thank you to everyone who submitted — we’re now reviewing all proposals.Speaker line up coming soon 👀👉 https://umbracospark.com/#UmbracoSpark #CFP #Umbraco

Busra Sengul from true digital will be one of the MCs at Umbraco Spark 2026

Thu, 08 Jan 2026 12:02:24 Z

Announcement time! 🚀 Busra Sengul from true digital will be one of the MCs at Umbraco Spark 2026!Speaker lineup coming soon — stay tuned 👀 👉 https://umbracospark.com/#UmbracoSpark #truedigital #Umbraco

New Year, New Perspectives: The Importance of Togetherness

Thu, 08 Jan 2026 00:00:00 Z

A new year has a funny way of inviting reflection. December often finds us looking back at the path we’ve taken, evaluating what worked, what didn't, and what we hope looks different twelve months from now.

Rewdboy.Umbraco.EditLink

Thu, 08 Jan 2026 00:00:00 Z

Package Description

Mastering the Subtle Art of MCP

Wed, 07 Jan 2026 05:18:35 Z

MCP is rapidly becoming a key layer in how AI systems connect with the tools and services developers rely on. Its real strength shows up when you go past simple integrations and start building deeper, structured capabilities. This session features Phil sharing practical guidance for creating reliable, production-ready MCP servers, drawing on insights from the Umbraco MCP implementation now adopted by the wider community.

Top Reasons Businesses Choose to Hire Remote Umbraco Developers

Tue, 06 Jan 2026 11:12:32 Z

In today’s competitive digital landscape, businesses need scalable, secure, and flexible content management systems to stay ahead. Umbraco…

Continue reading on Medium »

Skrift Issue #123

Tue, 06 Jan 2026 00:00:00 Z

Featuring guest posts by Bishal Tim on "Fully Automating Umbraco v17 Backoffice with AI + Umbraco MCP" and Shelly Chauhan on "Setting Up Umbraco With Umbraco Commerce"

uSkinnedSiteBuilder.StarterKit.Prima

Tue, 06 Jan 2026 00:00:00 Z

Responsive Starter Kit & Theme design add-on for uSkinned Site Builder demonstrating a fictional website for a Pizza Restaurant.

Webwonders.Umbraco.TableEditor

Tue, 06 Jan 2026 00:00:00 Z

A modern and flexible table editor for Umbraco. Provides editors with fine-grained control over table structure and semantics, while giving developers a clean and extensible rendering experience.

FoxCart.Payments.Invoice

Mon, 05 Jan 2026 00:00:00 Z

FoxCart e-commerce platform - Invoice/offline payment provider for manual payment processing.

FoxCart.Core

Mon, 05 Jan 2026 00:00:00 Z

FoxCart e-commerce platform - Core business logic, services, payment/shipping providers, and licensing for Umbraco CMS. Requires valid license for production use.

FoxCart.Payments.Mollie

Mon, 05 Jan 2026 00:00:00 Z

FoxCart e-commerce platform - Mollie payment provider supporting iDEAL, Bancontact, credit cards, and more.

FoxCart.Views

Mon, 05 Jan 2026 00:00:00 Z

FoxCart e-commerce platform - Shared Razor views, DTOs, and static assets for Umbraco CMS.

FoxCart.Payments.Stripe

Mon, 05 Jan 2026 00:00:00 Z

FoxCart e-commerce platform - Stripe payment provider supporting credit cards, Apple Pay, Google Pay, and more.

uSkinnedSiteBuilder.StarterKit.Camper

Sun, 04 Jan 2026 00:00:00 Z

Responsive Starter Kit & Theme design add-on for uSkinned Site Builder demonstrating a fictional Camping and Caravan Site website.

OC.MediaColourFinderV2 is now available

Sat, 03 Jan 2026 19:17:17 Z

OC.MediaColourFinderV2 is now available for #umbraco github.com/OwainWilliam... www.nuget.org/packages/OC....

OC.MediaColourFinderV2

Sat, 03 Jan 2026 00:00:00 Z

This package enables you to obtain an images brightest color, average color, and opposite color to the brightest which can then be used in your designs

UmbNav 4.0.2 for Umbraco 17 is out

Fri, 02 Jan 2026 17:53:21 Z

UmbNav 4.0.2 for #Umbraco 17 is out.This fixes an issue where child menu items would disappear when renaming a text parent itemGrab it here:https://marketplace.umbraco.com/package/umbraco.community.umbnav

Umbraco Community 2025 Highlights | Building, Learning, Growing

Fri, 02 Jan 2026 04:19:55 Z

A highlights recap of Umbraco community meetups from 2025, covering both online sessions and hybrid events. Featuring key moments from talks, discussions, and community interactions across the Umbraco ecosystem—presented as a visual montage with background music. Built by the community. Powered by shared learning. #Umbraco #UmbracoCommunity #UmbracoCMS #DotNet #TechMeetup #DeveloperCommunity

UmbHost.Tables

Fri, 02 Jan 2026 00:00:00 Z

A table property editor for Umbraco 17 that allows content editors to create and manage tabular data with support for header rows/columns and rich text editing.

Umbraco Spark 2026 Early Bird Tickets still available for £100, but only until Midnight Dec 31st 2025

Tue, 30 Dec 2025 11:08:40 Z

⏰ Early Bird reminder!Tickets for Umbraco Spark 2026 are available for £100, but only until Dec 31 at midnight.🎟 Secure your place now: https://umbra.co/48PdFnj#UmbracoSpark #Umbraco #BristolTech #WebDev #DotNet

Umbraco events calendar launches on umbraco.com

Sun, 28 Dec 2025 13:46:23 Z

Finding the right Umbraco event just got a lot easier 👀We’ve launched a brand new events calendar on umbraco.com, bringing all Umbraco events together in one place. From official Umbraco events to community driven meetups, you can now quickly see what’s coming up (online or in person) 🌍Up next is our Winter Keynote on Feb 3. Join us for a front row seat to Umbraco’s 2026 roadmap and strategy ❄️🔥Take a look and find your next Umbraco event at https://umbraco.com/events/#Umbraco

Umbraco Forms Extensions

Thu, 25 Dec 2025 08:00:00 Z

Over a period of time, we’ve been working on several client projects, and one of them came with a particularly interesting challenge: the need for extensive, custom form functionality. This gave us the perfect opportunity to explore how easy (or difficult) it actually is to extend Umbraco Forms.

Is Umbraco MCP Server Usable in Practice, or Is It Just a Phase?

Wed, 24 Dec 2025 08:00:00 Z

A non-developer’s mildly sarcastic journey into prompt-driven CMS automation.

Custom Property Editors in Umbraco 17

Wed, 24 Dec 2025 06:53:37 Z

A deep technical guide to Umbraco 17 custom property editors covering architecture, data flow, validation, and enterprise best practices.

Continue reading on Medium »

Say Hello to uMux: Sync videos from Umbraco to Mux effortlessly

Tue, 23 Dec 2025 19:06:54 Z

uMux is a brand new, free and open source, package for Umbraco 17+, that takes the hassle out of hosting videos on your website. Just drop your videos into Umbraco, and uMux will automatically upload and sync them with Mux. That means you get all the power of Mux’s streaming, thumbnails, and analytics, while still working in the CMS you love.

Why uMux?

For years, I found myself recommending platforms like Vimeo or similar to clients because they’re user-friendly and handle video streaming well. But there was always a catch: editors had to jump between systems, upload videos to Vimeo, then copy and paste IDs or embed codes back into Umbraco.

It’s clunky, error-prone, and just not the smooth experience editors deserve.

With uMux, my goal was to keep everything in one place.

Editors can upload and manage videos right inside Umbraco, just like they’re used to, while still getting all the benefits of a modern video platform like Mux. No more juggling logins, no more copy-pasting codes, just a seamless workflow.

What does it do?

uMux handles all the behind-the-scenes magic—your videos get sent to Mux, and Mux handles encoding, so the videos are ready to stream anywhere. Editors don’t have to worry about file types, encoding settings, or technical video stuff. It just works.

Why use a third party video host?

Serving big video files from your own server can be a pain, especially if you’re on Umbraco Cloud or have bandwidth limits. Here’s why letting Mux handle your videos is a game-changer:

Save your bandwidth
Mux takes care of the heavy lifting, so your Umbraco site stays speedy and you don’t get hit with surprise bandwidth bills.
Smooth streaming for everyone
Mux automatically streams the best quality for each viewer’s device and connection, so videos load fast and play without hiccups.
Global delivery
Your videos are delivered from servers close to your users, wherever they are in the world.

In addition to those obvious benefits, Mux also gives you some handy features around the videos you host with them.

Instant thumbnails & GIFs
Need a thumbnail or animated preview? Mux generates them for you—no extra work needed.
Awesome analytics
See how your videos are performing and where viewers might be dropping off.
Security & scalability
No worries about traffic spikes or unauthorized access—Mux has you covered.
Works everywhere
Embed videos in any player that supports HLS, or use Mux’s own slick player.
Automatic encoding
Mux encodes your videos in all the right formats, so you don’t have to think about codecs or compatibility.

Getting started

Install uMux:

  dotnet add package Umbraco.Community.uMux

Add your Mux credentials to your appsettings.json or as environment variables.
Add the Mux Sync property editor to your media types in Umbraco.
Upload your videos as usual - uMux takes care of the rest!

For all the nitty-gritty details, check out the README.

Modular Umbraco sites with NuGet, RCLs and uSync

Tue, 23 Dec 2025 08:00:00 Z

Many Umbraco teams have some kind of “starter” template for their projects - a collection of common content types or functionality, and helpers for things like SEO metadata. The goal is to give development a speed boost, and ultimately make projects more profitable.

Moving an Existing Umbraco Solution to Umbraco Cloud

Tue, 23 Dec 2025 06:32:26 Z

Migrating an already developed Umbraco solution — especially one with a custom architecture — to Umbraco Cloud can be challenging if not…

Continue reading on Medium »

Umbraco.Community.uMux

Tue, 23 Dec 2025 00:00:00 Z

Automatically sync local video assets from Umbraco to Mux

Building an AI Content Generator App Plugin for Umbraco 17

Mon, 22 Dec 2025 12:36:33 Z

Building an AI Content Generator App Plugin for Umbraco 17

How to Use Arro Simple Form in Umbraco 13–17

Mon, 22 Dec 2025 12:36:26 Z

How to Use Arro Simple Form in Umbraco 13–17 | Dynamic No-Code Forms

Umbraco vs WordPress: Which CMS Should You Use in 2026?

Mon, 22 Dec 2025 09:19:07 Z

canonical_url:https://www.addact.net/blogs/umbraco-vs-wordpress-which-cms-is-better

Choosing the right Content Management System (CMS) can make or break your next web project — whether it’s a blog, a corporate platform, or an enterprise portal. Two of the most widely discussed options are WordPress and Umbraco, but they serve distinctly different needs.

In this post, we’ll break down their differences, strengths, and use cases so you can decide which one fits your project from a developer’s perspective.

🚀 What Are WordPress and Umbraco?

WordPress
The world’s most popular CMS, powering ~40%+ of all websites on the internet.
Written in PHP and built with simplicity and extensibility in mind.
Designed to allow anyone to easily install a theme or plugin and launch a site quickly.

Umbraco
An open-source CMS built on Microsoft’s .NET stack.
Wikipedia
Focuses on scalability, customization, and structured content.
A favorite for enterprise-level applications and projects needing deep control.

🛠️ Customization & Flexibility

WordPress
⚡ Thousands of plugins and themes available
🎨 Rapid setup for common use cases
❗ Reliant on third-party plugins for extended functionality (which can raise maintenance overhead)

Umbraco
🔧 Built for developers — blank canvas approach
💡 Full control over architecture, workflows, and content models
📈 Better suited for complex, bespoke systems

👉 Quick takeaway: WordPress gets you up and running fast; Umbraco lets you build exactly what you want at the cost of more upfront work.

⚡ Performance & Scalability

WordPress
Performance can vary depending on hosting, plugins, and themes.
Scales decently with caching and optimizations.

Umbraco
Built on compiled .NET code, which can deliver strong performance out of the box.
Handles large, content-heavy, or high-traffic sites more predictably.

💡 Developer angle: Umbraco’s architecture often performs better in enterprise environments, while WordPress excels for small-to-mid projects with fewer technical constraints.

🛡️ Security Considerations

WordPress
Massive ecosystem means massive visibility — and more attack vectors.
Security largely depends on plugins and update discipline.

Umbraco
.NET foundation and enterprise-grade design yield fewer inherent vulnerabilities.
A smaller install base means fewer automated attacks.

🎯 Bottom line: Out-of-the-box, Umbraco tends to be more secure — but both platforms can be hardened with the right practices.

📈 SEO & Content Experience

WordPress
🔥 SEO is one of WordPress’s biggest strengths — plugins like Yoast and Rank Math make optimization very accessible.
📊 Easy meta editing, permalinks, and content tagging.

Umbraco
🔍 SEO is powerful but requires developer setup.
📌 You build the SEO tools yourself or customize them deeply.

👉 If you’re delivering lots of editorial content with SEO requirements, WordPress is usually easier. For highly controlled or non-standard SEO scenarios, Umbraco gives you complete flexibility.

💰 Cost & Maintenance

WordPress
Quick to set up and initially low cost
Long-term maintenance (plugin updates + security) can add complexity

Umbraco
Requires developer expertise and often higher initial cost
More predictable long-term platform maintenance

👥 Community & Ecosystem

WordPress
🌍 Huge community with tons of learning resources, plugins, and themes.

Umbraco
👨‍💻 Smaller but dedicated developer community — strong for .NET ecosystems.

🧩 Final Thoughts

There isn’t a “one-size-fits-all” answer.

Go with WordPress if you want a widely supported, developer-friendly CMS with tons of ready-made extensions.
Choose Umbraco for deep customization, enterprise stability, and .NET integration. Both tools are open source and capable — the right choice depends on your project’s scope, team expertise, and long-term growth strategy.

A Practical Guide to Unlocking Accessibility of Websites

Mon, 22 Dec 2025 08:00:00 Z

In this article, we dive into using powerful tools like WAVE to identify and address accessibility issues on your website. We also learn how to use these tools to spot common barriers, from missing alt text to improper heading structure, and take actionable steps to improve your site’s accessibility.

UmbracoForm.MailChimp.WorkFlow

Mon, 22 Dec 2025 00:00:00 Z

Umbraco Forms V17 Mailchimp Integration WorkflowType

An Introduction to Fluid Responsive Typography

Sun, 21 Dec 2025 08:00:00 Z

With support for CSS math functions min(), max(), clamp(), calc(), Container Queries and Container Query Units we have much greater control of typography.

uThemes.FlaticonPicker

Sun, 21 Dec 2025 00:00:00 Z

Flaticon picker property editor for Umbraco CMS 17

Lessons learned on my first Umbraco Commerce project

Sat, 20 Dec 2025 08:00:00 Z

Building my first e-commerce solution with Umbraco Commerce has been a good learning opportunity.

umbraCoffee - Ho Ho Ho!

Fri, 19 Dec 2025 09:45:09 Z

Welcome to your monthly dose of #umbraCoffee! Your hosts - Marcin and Callum - together with their guest(s) will drive through all of the community news and happenings in the Umbraco world. So... grab a cuppa, join us LIVE and enjoy! As is Christmas tradition, we are joined today by Umbraco Cloud product owner and all round wonderful human Rune Strand! See ya?! --- ☕ Wanna buy us a coffee/pizza/donuts? https://www.buymeacoffee.com/umbracoffee --- Notes: // TODO

Some (more) wintery wordplay!

Fri, 19 Dec 2025 08:00:00 Z

An Umbraco and technology themed cryptic crossword.

Why Composability Gets Complicated

Fri, 19 Dec 2025 00:00:00 Z

Get the key insights from our webinar with CMS Critic, focusing on why composability often becomes complex in practice and what teams tend to underestimate around data, architecture, and organisation.

Umbraco.Community.Cloud.HealthChecks

Fri, 19 Dec 2025 00:00:00 Z

A package for adding Umbraco Cloud health checks

Umbraco.Community.EnhancedMedia

Fri, 19 Dec 2025 00:00:00 Z

...

Altering Custom Table Columns in Umbraco Migrations

Thu, 18 Dec 2025 12:36:08 Z

https://www.nathanielnunes.com/blog/altering-custom-table-columns-in-umbraco-migrations @UMB.FYI#3772 tip

10 tips to make your Umbraco site more sustainable

Thu, 18 Dec 2025 08:00:00 Z

Practical ways to make your site greener, with clear, simple tips you can start implementing today

Skybrud.Umbraco.Redirects 17.0.1

Wed, 17 Dec 2025 22:26:35 Z

Award winning redirects manager for Umbraco.

Keeping Claude Code and Claude Desktop in sync

Wed, 17 Dec 2025 13:23:31 Z

https://umbracofreelancer.net/blog/keeping-claude-code-and-claude-desktop-in-sync-umbraco-freelancer/

Fixing 42-Second API Delays: An IPv6 Timeout Mystery

Wed, 17 Dec 2025 08:00:00 Z

I spent days chasing a 42-second API delay that drove me crazy. It wasn’t async/await, it was a broken IPv6 connection. Here’s what I learned and how I fixed it

Skybrud.Umbraco.Redirects 17.0.1

Wed, 17 Dec 2025 00:00:00 Z

Award winning redirects manager for Umbraco.

When GitKraken Desktop Runs Slow

Wed, 17 Dec 2025 00:00:00 Z

When GitKraken Desktop Runs Slow

Wed, 17 Dec 2025 00:00:00 Z

Authentication in Umbraco Using API Endpoints (JWT)

Tue, 16 Dec 2025 10:20:02 Z

Introduction : -

Continue reading on Medium »

13 Smart Uses for Temporary Segments in Umbraco Engage on V13+

Tue, 16 Dec 2025 08:00:00 Z

Martha and I, as marketers without technical backgrounds, attended our first Hackathon through the Umbraco Leeds Meet-up. The experience pushed us to apply our unique knowledge of Umbraco in creative ways, and inspired these practical tactics to help other Umbraco fans like us power up their personalisation and create campaigns that really resonate with Engage.

UmbracoCustomNavigation

Tue, 16 Dec 2025 00:00:00 Z

A reusable navigation component for umbraco

Introducing Umbraco to a new team

Mon, 15 Dec 2025 08:00:00 Z

A brief overview of how I introduced Umbraco to a team that had never used Umbraco, or any cloud-based CMS before.

OC.HiddenDashboard

Mon, 15 Dec 2025 00:00:00 Z

A hidden dashboard for Umbraco 17, revealed by the Konami code (↑ ↑ ↓ ↓ ← →), with full extensibility for third-party packages to register their own hidden content.

Umbraco.Community.OC.HiddenDashboard

Mon, 15 Dec 2025 00:00:00 Z

Hide a dashboard with Konami code to unlock. Features extensibility for third-party packages, configuration options, and includes a playable Pac-Man game as an example.

OC.HiddenDashboard - Umbraco Package

Mon, 15 Dec 2025 00:00:00 Z

OC.HiddenDashboard - Umbraco Package

Mon, 15 Dec 2025 00:00:00 Z

From Idea to Package: Building Member Impersonation for Umbraco backoffice

Sun, 14 Dec 2025 08:00:00 Z

A beginner‑friendly introduction to building an Umbraco package. From server‑side impersonation to a entity action and a small UUI frontend.

Umbraco Flavored Markdown: A ${template} for success

Sat, 13 Dec 2025 08:00:00 Z

Editor experience isn’t just a nice-to-have — it’s what makes or breaks your build. With the arrival of the first LTS using the new backoffice, we're seeing fresh possibilities to shape more intuitive and delightful editing environments. But with great innovation (hello Bellissima!) comes the loss of old comforts (farewell AngularJS).

Phases.Umbraco.Glossify

Sat, 13 Dec 2025 00:00:00 Z

Glossify adds a glossary picker to the Umbraco RTE, allowing editors to link selected text to glossary nodes, highlight the linked content, and display definition tooltips on the front end.

A New Level of Clarity and Confidence for Enterprise Projects

Sat, 13 Dec 2025 00:00:00 Z

Announcing Umbraco Power Tools, A small browser extension for Umbraco devs

Fri, 12 Dec 2025 08:27:40 Z

It's here: Umbraco Power Tools 🧰A small browser extension for Umbraco devs:• One-click switch between site ↔ /umbraco• Quick links to forum, socials & events• Useful Umbraco resources in one placeFirefox: https://addons.mozilla.org/en-US/firefox/addon/umbraco-power-tools/Chrome & Edge: https://chromewebstore.google.com/detail/umbraco-power-tools/mnnecgajjbmjjeneclnohbhaflmpjafh#Umbraco

Keeping Your Website Off the Naughty List: A Practical Guide to DDoS Defense for Umbraco

Fri, 12 Dec 2025 08:00:00 Z

As the holiday season brings both happy traffic spikes and the occasional unwelcome visitor, it’s the perfect time to make sure your website can handle the pressure. This guide walks you through real-world strategies for building DDoS resilience into your Umbraco (or any) site — from understanding attack layers and optimizing caching to setting up smart firewall rules and throttling policies.

If Burnout is an Injury, Passion is the Sport

Thu, 11 Dec 2025 12:00:00 Z

It's been a while since I wrote any kind of lifestyle post, but this one has been sitting in my brain for some time. After joining the organizers team for CODECABIN 2026 - which is happening in gorgeous Gleneagle, Colorado in March - and then reading Owain's blog post for 24 Days in Umbraco, I've been thinking a lot more about something that I know I have suffered strongly in the past year: burnout.

If you haven't read Owain's post yet, it is also a look back on this last year and a reflection on perfection, dream jobs, and change. It's both thoughtful, and thought-provoking, and is the strong impetus behind my own reflection on this phrase that I have been saying in my home the entirety of this last year:

Burnout is an injury. It takes time to heal, and it may never heal.

Looking Back at 2025

This year was a big year for me - after all, it's the 10 year anniversary of Skrift. A year of hype, a year of promotion, a year of improvement! Haha, just kidding. It was in fact Skrift's 10 year anniversary, but if we're being perfectly honest when the anniversary popped up on my radar in March (we started in April), I wasn't ready.

Kyle, my husband, was recovering from a long bout of pneumonia and a muscle tear that had landed him in the emergency room. He got diagnosed with that the same day our 17 year old kitty passed away (the first of two pets that we had to say goodbye to this year). Work was incredibly busy and I had a lot on my shoulders at the time - new builds, significant site upgrades/rebuilds, and some big new features for existing clients.

When I sat down to think about Skrift, a labor of love for over a decade, I wasn't even sure what to say. I couldn't focus on it. I had no interest in it. If we're being honest? I couldn't have cared less about the anniversary.

Move forward to planning my travel for Codegarden less than a month before the event, struggling through planning a (rather excellent, if I'm patting myself on the back) keynote presentation for the US Festival, writing blog posts and articles both for ProWorks, Skrift, and 24 Days...

They say it's not a sprint, it's a marathon, and boy howdy did this year feel like a marathon.

I love my job. I love Skrift. I love Umbraco. But I'm tired.

The Correlation Between Passion and Burnout

And that's the crux of my philosophizing in this post. The truth, for me, is you can't burn out on something if you weren't passionate about it. You cannot suffer burnout if you didn't first fall in love.

Pacing, thoughtfulness, giving yourself time and space to reflect and ponder doesn't happen when you're in the middle of a passionate affair with your career, your code, your writing, your art. Being all in, without limits and without boundaries, is how we make amazing progress and also how we break a leg. Or in this case, perhaps break our own hearts a little when we open our laptops, stare at the screen for one, five, fifteen, fourty-five minutes, and then close it again. Because there's nothing there to give when the day is over.

It's Time to Balance Your Passion with Routine

I have been in my current relationship for over fifteen years now, and the last five of them we've been married. If you asked me who my best friend is, I would immediately tell you that it's Kyle. And, while this is obviously very personal for an article about burnout in tech, I'm going to say that if I had tried to make the last fifteen years a wildly passionate fling, I would have absolutely burned out on my relationship as much as I would have any job.

But, especially when we have that shiny MVP badge next to our name, there's personal pressure that we put on ourselves to constantly maintain that passionate love affair with our work and our code - and it's as unrealistic as it is to maintain that level of energy in any interpersonal relationship.

What has made my last 15 years successful? Routine - full of easy, comfortable daily moments in each other's company, where we have our schedules laid out, our chores separated (I hate the dishes, Kyle hates scooping the litter boxes), and a healthy dose of laughter. And I think this is exactly what makes us successful at careers.

I'm not saying don't go above and beyond - obviously there are special moments - or not to push yourself when an opportunity presents itself that sparks your interest. I'm saying it's important to balance your passion with time to relax and let go. Embrace the moments where you aren't passionate, where you don't want to open the laptop, where the routine is good enough. Let passion be the sprint, not a marathon.

Step Away and Refresh

I am proud to say that ProWorks is a strong proponent of work life balance. I can count on one hand the amount of overtime I've worked after starting here three years ago. I also only work four days a week, something that they have supported me in, because I found that when the work week was over, I had no energy for the creative endeavors I love. Having my Mondays free means I actually draw, and I have grown so much as an artist.

It's important to give ourselves those moments, whether it's a randomly taken day off, a shorter work week, or stepping away to spend time with like-minded people in a quiet scenario. I remember being in Pete Duncanson's garden in England, talking with a few Umbracians in a personal setting, and feeling so refreshed and genuine.

If you get an opportunity - yep, there is a plug, but I honestly mean it - I recommend attending CODECABIN. I went to my first (and only) CODECABIN in 2022 after it had taken a break for COVID. While some people hacked - and yay that passion sprint - I spent most of my time in quiet conversations with people like me, about Umbraco, about life, about retirement (that was one of our big talking points that year), and yeah a little bit about code. It was refreshing, and I wouldn't say I came away passionate, I came away thoughtful and feeling like I had bonded with people who could accept me for who I am at this moment. If you get the chance, you should absolutely go.

Burnout is an injury brought on most often by an overabundance of passion. When you feel it, step back and allow yourself to heal. Remember that you don't have to push yourself every day. Routine is absolutely okay - in fact, it's healthy. It's a sprint, not a marathon.

Bellissima Backoffice: Custom Entity Signs

Thu, 11 Dec 2025 11:28:54 Z

You might recognise "entity signs" from the "pending changes" sign in older versions of Umbraco. But now, in Umbraco 17, we can add our own!

Scenario

You might have seen code like this, that blocks certain document types from being deleted.

/// A common use case: prevent certain document types being deleted
public class LockedDocumentContentMovingToRecycleBinNotificationHandler : INotificationHandler<ContentMovingToRecycleBinNotification>
{
    public static string[] LOCKED_ALIASES = ["home", "error"];
    public static Guid[] LOCKED_IDS = [
      Guid.Parse("a95360e8-ff04-40b1-8f46-7aa4b5983096"),
      Guid.Parse("9db112c5-c2ea-441d-8bd4-6daf522aa2b6")
    ];
    public void Handle(ContentMovingToRecycleBinNotification notification)
    {
        foreach (var item in notification.MoveInfoCollection)
        {
            if (Array.Exists(LOCKED_ALIASES, alias => alias.Equals(item.Entity.ContentType.Alias, StringComparison.OrdinalIgnoreCase)))
            {
                notification.CancelOperation(new EventMessage(
                  $"{item.Entity.Name} cannot be trashed",
                  $"The content item '{item.Entity.Name}' is of type '{item.Entity.ContentType.Name}' which cannot be trashed.",
                  EventMessageType.Error));
            }
        }
    }
}

But wouldn't it be nice to show this in the backoffice before trying to delete an item?

Flagging content items

The custom signs can be configured to show for items that have a certain "flag". This is also a new feature of Umbraco 17. (The only use I'm aware of for flags at the moment is for custom entity signs, but perhaps this will change in the future!)

using Umbraco.Cms.Core;
using Umbraco.Cms.Api.Management.Services.Flags;
using Umbraco.Cms.Api.Management.ViewModels;
using Umbraco.Cms.Api.Management.ViewModels.Document.Collection;
using Umbraco.Cms.Api.Management.ViewModels.Document.Item;
using Umbraco.Cms.Api.Management.ViewModels.Tree;
using My.UmbracoBackofficeExtensions.Notifications;

namespace My.UmbracoBackofficeExtensions
{
    // Created a C# class that implements `IFlagProvider`
    public class LockedDocumentFlagProvider : IFlagProvider
    {
        // We'll use this alias in the custom sign configuration
        private const string Alias = Constants.Conventions.Flags.Prefix + "My.Locked";

        // Indicate that this flag provider only provides flags for documents.
        public bool CanProvideFlags<TItem>()
            where TItem : IHasFlags =>
            typeof(TItem) == typeof(DocumentTreeItemResponseModel) ||
            typeof(TItem) == typeof(DocumentCollectionResponseModel) ||
            typeof(TItem) == typeof(DocumentItemResponseModel);

        // Implemented the `PopulateFlags` method which is just looping through each item and checking it in the `ShouldAddFlag` method.
        public Task PopulateFlagsAsync<TItem>(IEnumerable<TItem> itemViewModels)
            where TItem : IHasFlags
        {
            foreach (TItem item in itemViewModels)
            {
                if (ShouldAddFlag(item))
                {
                    item.AddFlag(Alias);
                }
            }

            return Task.CompletedTask;
        }

        // We just get the ID of the document type and check it against our list of IDs we don't allow being deleted
        private bool ShouldAddFlag<TItem>(TItem item)
        {
            Guid id;
            switch (item)
            {
                case DocumentTreeItemResponseModel dti:
                    id = dti.DocumentType.Id;
                    break;
                case DocumentCollectionResponseModel dc:
                    id = dc.DocumentType.Id;
                    break;
                case DocumentItemResponseModel di:
                    id = di.DocumentType.Id;
                    break;
                default:
                    return false;
            }

            return LockedDocumentContentMovingToRecycleBinNotificationHandler.LOCKED_IDS.Contains(id);
        }
    }
}

This provider also needs registering in a composer.

public class LockedDocumentComposer : IComposer
{
    public void Compose(IUmbracoBuilder builder)
    {
        builder.SignProviders()
            .Append<LockedDocumentFlagProvider>();

        // Our existing logic to disallow deleting the document deletion
        builder.AddNotificationHandler<ContentMovingToRecycleBinNotification, LockedDocumentContentMovingToRecycleBinNotificationHandler>();
    }
}

Configuring the custom entity sign

The entity sign is configured in a backoffice extension. If you're already extending the backoffice and have a manifests file already, please read on. Otherwise, I've written about extending the backoffice in my Template for Success article on 24 Days in Umbraco.

Once the flag is in place, entity signs only require a manifest to configure them, no JavaScript required:

import { UMB_DOCUMENT_ENTITY_TYPE } from '@umbraco-cms/backoffice/document';

export const manifests: Array<UmbExtensionManifest> = [
  // ...
  // Adding a new manifest of type `enitiySign` and kind `icon`
  {
    type: 'entitySign',
    kind: 'icon',
    alias: 'Umb.EntitySign.Document.My.Locked',
    name: 'Is Locked Document Entity Sign',
    // Specifying which enties can show this sign, documents
    forEntityTypes: [UMB_DOCUMENT_ENTITY_TYPE],
    // Specify what entities should be "flagged" with to make the sign show
    forEntityFlags: ['Umb.My.Locked'],
    // Can only show 2 icons at once, so the weighting matters. `-1000` means this one is really unimportant!
    weight: -1000,
    meta: {
      // Specifying what the sign looks like
      iconName: 'icon-lock',
      label: 'Locked',
      iconColorAlias: 'red',
    }
    // You'll notice we don't link to a TS file! Flagging is purely a C# concern
  }
];

The result

As you can see in the screenshot below, Home and Error are locked and have our new red padlock custom entity sign, while Features and Error have unpublished changes with the default pencil entity sign and Error has both, sorted by priority.

This is an example of what entity signs could be used for, but hopefully you can now imagine many more uses! And not just document types either!

Umbraco 17 LTS: Features, Improvements & What Developers Should Know

Thu, 11 Dec 2025 09:13:58 Z

canonical_url: "https://www.addact.net/blogs/umbraco-17-lts-features-and-future"

Every few years, the digital ecosystem takes a big leap forward. Frameworks evolve, performance expectations increase, and businesses look for platforms that can modernize without disrupting their existing operations.

For teams building with Umbraco, this evolution has always felt steady and intentional — each release improving the editing experience, strengthening stability, and simplifying the development workflow.

With the launch of Umbraco 17, the newest Long-Term Support (LTS) edition, the platform reaches another important milestone. It's not a radical reinvention but a strategic continuation of everything Umbraco does well: usability, flexibility, and long-term reliability.

Why Umbraco 17 Matters

Umbraco 17 is the next LTS after version 13 — and the upgrade path is intentionally smooth.

If you’re on Umbraco 13, you can directly upgrade to 17.
All intermediate migrations are applied automatically.
No multi-step upgrade headaches.

This is especially valuable for enterprise teams that prioritize stability and predictable lifecycles.

Built on .NET 10 LTS, Umbraco 17 aligns with Microsoft’s support timeline and will receive security + patch updates until late 2028. That gives organizations a strong, future-ready foundation for planning and compliance.

Major Advancements in Umbraco 17

1. Load-Balanced Backoffice

Umbraco 17 introduces true backoffice load balancing, allowing editors across regions to work simultaneously without:

performance drops
content conflicts
task failures It especially improves long-running operations and real-time features like SignalR.

2. Consistent UTC Date & Time Zone Handling

Older Umbraco versions relied on server-local time, causing issues for:

multi-region deployments
daylight-saving differences
workflows or scheduled publishing

Umbraco 17 fixes this with:

All system dates stored in UTC
Automatic migration for historical data
A new Date-Time with Time Zone property editor Scheduling, content workflows, and integrations become far more reliable.

3. Improved Backoffice UI & Editor Experience

The editorial experience gets a noticeable polish:

Clearer and more consistent entity icons
Streamlined navigation
Accessibility improvements
Subtle but meaningful speed boosts It's not flashy, but it makes editing faster and more intuitive.

4. Stronger Extension Model

Since the switch to the Bellissima backoffice (v14), Umbraco has been moving toward a modern extensible architecture.

In version 17:

Extensions are now first-class
Upgrade predictability improves
Reusable components become more stable This is a big win for teams who rely on custom editors, dashboards, or integrations.

Umbraco 17 on Cloud: Built for Scale
Umbraco Cloud gets several enhancements tailored to enterprise environments:

Better CI/CD tooling
Hostname validation
Centralized identity management
Bandwidth insights
Reliable scaling for high-traffic workloads

Plus, Umbraco Engage now aligns with the new backoffice and supports Deploy, making personalization moves across environments seamless.

Developer-Focused Enhancements
Umbraco 17 brings upgrades that directly improve engineering workflows:

TipTap becomes the default rich-text editor
Server-side preview URLs
Optimized dependency layer for .NET 10
Faster Models Builder performance

Together, these reduce debugging friction and improve day-to-day development speed.

Installing Umbraco 17 (Quick Guide)
You’ll need:

.NET 10 or later
VS Code or Visual Studio 2022
SQLite or SQL Server (2016+)
A modern browser

Umbraco Search is coming to town

Thu, 11 Dec 2025 08:00:00 Z

You better watch out, you better not cry. You better not pout, I'm telling you why: Umbraco Search is coming to town!

SlimPim.SlimConnect

Thu, 11 Dec 2025 00:00:00 Z

SlimConnect integrates SlimPim (Product Information Management) with Umbraco CMS. Automatically sync your product catalog, categories, variants, images and custom fields from SlimPim to Umbraco content nodes. Includes backoffice dashboard, scheduled sync, and frontend helper services.

Belissima Backoffice: Blocks in the Rich Text Editor

Wed, 10 Dec 2025 11:32:32 Z

We've been able to add blocks (as seen in Block List and Block Grid) to the Rich Text Editor (RTE) since Umbraco 13, but they're topical at the moment with v17 being released, the first LTS version since macros have been removed, more of us are looking to replace macros for good!

RTE Blocks are a new way of thinking about content (and a good replacement for macros!)

Creating block types

You can reuse your existing Block List and Block Grid blocks - they're exactly the same thing! But in most real use cases these will be different document types.

You simply need to create "element" type document types with all the properties you want on your new block, the difference comes in the data type you configure them in:

Adding blocks to the RTE

Instead of creating a Block List or Block Grid, we need to create (or modify an existing) Rich Text Editor data type.

We'll need to add the Block button to the RTE toolbar.

The RTE now has settings for configuring Blocks, just like in other Block editors:

Select your element types with optional settings and configure a label template, just as you would ordinarily as well as a setting for whether the block will render inline (think span) or as a block (think div).

Rendering RTE Blocks

This is probably where the RTE block differs most from the other block editors (and even that doesn't differ much!)

Simply needs a view matching the alias in the Views\Partials\RichText\Components folder.

Here's my example phone number view located at TemplateForSuccess.Web\Views\Partials\RichText\Components\PhoneNumberRteBlock.cshtml

@inherits Umbraco.Cms.Web.Common.Views.UmbracoViewPage<Umbraco.Cms.Core.Models.Blocks.RichTextBlockItem<ContentModels.PhoneNumberRteBlock>>
@using ContentModels = Umbraco.Cms.Web.Common.PublishedModels;
@using System.Text.RegularExpressions
@{
    var contactPage = Model.Content.ContactUsPage as ContentModels.Contact;

    if(contactPage is null || string.IsNullOrWhiteSpace(contactPage.PhoneNumber))
    {
        return;
    }
}

<a href="tel:@contactPage.PhoneNumber.Replace(" ", "")">
    @Regex.Replace(contactPage.PhoneNumber, @"\+44\s*", "0")
</a>

In this example I'm rendering a phone number from the selected contact page (a property on the Block), applying all the logic I want to format the phone number and adding the tel: link.

The journey for adding this block via the backoffice looks like this:

Click the insert block button
Pick my phone number block
Complete the content for the block, a content picker for the contact page in my case
Save
And a placeholder appears inline in the RTE

Which, when viewed on the frontend renders my view:

Bellissima Backoffice: Blocks in the Rich Text Editor

Wed, 10 Dec 2025 11:32:32 Z

RTE Blocks are a new way of thinking about content (and a good replacement for macros!)

Creating block types

You can reuse your existing Block List and Block Grid blocks - they're exactly the same thing! But in most real use cases these will be different document types.

You simply need to create "element" type document types with all the properties you want on your new block, the difference comes in the data type you configure them in:

Adding blocks to the RTE

Instead of creating a Block List or Block Grid, we need to create (or modify an existing) Rich Text Editor data type.

We'll need to add the Block button to the RTE toolbar.

The RTE now has settings for configuring Blocks, just like in other Block editors:

Rendering RTE Blocks

This is probably where the RTE block differs most from the other block editors (and even that doesn't differ much!)

It simply needs a view matching the alias in the Views\Partials\RichText\Components folder.

Here's my example phone number view located at TemplateForSuccess.Web\Views\Partials\RichText\Components\PhoneNumberRteBlock.cshtml

@inherits Umbraco.Cms.Web.Common.Views.UmbracoViewPage<Umbraco.Cms.Core.Models.Blocks.RichTextBlockItem<ContentModels.PhoneNumberRteBlock>>
@using ContentModels = Umbraco.Cms.Web.Common.PublishedModels;
@using System.Text.RegularExpressions
@{
    var contactPage = Model.Content.ContactUsPage as ContentModels.Contact;

    if(contactPage is null || string.IsNullOrWhiteSpace(contactPage.PhoneNumber))
    {
        return;
    }
}

<a href="tel:@contactPage.PhoneNumber.Replace(" ", "")">
    @Regex.Replace(contactPage.PhoneNumber, @"\+44\s*", "0")
</a>

In this example I'm rendering a phone number from the selected contact page (a property on the Block), applying all the logic I want to format the phone number and adding the tel: link.

The journey for adding this block via the backoffice looks like this:

Click the insert block button
Pick my phone number block
Complete the content for the block, a content picker for the contact page in my case
Save
And a placeholder appears inline in the RTE

Which, when viewed on the frontend renders my view:

Importing Block List Items Programmatically in Umbraco 17

Wed, 10 Dec 2025 08:00:00 Z

A practical, problem-solving guide on how to import Block List items programmatically in Umbraco 17 instead of manually creating them in the backoffice.

Bellissima Backoffice: Custom block views

Wed, 10 Dec 2025 05:20:34 Z

Custom block views have changed with recent versions, so let's take a look at how we might do this.

Custom backoffice block views are now configured using an Umbraco backoffice extension.

If you're already extending the backoffice and have a manifests file already, please read on. Otherwise, I've written about extending the backoffice in my Template for Success article on 24 Days in Umbraco.

The example

In this post I'll be using the example of showing a little tag to indicate a block is hidden. I'm using the familiar pattern used by Clean Starter Kit of having ahidden setting on each block. Rather than rendering the text "[HIDDEN]" in each block template I'd like this to automatically appear for all blocks. Here's a mockup I made in Paint of what we're aiming for here.

Registering the extension

Add a manifest to your manifests file:

export const manifests: Array<UmbExtensionManifest> = [
  // ...
  {
    // extension type is `blockEditorCustomView`
    type: 'blockEditorCustomView',
    alias: 'My.HiddenBlockEditorView',
    name: 'Hidden Block Editor View',
    // referencing a TS file for the element we want to use a the block view
    element: () => import('./hidden-block.element'),
    // specifying which block editor we're replacing the view for
    forBlockEditor: 'block-list'
  }
];

Creating the custom element

That referenced hidden-block.element.ts file looks like this:

import { html, customElement, LitElement, property, css, when } from '@umbraco-cms/backoffice/external/lit';
import { UmbElementMixin } from '@umbraco-cms/backoffice/element-api';
import type { UmbBlockDataType } from '@umbraco-cms/backoffice/block';
import type { UmbBlockEditorCustomViewElement, UmbBlockEditorCustomViewConfiguration } from '@umbraco-cms/backoffice/block-custom-view';

@customElement('hidden-block-custom-view')
// Extending the `UmbElementMixin` and implementing `UmbBlockEditorCustomViewElement`
export class HiddenBlockCustomView extends UmbElementMixin(LitElement) implements UmbBlockEditorCustomViewElement {

    // UmbRefListBlockElement is not exposed to extend it, so we have to copy a lot of it in to replace it:

    @property({ type: String, reflect: false })
    label?: string;
   // ...
   // Other properties copied from UmbRefListBlockElement
   // ...

    // This render method is largely copied from UmbRefListBlockElement, with some customisations to show hidden state
    override render() {
        const blockValue = { ...this.content, $settings: this.settings, $index: this.index };
        return html`
            <uui-ref-node standalone
        href=${(this.config?.showContentEdit ? this.config?.editContentPath : undefined) ?? ''}
        class="${this.settings?.hide ? 'hidden' : ''}">
            ${when(
                this.settings?.hide,
                () =>
                    html`<umb-icon slot="icon" name="icon-checkbox-dotted"></umb-icon>`,
                () =>
                    html`<umb-icon slot="icon" .name=${this.icon}></umb-icon>`
            )}
                <umb-ufm-render slot="name" inline .markdown=${this.label} .value=${blockValue}></umb-ufm-render>
                ${when(
                    this.unpublished,
                    () =>
                        html`<uui-tag slot="name" look="secondary" title=${this.localize.term('blockEditor_notExposedDescription')}
                                    ><umb-localize key="blockEditor_notExposedLabel"></umb-localize
                                ></uui-tag>`,
                )}
                ${when(
                    this.settings?.hide,
                    () =>
                        html`<uui-tag slot="name" look="secondary" title="Hidden"
                                >Hidden</umb-localize
                            ></uui-tag>`
                )}
            </uui-ref-node>
        `;
    }

    static override styles = [
        css`
            /* Copied styles from UmbRefListBlockElement and added custom styles /*
        `,
    ];
}
export default HiddenBlockCustomView;

declare global {
    interface HTMLElementTagNameMap {
        'hidden-block-custom-view': HiddenBlockCustomView;
    }
}

The full code sample is available on GitHub.

The new view!

With that in place, my block lists now look like this!

Belissima Backoffice: Custom block views

Wed, 10 Dec 2025 05:20:34 Z

Custom block views have changed with recent versions, so let's take a look at how we might do this.

Custom backoffice block views are now configured using an Umbraco backoffice extension.

The example

Registering the extension

Add a manifest to your manifests file:

export const manifests: Array<UmbExtensionManifest> = [
  // ...
  {
    // extension type is `blockEditorCustomView`
    type: 'blockEditorCustomView',
    alias: 'My.HiddenBlockEditorView',
    name: 'Hidden Block Editor View',
    // referencing a TS file for the element we want to use a the block view
    element: () => import('./hidden-block.element'),
    // specifying which block editor we're replacing the view for
    forBlockEditor: 'block-list'
  }
];

Creating the custom element

That referenced hidden-block.element.ts file looks like this:

import { html, customElement, LitElement, property, css, when } from '@umbraco-cms/backoffice/external/lit';
import { UmbElementMixin } from '@umbraco-cms/backoffice/element-api';
import type { UmbBlockDataType } from '@umbraco-cms/backoffice/block';
import type { UmbBlockEditorCustomViewElement, UmbBlockEditorCustomViewConfiguration } from '@umbraco-cms/backoffice/block-custom-view';

@customElement('hidden-block-custom-view')
// Extending the `UmbElementMixin` and implementing `UmbBlockEditorCustomViewElement`
export class HiddenBlockCustomView extends UmbElementMixin(LitElement) implements UmbBlockEditorCustomViewElement {

    // UmbRefListBlockElement is not exposed to extend it, so we have to copy a lot of it in to replace it:

    @property({ type: String, reflect: false })
    label?: string;
   // ...
   // Other properties copied from UmbRefListBlockElement
   // ...

    // This render method is largely copied from UmbRefListBlockElement, with some customisations to show hidden state
    override render() {
        const blockValue = { ...this.content, $settings: this.settings, $index: this.index };
        return html`
            <uui-ref-node standalone
        href=${(this.config?.showContentEdit ? this.config?.editContentPath : undefined) ?? ''}
        class="${this.settings?.hide ? 'hidden' : ''}">
            ${when(
                this.settings?.hide,
                () =>
                    html`<umb-icon slot="icon" name="icon-checkbox-dotted"></umb-icon>`,
                () =>
                    html`<umb-icon slot="icon" .name=${this.icon}></umb-icon>`
            )}
                <umb-ufm-render slot="name" inline .markdown=${this.label} .value=${blockValue}></umb-ufm-render>
                ${when(
                    this.unpublished,
                    () =>
                        html`<uui-tag slot="name" look="secondary" title=${this.localize.term('blockEditor_notExposedDescription')}
                                    ><umb-localize key="blockEditor_notExposedLabel"></umb-localize
                                ></uui-tag>`,
                )}
                ${when(
                    this.settings?.hide,
                    () =>
                        html`<uui-tag slot="name" look="secondary" title="Hidden"
                                >Hidden</umb-localize
                            ></uui-tag>`
                )}
            </uui-ref-node>
        `;
    }

    static override styles = [
        css`
            /* Copied styles from UmbRefListBlockElement and added custom styles /*
        `,
    ];
}
export default HiddenBlockCustomView;

declare global {
    interface HTMLElementTagNameMap {
        'hidden-block-custom-view': HiddenBlockCustomView;
    }
}

The full code sample is available on GitHub.

The new view!

With that in place, my block lists now look like this!

CLI tool for Package Script Writer now available

Tue, 09 Dec 2025 17:31:37 Z

umbPublisher 1.3.0 is now out

Tue, 09 Dec 2025 16:40:59 Z

umbPublisher 1.3.0 is now out. This release now lets you push images to Umbraco as part of your content. Got images in your markdown file, no problem, the media is saved in an "obsidian" folder and the links are updated in your markdown file. https://obsidian.md/plugins?search=Umbraco#umbraco #obsidian

Submit your talk proposal for Umbraco Spark by January 5th

Tue, 09 Dec 2025 12:05:19 Z

🎤 Why speak at #UmbracoSpark?2024 speaker @erica shares:“Umbraco Spark was incredibly welcoming and inspiring… seeing both sides connect with the takeaways was so validating. The community’s curiosity and warmth made it an amazing place to learn, connect, and contribute.”🎁 Free ticket + accommodation👉 Submit your proposal: https://sessionize.com/umbraco-spark-2026/🕛 CFP closes 5 January at midnight#Umbraco #Innovation #CallForSpeakers

Communication in the Backoffice

Tue, 09 Dec 2025 08:00:00 Z

A great customization integrates seamlessly — and the Context API makes that possible. In this article, I’ll show you how it works and how you can make the most of it.

Security Advisory, December 9, 2025: Security Patch is now available

Tue, 09 Dec 2025 00:00:00 Z

Umbraco.Community.IconPicker

Mon, 08 Dec 2025 13:16:43 Z

Happy to announce my first package! Originally build it for an own project. But now its out for the public! Currently only for V13, but started work on a v17 version already! Description should supply all that is needed: https://github.com/Ambertvu/Umbraco.Community.IconPicker

Umbraco Compose - Under the Tree

Mon, 08 Dec 2025 08:00:00 Z

A sneak peek at the orchestration platform, launching Q1 2026 - still too early for unwrapping, but...

Umbraco 17 LTS: Features, Upgrades & Benefits for Modern CMS

Mon, 08 Dec 2025 06:41:40 Z

Umbraco 17 LTS: Features, Upgrades & Benefits for Modern CMS

Why AI Needs a Platform, Not Just Potential

Mon, 08 Dec 2025 00:00:00 Z

Mats Persson, Umbraco CEO, explains why AI needs a CMS platform

Umbraco.Community.PagespeedOptimizer

Mon, 08 Dec 2025 00:00:00 Z

This Umbraco package improves your Google page speed score. This package automatically optimizes your site's front-end performance with zero coding required.

Cultiv.Hangfire 5.2.0 released

Sun, 07 Dec 2025 19:57:10 Z

I've had a productive weekend on my hobby projects 🙌`Cultiv.Hangfire` is now at 5.2.0 after merging 2 community PRs and implementing an idea Bjarne had years ago to move the Hangfire dashboard to it's own section - that is now an option! Release notes: https://github.com/nul800sebastiaan/Cultiv.Hangfire/releases/tag/v5.1.0 and https://github.com/nul800sebastiaan/Cultiv.Hangfire/releases/tag/v5.2.0Also: https://umbracalendar.com now has a stylesheet for it's RSS feed and the feed includes all events, not just the ones from meetup.com 🎉 Feed: https://umbracalendar.com/meetup#Umbraco

On Demystifying Our Work

Sun, 07 Dec 2025 08:00:00 Z

As web workers, we often mystify clients with jargon and complexity. Here's how to bridge the gap through context, translation, involvement, and trust in your web work.

ExtendEverything.TetrisDashboard

Sun, 07 Dec 2025 00:00:00 Z

Adds a Tetris dashboard to the Umbraco 17 backoffice.

Headless Umbraco: Two Paths to JSON Glory

Sat, 06 Dec 2025 08:00:00 Z

Sometimes you need Umbraco to just handle content while your frontend does its own thing. This article compares two approaches: Umbraco's built-in Content Delivery API versus building your own custom solution. We'll look at real code, and help you figure out which one actually fits your project.

Gotik.Commerce

Sat, 06 Dec 2025 00:00:00 Z

Complete e-commerce solution for Umbraco CMS including backend services, API controllers, product catalog with dynamic filtering, shopping cart, order management, and Odoo ERP integration. Built with clean architecture principles and enterprise-grade features.

Umbraco.Community.Lexicon

Sat, 06 Dec 2025 00:00:00 Z

Lexicon restores dictionary-based backoffice localization for Umbraco 14+. Use dictionary items to translate document type labels, descriptions, tab names, and group names in the backoffice.

Umbraco Recognized as a G2 Leader Across CMS and Headless in the Winter 2026 Reports

Sat, 06 Dec 2025 00:00:00 Z

Discover why Umbraco is recognized as a G2 Leader in CMS, Headless, DXP, and WebOps in the Winter 2026 Reports highlighting top usability, fast implementation, and strong global adoption backed by 936+ user reviews.

Find Ancestors of Item Using the Umbraco Content Delivery API

Fri, 05 Dec 2025 13:50:40 Z

'Twas the Night Before v17 Release

Fri, 05 Dec 2025 08:00:00 Z

A playful, holiday-style ode to the excitement surrounding the Umbraco v17 release, this poem follows a developer’s sleepless anticipation as they await new features, celebrate major technical improvements—from a redesigned back office to modernized front-end tooling—and applaud the entire Umbraco community. Blending humor, gratitude, and tech enthusiasm, it captures the collective joy of Release Day.

Codegarden 2026 Tickets Are LIVE!

Thu, 04 Dec 2025 09:35:42 Z

Join us in Copenhagen (or online) on June 10–11 for the biggest Umbraco conference in the world - two full days of learning, genuine conversations, and the kind of inspiration that brings business leaders, developers, and digital creators together. Read more and secure your spot at: https://codegarden.umbraco.com/

Tips to Make Your Technical Articles Umbazing

Thu, 04 Dec 2025 08:00:00 Z

Technical writing is a very different beast from fiction, poetry, or journaling. It often aligns more with an essay, but if it's too stiff and dry then what makes it different than documentation? This is already getting complicated, but don't worry! I'm here with a bunch of tips to level up your technical writing, or even just get you started if this is a new journey for you.

TinyMCE.Umbraco v17 Released and Ready for Umbraco 17

Wed, 03 Dec 2025 19:28:36 Z

The ProWorks team is excited to announce the release of TinyMCE.Umbraco v17, our latest update to the TinyMCE.Umbraco package for Umbraco CMS. If you're using or upgrading to Umbraco 17 and want to continue using TinyMCE, this update ensures full compatibility with the new Web Components-based back-office and adds in some other great features as well:

Additional features include:

Streamlined configuration for RTE Data Types in Umbraco
Enhanced settings that support direct JSON-based configuration via .NET (appsettings.json)
Support for updating TinyMCE to versions 7 or 8
Simple configuration-based TinyMCE Premium setup
OpenAI and ChatGPT integrations out-of-the-box
Migrations from v15 that keep TinyMCE in Umbraco as an RTE option by default

More information and documentation about TinyMCE.Umbraco here: https://github.com/ProWorksCorporation/TinyMCE-Umbraco

Highlights from the Umbraco 17 Release

Umbraco version 17 includes several major improvements that make it a compelling upgrade for most teams:

Umbraco MCP Server

A new integration layer to enable content editors to report on, manage, create, and update content and media through AI chat interfaces like ChatGPT and Claude. This allows for bulk operations and reporting where AI can reason and help editors understand their content at a new level.

Enhanced caching configuration

The new caching layer allows for more fine-grained configuration. Instead of simply caching all the content, now it can cache only the most used content for faster startup times and better performance for sites with lots of content.

A fully rebuilt back-office

The new back-office UI is powered by standard JavaScript Web Components, delivering better performance, faster load times, and a more modern foundation for custom extensions.

Read the official announcement from Umbraco here: https://umbraco.com/blog/umbraco-17-lts-release/

Thinking about upgrading?

We’d be happy to help with:

Upgrading from Umbraco versions 8 - 16 to the latest LTS
Back-office extension development
Custom TinyMCE plugins or editor integrations
Modernizing workflows using MCP Server and AI-enabled tooling
Custom MCP implementations for Umbraco websites

If you’d like to discuss your upgrade strategy or schedule a brief consultation, contact us below and we would be happy to help!

Top Reasons to Hire an Umbraco Development Agency

Wed, 03 Dec 2025 11:33:46 Z

Choosing the right CMS is one of the most important decisions for any business planning to grow online. Among today’s content management…

Continue reading on Medium »

When Passion Isn’t Enough: Choosing Wellbeing Over the “Perfect” Job

Wed, 03 Dec 2025 08:00:00 Z

Even the “dream job” can become unsustainable when personal wellbeing is compromised. This is a story about recognising burnout, making a tough decision to step away, and rediscovering purpose through reflection, honesty, and community.

Introducing the Umbraco Sustainability Agent Profile

Wed, 03 Dec 2025 00:00:00 Z

Learn how the new agents.md file helps developers use AI tools more efficiently in Umbraco projects by reducing emissions, saving costs, and supporting sustainable web development.

Safety Nets: What Cycling Taught Me About Umbraco Development

Tue, 02 Dec 2025 08:00:00 Z

A story about bikes, brakes, and better development: how unlearning an old "rule" helped me understand Umbraco's evolution and how safety nets like monitoring, tests, and community make us braver developers.

Umbraco + Astro workshop demo upgraded to v17

Tue, 02 Dec 2025 07:14:48 Z

First use of Umbraco v17: updating the Umbraco + Astro workshop Adam Prendergast and I delivered over the summer! Having initially built the project on v15 it's been great to keep the project with the latest versions of Umbraco, Astro and .NET! #umbraco #astro github.com/jacksorjacks...

Building My First Umbraco Package: Creating the Lorem Ipsum Generator

Mon, 01 Dec 2025 08:00:00 Z

This article shares my experience of building my first Umbraco package during the Umbraco Spark hackathon. Inspired by an idea from a PM at true, I set out to extend the Rich Text Editor with a Lorem Ipsum dropdown, making it simple to insert placeholder text directly into RTE blocks.

Clean Start Kit v7 is out now for Umbraco 17

Mon, 01 Dec 2025 03:00:00 Z

In this post I talk about the release of Clean v7 for Umbraco 17 and the new automation which has helped me streamline everything to do with maintaining the package.

Version 17 of UmBootstrap is here

Fri, 28 Nov 2025 13:47:09 Z

Version 1 7.0.0 of #Umbraco ❤️ and #UmBootstrap 🚀are here: https://umbootstrap.com/

Umbraco v17 versions of UmbNav, uCaptcha, Intl_Tel_Input and Smidge now available

Fri, 28 Nov 2025 13:46:31 Z

I have released stable versions of my packages for Umbraco 17!UmbNav v4:https://www.nuget.org/packages/Umbraco.Community.UmbNavuCaptcha v6:https://www.nuget.org/packages/Umbraco.Community.Forms.uCaptchaIntl_Tel_Input v6:https://www.nuget.org/packages/Umbraco.Community.Forms.Intl_Tel_InputUmbraco.Community.Smidge v2:https://www.nuget.org/packages/Umbraco.Community.Smidge#umbraco #umbraco17 #launchday

Umbraco 17 LTS is here

Fri, 28 Nov 2025 13:45:20 Z

Cue the confetti - Umbraco 17 LTS is here! 🎉This major-Major version of Umbraco is both a Long-Term Supported version and, for many, includes an upgrade to a modern backoffice architecture (introduced in Umbraco 14). New features and improvements include: - Load Balancing the backoffice 📈- Consistent handling of dates 🌎- Runs on the latest Microsoft .NET 10 LTS 🌟Happy upgrading, everyone! Find out exactly what you get with this release right here: https://umbraco.com/blog/umbraco-17-lts-release/

Contentment 6.0.0 For Umbraco 17 out now

Fri, 28 Nov 2025 13:42:31 Z

#umbraco #Contentment 6.0.0https://github.com/leekelleher/umbraco-contentment/releases/tag/6.0.0TL;DR, fresh out of beta, ready for Umbraco 17/.NET 10.

umbraCoffee - OP DELIVERED

Fri, 28 Nov 2025 09:00:59 Z

Welcome to your monthly dose of #umbraCoffee! Your hosts - Marcin and Callum - together with their guest(s) will drive through all of the community news and happenings in the Umbraco world. So... grab a cuppa, join us LIVE and enjoy! We're joint by two amazing gents from Umbraco HQ - Filip Bech-Larsen & Niels Lyngsø to talk about the latest LTS v17 release and more. See ya?! --- ☕ Wanna buy us a coffee/pizza/donuts? https://www.buymeacoffee.com/umbracoffee --- Notes: // TODO

ImageSharpRemoteImages now available for Umbraco v17

Fri, 28 Nov 2025 08:13:26 Z

Remote Image Provider for ImageSharp | Umbraco Marketplace

our.umbraco.fulltextsearch now available for Umbraco v17

Fri, 28 Nov 2025 07:43:01 Z

Full Text Search | Umbraco Marketplace

Skybrud Redirects is now available for Umbraco 17

Fri, 28 Nov 2025 05:34:13 Z

With #Umbraco 17.0.0 out today, a new release of Skybrud Redirects is now also available 🎉🦄https://github.com/skybrud/Skybrud.Umbraco.Redirects/releases/tag/v17.0.0

Jumoo.TranslationManager.Microsoft

Fri, 28 Nov 2025 00:00:00 Z

Microsoft Translation Api Connector for Translation Manager for Umbraco

Jumoo.TranslationManager.DeepL

Fri, 28 Nov 2025 00:00:00 Z

DeepL Translation Api Connector for Translation Manager for Umbraco

Jumoo.TranslationManager.Google

Fri, 28 Nov 2025 00:00:00 Z

Google Translation Api Connector for Translation Manager for Umbraco

Jumoo.TranslationManager.Passthrough

Fri, 28 Nov 2025 00:00:00 Z

Passes text stright through translation process - good if you just want the language in another site

Umbraco.Community.UmbNav.Core

Fri, 28 Nov 2025 00:00:00 Z

Drag and drop menu editor for Umbraco V15+

Mole.StorageProviders.AzureBlob.TemporaryFile

Fri, 28 Nov 2025 00:00:00 Z

Azure Blob Storage provider for Umbraco temporary files. Offloads temporary file storage during media uploads and other operations to Azure Blob Storage.

Jumoo.TranslationManager.Xliff

Fri, 28 Nov 2025 00:00:00 Z

Xliff 1.2 and Xliff 2.0 Connector for Translation Manager for Umbraco

Skybrud.Umbraco.Redirects 17.0.0

Thu, 27 Nov 2025 20:21:47 Z

Award winning redirects manager for Umbraco.

Dev Tip: Umbraco Commerce Scaling

Thu, 27 Nov 2025 14:29:28 Z

Dev Tip: Umbraco Commerce Scaling – Bump Digital - YouTube

Content Lock for Umbraco 17 now available

Thu, 27 Nov 2025 13:58:23 Z

Content Lock for 17 Only one small new feature - just because it was new in 16.4/17.0 Adds Flag Provider & Entity Sign (To display a locked icon in the tree in realtime for locked nodes) https://github.com/warrenbuckley/Umbraco.Community.ContentLock/releases/tag/v17.0.0 https://www.nuget.org/packages/Umbraco.Community.ContentLock/17.0.0 https://marketplace.umbraco.com/package/umbraco.community.contentlock /cc @UMB.FYI#3772 tip

Content Lock for Umbraco 17 out now

Thu, 27 Nov 2025 13:58:23 Z

Meta Momentum V17 out now

Thu, 27 Nov 2025 11:33:08 Z

Meta Momentum V17 search and social sharing package has just been released and ready for your upgrades!:v9rocket: https://www.nuget.org/packages/MetaMomentum/17.0.0 https://github.com/DigitalMomentum/MetaMomentum @UMB.FYI#3772 tip

Unboxing Umbraco 17 LTS

Thu, 27 Nov 2025 10:27:38 Z

Join us to learn about the significant improvements and new features of Umbraco 17, the new Long-Term Support release of the CMS now on .NET 10. We discuss new consistent date handling, user interface enhancements, the introduction of load balancing for the Backoffice and upgrade considerations from previous versions including Models Builder changes. Built on .NET 10 (ASP.NET Core 10), Umbraco 17 offers enhanced performance, scalability, and flexibility to meet your project's unique needs - whether you're developing a simple site or a large-scale content platform. 📰 Dive into the Umbraco 17 release blog post: https://umbraco.com/blog/umbraco-17-lts-release/ 📖 Visit our Umbraco 17 product page: https://umbraco.com/products/umbraco-cms/umbraco-17/ 🔗 Ready to learn more? Explore Umbraco 17 documentation: https://docs.umbraco.com/umbraco-cms 📑 Specific documentation links: - Version-specific upgrade instructions (including system Date/Time migrations & Models Builder changes): https://docs.umbraco.com/umbraco-cms/fundamentals/setup/upgrading/version-specific - Umbraco Cloud upgrade instructions: https://docs.umbraco.com/umbraco-cloud/optimize-and-maintain-your-site/manage-product-upgrades/product-upgrades/major-upgrades - Load balancing the Backoffice: https://docs.umbraco.com/umbraco-cms/17.latest/fundamentals/setup/server-setup/load-balancing/load-balancing-backoffice 00:00 Introduction 01:36 Umbraco/.NET Release Schedule 02:20 Highlights tour of Umbraco 14-16 12:04 Load balancing the Backoffice 17:15 Consistent handling of dates and new Date/Time property editors 27:20 UI Improvements including Entity Signs, Entity Action shortcuts, Collection Views, Accessibility improvements 38:49 Changes in Models Builder 44:20 Upgrade Considerations 47:20 What's Next 49:35 Credits

Unlocking the Umbraco Management API

Thu, 27 Nov 2025 05:35:16 Z

A focused deep-dive into the Umbraco Management API — how it really works, how to use it outside the backoffice, and what to watch out for in real implementations. This session covers practical demos, tricky payloads, integration patterns, and common pitfalls to help you push the API further than the docs. Owain Williams is a Senior Developer and 8× Umbraco MVP known for his hands-on expertise and practical guidance across the Umbraco ecosystem.

Umbraco.Community.UmbNav

Thu, 27 Nov 2025 00:00:00 Z

Drag and drop menu editor for Umbraco V17+

Umbraco 17 LTS: Final Release

Thu, 27 Nov 2025 00:00:00 Z

The latest Umbraco Major version is out. A milestone release that not just offers a bunch of great new features but also 3 years of stability as a Long-Term Supported version

Umbraco.Community.Forms.Intl_Tel_Input

Thu, 27 Nov 2025 00:00:00 Z

Add the Intl-Tel-Input text field to your Umbraco Forms for Umbraco V15+

Umbraco.Community.Forms.uCaptcha

Thu, 27 Nov 2025 00:00:00 Z

A simple to use and integrate captcha plugin for Umbraco Forms which supports hCaptcha, reCaptcha and Cloudflare Turnstile for Umbraco V15+

Asyntai.Umbraco.Chatbot

Thu, 27 Nov 2025 00:00:00 Z

Add an intelligent AI chatbot to your Umbraco website that provides instant answers to your visitors.Your website can now talk.

UK Partner Summit Umbraco 2025

Wed, 26 Nov 2025 21:48:59 Z

Secure member auth for the Delivery API

Wed, 26 Nov 2025 00:00:00 Z

Securing OpenID Connect auth tokens for publicly facing web apps.

Articulate for Umbraco is back with Umbraco 17 support

Tue, 25 Nov 2025 17:54:57 Z

Good news on the horizon - Articulate for #umbraco is back! Thanks to github.com/gavinfaux It's working with umb 17 🎉 I've tested exporting my own shazwazza.com blog running umb 12.3 and reimporting with latest code = 💯working. Truly awesome work💪

More efficient integration tests with Umbraco

Tue, 25 Nov 2025 07:11:08 Z

TLDR;

I made a package that removes the "database and Umbraco instance" per fixture constraint from Umbraco's Integration Test library. It also enables reuse of seeded database snapshots to avoid executing the same setup / seeding over an over per fixture or test.

An itch

I've spent way too long waiting for similar setup code for my integration tests the last couple of years. The modern .NET version of Umbraco's integration test library is super nice, and real effective with SQLite. But it's got a few constraints:

All things Umbraco is instantiated and spun up per test, granted a configurable amount.
Databases have to be "installed" and seeded for each TestFixture at the least.
All test fixtures need to inherit from Umbraco's base classes

So we spend a long time waiting for suff, even if it's only the little green box we care about:

We're also stuck either juggling a singleton of some sorts and/or stuffing a lot of "units" into the same fixture.
Any notion of intermediate base classes quickly become a sore spot.

An idea

I had recently discovered, likely for the n-th time in my life, that NUnit supports namespace scoped setup fixtures. Those live as long as all that other tests in that namespace and deeper. They bring an opportunity to share initial state across several fixtures. I often find it nice to have several fixtures for the same systems under tests because it makes sense to group by use-case rather than tech.

So I set out to see if I could hack together something that made Umbraco's base tests possible to use as setup fixtures rather than "base" fixtures. As things would have it it was early october, and the CanCon gang hosted a virtual hackathon on a friday. I took the day "off" regular work and gave it a go.

Dark magic

In the end I've used all the dirty tricks you can imagine in today's .NET landscape. You'll find Lib.Harmony for messing with Umbraco's tests' IL (Intermediate Language), and there's Castle DynamicProxy doing a lot of fooling around with the NUnit test hierarchy. The Harmony bit can likely be removed by making a few slight changes to Umbraco's test core, but I wanted to get this working satisfactory before suggesting such changes.

The bottom line is that those two tools let us run code before, after or even instead of inherited code. And that in turn enables all the following features.

A new way of composing tests

With the package I've cooked together we can leave the dark world of peach and purple above in favor of a way greener scenery like such:

So without further ado, let's dig into how you can get there too.

Umbraco's attributes

We rely on Umbraco's Tests:Database config and the [UmbracoTest] attribute to provide databases (or not). The Database option works almost as expected, but the four non-none options end up doing the same: they prepare one db for the lifetime of the setup fixture.

[ExtendableSetUpFixture]

The first attribute you have to know is [ExtendableSetUpFixture]. It's sole purpose is to enable the rest of them. Since it's inherited from [SetUpFixture], it tells NUnit we won't add any [SetUp], [TearDown] or [Test] methods in the marked class. But this is the attribute we'll add to any UmbracoIntegrationTest or UmbracoTestServerTestBase, and those have a bunch of each. That's why we have...

[MakeOneTimeLifecycle]

The first attribute in the package that does something. [MakeOneTimeLifecycle] lets you mark methods in otherwise not accessible base classes like UmbracoTestBase to become [OneTimeSetUp] methods rather than [SetUp] methods, and [TearDown] methods becomes [OneTimeTearDown].
Here's an example of what we'd feed it for an UmbracoIntegrationTest inheritor:

[UmbracoTest(Database=SchemaPerFixture, Boot=true)]
[ExtendableSetUpFixture]
[MakeOneTimeLifecycle(
    setUpNames: [nameof(UmbracoIntegrationTest.Setup), nameof(UmbracoIntegrationTest.SetUp_Logging)],
    tearDownNames: [
        nameof(UmbracoIntegrationTest.TearDown), nameof(UmbracoIntegrationTest.TearDownAsync), 
        nameof(UmbracoIntegrationTest.FixtureTearDown), nameof(UmbracoIntegrationTest.TearDown_Logging)
    ]
)]
public class MyLongLivedUmbracoSetUp : UmbracoIntegrationTest
{
}

I found it a bother to write that long attribute all the time, so there's a derived one called:

[OneTimeUmbracoSetUp]

It makes it slightly less messy by letting us write as follows:

[UmbracoTest(Database=SchemaPerFixture, Boot=true)]
[ExtendableSetUpFixture]
[OneTimeUmbracoSetUp]
public class MyLongLivedUmbracoSetUp : UmbracoIntegrationTest
{
}

Note however that the current version doesn't come with a 100% compatible one for UmbracoTestServerTestBase or ManagementApiTest<>, but it's easy to make one yourself, and they're likely suddenly in the package.

Now if you're into hacking around the environment and hidden, protected members lurking around in memory, we're quite alike. But when doing professional work that's often not what we're paid for. So even though the above code will start up a perfectly fine Umbraco instance with a SQLite database it doesn't do much good. We need to get at the IServiceProvider somehow...

[InjectionProvider(string)] and [ServiceProvider]

There is a limit to how many attributes we'll stick on our setup fixtures, I promise. I complained about intermediate base classes earlier, but a few for attribute consolidation is cool enough. OK, these two are a basic re-usable one and a "defaulted" one. The [InjectionProvider(string)] attribute stores a reference to a property on the setup fixture that exposes an IServiceProvider instance. Umbraco's base classes exposea property called Services, and [ServiceProvider] is just a derived [InjectionProvider(nameof(Services))]. To be specific, the service provider reference goes into the test context property bag as a factory method.
By adding one to our growing tower we're ready to meet our first actual test fixture enjoying the power of:

[Inject(string)]

To enjoy the benefits of our stored service provider reference, we must expose an instance method on our "scoped" test fixture that accepts services. We could've used constructor injection, but that's already "in use" by NUnit [TestFixture(args)] functionality. Once you start composing tests like this package allows, you can get much more value from things like that. So a void method will have to do. A fresh "standalone" and "scoped" test fixture will look like this:

using Same.Namespace.As.SetupFixture;

[Inject(nameof(Inject))]
public class LookMaImFreeAsABird
{
    IDataTypeService dataTypeService = null!;

    public void Inject(IDataTypeService dataTypeService)
    {
        this.dataTypeService = dataTypeService;
    }

    [Test]
    public void FiddleWithDataTypeA()
    {
        // ...
    }

    [Test]
    public void CreateDataTypeB()
    {
        // ...
    }
}

Notice the beauty of no forced ctors, no base class and no overrides in that class! Not to mention, you can have several of those!

Interlude: Transactions

With the above setup the individual fixtures are free to create ICoreScope instances from Umbraco and commit or dispose them as you wish. Just writing three sentences about it here doesn't really give the method justice. Suffice to say, just give it a go!
However it won't work when we use UmbracoTestServerTestBase. There's no way to spread a core scope across threads, and there's not even a way to spread gool old .NET transaction scopes across. I guess you could go full old school and bring DCOM into the picture, but after a lot of failed attempts I finally stumbled over an obvious solution.

Snapshots

The final itch has taken me the longest, and even longer to stuff into an attribute rather than yet another base class. I must admit it took a desperate (but accurate) final plea with ChatGPT 5.1 to see the obvious solution just lying there to implement. All database engines, or at least the two I've implemented, support some sort of fast backup. VACUUM INTO in SQLite and CREATE/RESTORE DATABASE AS SNAPSHOT in SQL Server.

I had two intermediate base classes for a few weeks, but this last weekend I ran over the goal line:

`[ReusableDatabase(type, string)]`

If you configure Tests:Database:DatabaseType in your appSettings.Tests.Local.json and set any of the non-none values in the [UmbracoTest] database parameter, you can also add [ReusableDatabase(typeof(SeedClass), nameof(SeedClass.Configure))] to get a new type of ITestDatabase.

As of writing it requires a method to be implemented in the setup fixture, or on some supporting type. Its mission is to configure whether the database needs a fresh seed and how to seed the initial data for all the tests. Only if we say so, the database is installed and re-seeded. For all other scopes it's just restored from that initial snapshot.

The seeding can be done in any way you please. My favorite is importing things using uSync, and that might just become another blog post. For simplicity let's say we're testing variants of property editors based on a datatype we want all tests to start with:

[UmbracoTest(
    Database = UmbracoTestOptions.Database.NewSchemaPerTest,
    Boot = true,
    Logger = UmbracoTestOptions.Logger.Console
)]
[ExtendableSetUpFixture]
[OneTimeUmbracoSetUp]
[ServiceProvider]
[ReusableDatabase(nameof(ConfigureSeeding))]
public class ReusedDbAttributeSetUp : UmbracoIntegrationTest
{
    public static void ConfigureSeeding(ReusableTestDatabaseOptions options)
    {
        options.NeedsNewSeed = _ => Task.FromResult(true);
        options.SeedData = async (services) =>
        {
            await TestContext.Progress.WriteLineAsync("Creating datatype");
            await services.GetRequiredService<IDataTypeService>().CreateAsync(
                new DataType
                (
                    new TextboxPropertyEditor
                    (
                        services.GetRequiredService<IDataValueEditorFactory>(),
                        services.GetRequiredService<IIOHelper>()
                    ),
                    services.GetRequiredService<IConfigurationEditorJsonSerializer>()
                )
                {
                    Name = "A seeded textbox"
                },
                Umbraco.Cms.Core.Constants.Security.SuperUserKey
            );
        };
    }
}

The method has to be static void. If it's on the setup fixture you can omit the type from the attribute parameters.
Now all tests within this "scope" will have access to the seeded textbox. Such seeding code might quickly grow out of hand though, and that's why I prefer just importing the content schema from the web project in the same repo as my tests.

Which ones to choose

As you've hopefully realized by now you can introduce really slim intermediate base classes that set up the initial environment for a bunch of use-cases and scenarios. Leaving your actual test fixtures free to be composed just as you wish, and with all the features of NUnit at your disposal.

I'm sure you can see that the last setup fixture example above makes for a nice base class to avoid repeating that tower of attributes. The repository has a few examples using a few or all of the attributes.

The final trick I haven't disclosed above is how to do a "mid-fixture" rollback. The reusable database implementations have a "RestoreSnapshot" method, so in a [TearDown] you can go:

await serviceProvider.GetRequiredService<IReusableDatabase>().RestoreSnapshot();

That makes it so that whatever test comes next it's unaffected by the changes you've made. This is of course what happens during [OneTimeSetUp] for any setup fixture using [ReusableDatabase].

If you want to try this out, I recommend going with [ReusableDatabase] (and uSync) for everything that use more than 10ish artifacts like data and content types, not to mention content. Whenever you want to run changes through the Management API, or definitely if you want to test how all your sites' elements look in the Delivery API. It's a no-brainer when you go full integration with UmbracoTestServerTestBase and more than one HTTP call.

If all your tests have all they need in a fresh Umbraco database, but they all mutate it so you need cleanup, it'll be blazing fast if you can use ICoreScope with autocommit off. As long as you don't need to test via HTTP endpoints, this is a better option than restoring the snapshot. Using a snapshot restore between fixtures however is still a nice option to keep around, so I still opt for [ReusableDatabase].

Want more?

I'm definitely going to be in "only fix what breaks for me" mode for a little while, as this was just gonna be a hacktoberfest weekend project. Turned out to take too much of my spare time for one and a half month instead.

But I honestly believe this'll save some trees if applied well to CI pipelines running all day long.
And I've gone from 90 sec to 26 sec to execute a full test suite, a lot of which would run for any filter.

The package is currently listed as a beta (pre-release) on nuget and if it doesn't crash much I might just promote it to full visibility. It's a bit furry on the edges and has a bit of legacy to it (already), but if you stick the namespaces in the project file and leave the stray base classes alone I think you'll be good.

All this is to say I'd love for conversation about what it solves and if it could do it better. I'd love even more to throw out a bit of the code because Umbraco suddenly fixed the core two issues. Let me hear from you if you try it out. Feel free to clone the code and mess about, although I reserve the right to refactor the mess myself that beautiful day I get to keep going with this.

Looking forward to hearing how (and if) you like it. Hope you have a go!

Links

Bellissima Backoffice: Property Descriptions

Mon, 24 Nov 2025 07:15:24 Z

I'm sure you're already aware of property descriptions! They’re useful to explain a property when a name doesn't give enough detail. The property descriptions have accepted markdown for a long time now (although allowed features have changed over time!). And because it’s markdown, that means we can use HTML too. And because its HTML it means we can also make use of web components, like UUI!

Property Descriptions: Read more

One of the features that's changed in recent versions is the "read more" functionality. In earlier versions of Umbraco, --- rendered a read more link.

Short description

---

Descriptions below a `---` were rendered behind a "Read More" link in v9-13.

This is no longer the case, --- renders a horizontal rule element (as it should!) but we can recreate the read more functionality with modern HTML.

Short description

---

Three dashes renders a horizontal rule.

<details>
<summary>Read more</summary>

We have to use the native HTML `details` element for modern Umbraco.

</details>

We can even take that a step further - in this example I’m using: markdown to render italic text, a code sample and a hyperlink; HTML to render a <details> element to recreate the read more functionality; and because UUI uses web components, which are HTML, we can bring UUI elements into the descriptions too, so I’ve got a UUI Umbraco help icon in there too to make the property description rich and intuitive without taking too much space.

Should search engines and other crawlers index this page and serve them up as search results?
<details>
<summary>
  <uui-icon name="icon-help-alt" label="More details"></uui-icon> 
</summary>

This sets the *index* aspect of the [`robots` meta tag](https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Elements/meta/name/robots)

</details>

Belissima Backoffice: Property Descriptions

Mon, 24 Nov 2025 07:15:24 Z

Property Descriptions: Read more

One of the features that's changed in recent versions is the "read more" functionality. In earlier versions of Umbraco, --- rendered a read more link.

Short description

---

Descriptions below a `---` were rendered behind a "Read More" link in v9-13.

This is no longer the case, --- renders a horizontal rule element (as it should!) but we can recreate the read more functionality with modern HTML.

Short description

---

Three dashes renders a horizontal rule.

<details>
<summary>Read more</summary>

We have to use the native HTML `details` element for modern Umbraco.

</details>

Should search engines and other crawlers index this page and serve them up as search results?
<details>
<summary>
  <uui-icon name="icon-help-alt" label="More details"></uui-icon> 
</summary>

This sets the *index* aspect of the [`robots` meta tag](https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Elements/meta/name/robots)

</details>

Protecting an Umbraco site against a bot attack

Fri, 21 Nov 2025 11:46:03 Z

A client's #Umbraco site was recently taken down by a bot. Here's a post about what happened, and what we did to mitigate the attack. If you've got an Umbraco site with forms (Umbraco Forms, or surface controllers) you probably need this WAF rule. dev.to/jasonelkin/t...

The Bot That Shouldn’t Have Taken Down My Umbraco Site, and the WAF Rule That Fixed It

Fri, 21 Nov 2025 11:19:36 Z

This week, one of our sites was brought down by a Denial of Service attack. It wasn’t really a DoS attack, i.e. I’m sure that wasn’t the attackers’ aim, but the attack did cause a Denial of Service nonetheless.

It was clear a bot was spamming the site with several thousands of requests per minute, but that in itself was well within the threshold that we’d expect the site to be able to handle - this is a modern Umbraco site with load-balancing/auto-scaling and a well optimized codebase after all.

So, what was going on?

The problem was the nature of the traffic – form submissions, shedloads of form submissions being made to both Umbraco forms and our custom surface controllers - that were causing errors.

It was those errors that contributed to a significant degradation in performance, leaving us with come challenges that we had to find a way to overcome:

1. Umbraco Forms

Umbraco Forms has a honeypot field built-in – this is a hidden text field that looks tempting to bots, so they fill it in. If a form is submitted with a value in that field, Umbraco Forms will reject the submission. The bot hitting our site was totally falling for the honeypot - great! So what’s the problem? When Umbraco Forms rejects that submission it also logs that rejection.

Logging is a non-trivial concern in performance-critical applications. In Umbraco, every log entry is a disk write operation by default. So, although the site would normally be able to handle this level of traffic easily, these POST requests are resulting in a disk write (which in an Azure Web App is actually a network request under the hood) – gobbling up IO and slowing the site down.

2. Surface controllers

We had a bigger problem with our surface controllers. Surface controllers use a hidden ufprt field to store an encrypted value for routing form submissions. If there’s a problem with this field, i.e. Umbraco can’t decrypt it, an error is thrown.

The bot spamming us was stuffing that field with SQL in the vain hope of carrying out an SQL Injection. Of course Umbraco was unable to decrypt that into a valid ufprt value so threw an error.

So, just like with Umbraco Forms we have an error being logged for each of these requests, with the added overhead of an Exception being thrown.

2.1 reCAPTCHA

There was another problem with our surface controllers: reCAPTCHA.

Like a lot of other .NET projects, we use an attribute on our controllers to handle reCAPTCHA validation. The problem is that this validation was running before Umbraco tried to decrypt the ufprt field – so as well as the exception and extra writes to disk, every request was also making an HTTP request to the reCAPTCHA API, gobbling up precious TCP threads.

We're serving all these requests!

On top of the errors themselves, we’re then returning a 500 error page for most of these requests.

These are dynamic/server-rendered pages on this site so they are using compute – it’s not a big deal, but we don’t want to be wasting those resources on bot requests.

Considerations

Sure, we could look at each of the individual problems above and solve for them but…

I still want to know about errors, so I need logging.
I still want to use reCAPTCHA to validate form submissions, especially from bots.
I still want to serve dynamic error pages (though there’s an argument to be made for better caching).

For legitimate traffic, I still want all of this to happen. For illegitimate traffic I don’t want our app to be responding at all - it’s a waste of resources. In fact, W3C’s Web Sustainability Guidelines recommend filtering suspicious activity for this reason.

We should be blocking this traffic at the edge, and that’s a job for the WAF - In this case Cloudflare.

The Solution

It’s time for a new WAF rule.

Fortunately, there’s a really simple rule that we can deploy in Cloudflare to block this traffic.

I set up a new Rate Limiting Rule with an expression that matches all POST requests, then rate limited it to 25 POST requests per IP address every 10 seconds before issuing a challenge.

No legitimate user is going to be making more than 20 POST requests in 20 seconds. You might even think that’s a little high, but we can only rate-limit by IP address, and multiple users will legitimately be sharing a single IP.

Here’s what that looks like in the portal:

The Result

3 million requests have been blocked since I deployed that rule yesterday and, most importantly, the site has remained online and performant for legitimate users throughout.

Win.

In Conversation With CMS Critic

Fri, 21 Nov 2025 09:07:47 Z

Is AI going to take our jobs?

Thu, 20 Nov 2025 16:53:24 Z

Final call for attendees The ClerksWell Charity Hackathon is happening on 28th November in London If you can get to London on that day, please sign up to our free event https://clerkswell.com/hackathon25 FAQs 🆓 Is it free to enter? Yes the hackathon is completely free to enter, you just need to make your way to London for the day. Food and drink will also be provided. If you live outside of London and travel costs are preventing you from attending please get in touch as we may be able to help you. 🏆 What are the prizes? There will be two winning teams, one for each of the two charity challenges. Each team will consist of 2 people. The prize for each winning team is: 1 Codegarden ticket 1 Expert Training & Certification bundle If your team wins, you’ll need to decide between yourselves who gets which prize. 💻 How much Umbraco do we need to use? There are no strict limits, just make sure you use Umbraco 17 in some way. It doesn’t need to be a full-blown implementation. Be creative! ⏱ What if we can't finish a working solution in time? That’s totally fine. The judges will assess entries based on several criteria, including usability and how well the idea meets the brief. Even if your solution isn’t fully working, your concept and approach still count. 👥 Do I need to already have a teammate? No. We’ve shared a private Slack channel with attendees where you can find a partner and form a team. 🧠 How good do I need to be at coding? You don’t need to be an expert. If you team up with someone whose skills complement yours, you’ll be in a great position. For example, if you're stronger in front-end or UX, you could pair with someone who’s more backend-focused. There will also be people around to help if you get stuck. 🕒 What are the timings? What if I arrive late or leave early? Coding starts at 10:00 and ends at 16:00. If travel is a challenge, it’s okay to arrive a bit late or leave slightly early. Just make sure you’ve coordinated with your teammate in advance so you’re aligned on what you’ll be working on. 🌐 Can I attend online? This is an in-person event only. However, the challenge briefs are public, and you’re welcome to try them out on your own. If you’d like to share your work with the charities afterwards, we’d be happy to connect you. 🫱 Can I take part if I already know the charities or ClerksWell? Yes, that’s not a problem. There are six independent judges, and ClerksWell won’t be involved in judging, to keep things fair. ❤️ Are the charities connected to ClerksWell? The charities are not clients of ClerksWell, but they are close to our hearts: Headway was suggested by Paul, who previously worked at an agency that built their website. Several of Paul’s family members have experienced brain injuries and benefited from Headway’s services. Restore Hope was suggested by Marc from ClerksWell, who has volunteered with them and admires the work they do in his local area.

Automate Your Lead Flow in Umbraco with Webhooks and Zapier

Thu, 20 Nov 2025 00:00:00 Z

From form submit to CRM: Learn how to automate lead validation, enrichment, and routing with Umbraco Forms, Zapier, and a bit of AI magic.

Skybrud.Umbraco.Redirects 17.0.0-beta002

Wed, 19 Nov 2025 22:44:11 Z

Award winning redirects manager for Umbraco.

Skybrud.Umbraco.Redirects 16.0.2

Wed, 19 Nov 2025 22:26:02 Z

Award winning redirects manager for Umbraco.

I love working on proof of concepts, don’t you?

Wed, 19 Nov 2025 16:10:11 Z

The ClerksWell Charity Hackathon is happening on 28th November in London If you can get to London on that day, please sign up to our free event https://clerkswell.com/hackathon25 FAQs 🆓 Is it free to enter? Yes the hackathon is completely free to enter, you just need to make your way to London for the day. Food and drink will also be provided. If you live outside of London and travel costs are preventing you from attending please get in touch as we may be able to help you. 🏆 What are the prizes? There will be two winning teams, one for each of the two charity challenges. Each team will consist of 2 people. The prize for each winning team is: 1 Codegarden ticket 1 Expert Training & Certification bundle If your team wins, you’ll need to decide between yourselves who gets which prize. 💻 How much Umbraco do we need to use? There are no strict limits, just make sure you use Umbraco 17 in some way. It doesn’t need to be a full-blown implementation. Be creative! ⏱ What if we can't finish a working solution in time? That’s totally fine. The judges will assess entries based on several criteria, including usability and how well the idea meets the brief. Even if your solution isn’t fully working, your concept and approach still count. 👥 Do I need to already have a teammate? No. We’ve shared a private Slack channel with attendees where you can find a partner and form a team. 🧠 How good do I need to be at coding? You don’t need to be an expert. If you team up with someone whose skills complement yours, you’ll be in a great position. For example, if you're stronger in front-end or UX, you could pair with someone who’s more backend-focused. There will also be people around to help if you get stuck. 🕒 What are the timings? What if I arrive late or leave early? Coding starts at 10:00 and ends at 16:00. If travel is a challenge, it’s okay to arrive a bit late or leave slightly early. Just make sure you’ve coordinated with your teammate in advance so you’re aligned on what you’ll be working on. 🌐 Can I attend online? This is an in-person event only. However, the challenge briefs are public, and you’re welcome to try them out on your own. If you’d like to share your work with the charities afterwards, we’d be happy to connect you. 🫱 Can I take part if I already know the charities or ClerksWell? Yes, that’s not a problem. There are six independent judges, and ClerksWell won’t be involved in judging, to keep things fair. ❤️ Are the charities connected to ClerksWell? The charities are not clients of ClerksWell, but they are close to our hearts: Headway was suggested by Paul, who previously worked at an agency that built their website. Several of Paul’s family members have experienced brain injuries and benefited from Headway’s services. Restore Hope was suggested by Marc from ClerksWell, who has volunteered with them and admires the work they do in his local area. Let me know if you have any others to add or want to change any. We are checking with Lotte about the one which mentions help with travel, so please don't publish yet.

US Partner Summit Umbraco 2025

Wed, 19 Nov 2025 14:24:47 Z

Umbraco CMS Developer MCP for Umbraco 16

Wed, 19 Nov 2025 00:00:00 Z

Two months ago, we released the beta of the Umbraco MCP Server - a bridge between AI assistants and Umbraco CMS. Now, we're thrilled to announce the official first release of the Umbraco CMS Developer MCP for Umbraco 16.

Umbraco Spark Diversity programme launches

Tue, 18 Nov 2025 12:19:08 Z

🎉 Have you heard about the Umbraco Spark Diversity programme? We're offering FREE tickets to ensure everyone can attend the conference, regardless of background, gender, race, or experience. 👉 Apply or nominate today: https://shorturl.at/YHwkj for a chance to receive a free ticket. Let's build a tech community where everyone is included. 🌟 #umbracospark #diversityintech #umbraco

.NET 10 is now available across all of UmbHost shared hosting

Mon, 17 Nov 2025 10:17:17 Z

.NET 10 is now available across all of our shared hosting!This means you can now deploy Umbraco 17 and other dotnet 10 applications to us!Get started here 👉 https://umbhost.net/hosting/cloud-umbraco-hosting #hosting #umbraco #dotnet #dotnet10 #sharedhosting

Don’t outsource your AI strategy

Mon, 17 Nov 2025 00:00:00 Z

The first Umbraco Education Program in India is a Huge Success

Sat, 15 Nov 2025 14:40:38 Z

Two weeks ago, the first Umbraco Education Program in India took place 🇮🇳 Over 50 LJ University students spent two days learning and earned their first Umbraco Certification 🎓👏 Thanks to all involved, especially Nikhil Prajapati and Giriraj Digital 🙌#Umbraco

Sign up to the Umbraco Winter Keynote 2026

Fri, 14 Nov 2025 12:49:35 Z

Imagine it’s February 3rd, 4:30 PM CET. Your team is gathered in your favorite meeting room, drinks in hand, screens glowing… all eyes on the Umbraco Winter Keynote 2026 ❄️🔥You guessed it! You can now sign up for the Winter Keynote and grab a front-row view of how Umbraco will empower you to win in 2026 - all free and online.🚀 Sign up now (and we’ll send the recording if you can’t join live).https://umbra.co/3WVEPCd #Umbraco

Umbraco.Community.OEmbed.Indiveo

Fri, 14 Nov 2025 00:00:00 Z

A lightweight Umbraco CMS plugin that adds OEmbed support for Indiveo directly into the Umbraco Rich Text Editor (RTE)

ClerksWell Charity Hackathon Call for Attendees

Thu, 13 Nov 2025 09:53:52 Z

Join your nearest Umbraco 17 Launch Party

Thu, 13 Nov 2025 08:55:13 Z

Communities worldwide are celebrating the Umbraco 17 release this November 🎉 Whether you’re a long-time contributor or new to the community, this is your chance to celebrate the latest release and connect with fellow Umbraco enthusiasts around the world 🌍Join the party nearest to you:Sydney, Nov 27: https://umbra.co/4r96Sft Amersfoort, Nov 27: https://umbra.co/4qPPa0fLondon, Nov 28: https://umbra.co/4nMU0sjGlasgow, Dec 4: https://umbra.co/49G4mXy #Umbraco

Umbraco CMS 17.0.0 Release Candidate 2 is out

Thu, 13 Nov 2025 08:55:00 Z

Umbraco CMS 17.0.0 Release Candidate 2 is out 🎉 Release notes here👇 https://releases.umbraco.com/release/umbraco/Umbraco-CMS/17.0.0-rc2 https://github.com/umbraco/Umbraco-CMS/releases/tag/release-17.0.0-rc2 Umbraco CMS 16.4.0 Release Candidate is out 🎉 Release notes here 👇 https://releases.umbraco.com/release/umbraco/Umbraco-CMS/16.4.0 https://github.com/umbraco/Umbraco-CMS/releases/tag/release-16.4.0-rc #Umbraco

A pre-release of Skybrud Redirects is now available for Umbraco 17

Wed, 12 Nov 2025 11:36:16 Z

A pre-release of Skybrud Redirects is now available for #Umbraco 17 🎉https://github.com/skybrud/Skybrud.Umbraco.Redirects/releases/tag/v17.0.0-beta001

Skybrud.Umbraco.Redirects 17.0.0-beta001

Tue, 11 Nov 2025 21:17:40 Z

Award winning redirects manager for Umbraco.

Get Ready For Umbraco Spark 2026

Tue, 11 Nov 2025 18:21:50 Z

https://gibe.digital/blog/umbraco-spark-2026/

Join Lotte and Emma at .NET Conf 2025

Tue, 11 Nov 2025 12:57:53 Z

We’re excited to speak at .NET Conf 2025! 🎉Join Lotte and Emma for “From Frameworks to Friendliness,” a session on building more welcoming open source communities. Catch it this Thursday at https://umbra.co/3Jnqzz7 💙#Umbraco

Early bird tickets for Umbraco Spark 2026 are out now!

Mon, 10 Nov 2025 12:01:38 Z

🎟️ Early bird tickets for Umbraco Spark 2026 are out now!Join us on 20 March in Bristol for a day of Umbraco insights, community collaboration, and open-source energy.Grab your ticket while early bird pricing lasts → https://www.tickettailor.com/events/umbukfdn/1896581 #Umbraco #UmbracoSpark #Innovation

Live from Umbraco in the City Manchester!

Mon, 10 Nov 2025 07:00:09 Z

All four of us were together in-person - for the first time over two years - at Umbraco in the City, a community-organised event in Manchester. We talked about what contributions look like to a mature open-source product with a team of full time engineers working on the codebase. Are code contributions still the “gold-standard”, were they ever? We discuss this and what other types of contrubitions make a meaningful difference to the Umbraco CMS in front of a wonderful live audience.
Thanks to our guests - Michael Latouche, Paul Seal and our new best friend Kieron McIntyre - for taking the microphone and sharing their contribution stories.
High five to them and the audience, we had a lot of fun!

Links

Algolia provider for Umbraco Search

Mon, 10 Nov 2025 00:00:00 Z

An introduction to the Algolia provider for Umbraco Search, including a discussion about best practices for Umbraco data in Algolia.

Help Dean Leigh race money for Bowel Cancer UK this Christmas

Sun, 09 Nov 2025 20:56:30 Z

I know were still in Movember but I need an early start to get a decent santa beard!Please help me raise some money for @bowelcanceruk #Decembeard no matter how small it all helps.https://www.justgiving.com/page/dean-leigh-decembeard-2025

Adage.Engage.Inspector

Sat, 08 Nov 2025 00:00:00 Z

Visual A/B test and personalization inspector for Umbraco Engage. Enables content editors to visually select and configure content variants directly in the frontend.

Umbracokalaset 2025 - Swedish Umbraco Festival

Fri, 07 Nov 2025 12:00:00 Z

I had the absolute pleasure of speaking at Umbracokalaset 2025 in Stockholm! From friendly faces and great conversations to an incredible response to my talk on building better content editor experiences, it was an unforgettable week with the amazing Umbraco community.

Umbracokalaset 2025 - Swedish Umbraco Festival

Fri, 07 Nov 2025 12:00:00 Z

Nah, the Umbraco Community Hasn't Lost It's Spark - We Have

Thu, 06 Nov 2025 22:45:56 Z

What a contradictory title, please let me explain.

This article is a response to Owain William's thought-provoking blogpost, Has the Umbraco Community lost its Spark?

While I understand where Owain is coming from and I too feel the change, I'd like to set up a defense: It's not Umbraco, it's not you, it's not me.

So what has changed?

We're Exhausted

We're all grinding harder just to tread water, trying our best to cling to the standard of living we once took for granted. Less time for Discord banter, fewer swag selfies on Umbraco Tees Day. Sound familiar?

While I agree with Owain, I just can't stand this characterization assassination of the Umbraco community. This despair (dramatic?) is all over the place. I have seen video after video show up on my YouTube feed lamenting the zombification and decline of community over the last few years.

In one, the host described a recent trip to the Kentucky Derby where he was shocked at the low attendance, the lack of inebriation of those who did attend, and at the relatively disconnected feeling of the entire event - a sharp contrast against the years of decades of the past.

I have never been, but I feel it too. Christmases, thanksgivings, halloweens, independence days, none of these feel the same lately. Hell, malls barely bother with holiday displays anymore, and it doesn't seem to matter because no one has the time to enjoy them anyway. These occasions now blend into any other day, and I feel horrible for this generation of children being deprived of the same joy I had.

People are so eager to blame this zombification on smartphone usage, but that's such a lazy analysis and so far off the mark that it makes my skin crawl.

In this response, I'll walk you through how we are being slowly and invisible suffocated by compounding financialization of every segment of our economy. It's crept in over decades, draining joy from what we love, bit by bit.

You probably haven't heard this story before. I'll admit up front: this is going to be contrarian and politically incorrect, but I promise to do my best to be truthful and objective.

How Did We Get Here?

The 2008 crisis wasn't fixed; it was papered over. Politicians bailed out arrogant and irresponsible bankers in a now familiar pattern of "socialism for corporations, capitalism for the rest."

The "fix" for the 2008 crisis was to pretend the whole thing never happened: reinflate the asset bubbles, but with stricter rules this time. This kicked off the funny-money era, but bad policy started in 1971 when we ditched the gold standard, a Bretton Woods/post-WWII holdover, to cover the costs of the Vietnam War.

Through the 2010s, every hiccup or slowdown triggered Fed rate cuts, plunging deeper into a ZIRP (zero interest rate policy) environment. We had historic low interest rates on everything, and money was cheap. Each rate cut did in fact stimulate economic activity and kept the economy from actually, finally, correcting. You likely observed this in your own life with residential home mortgages, or in the news with historic investment banking deals.

Analysts gawked at the "depravity" of this tactic, which was a decisive turn from what is considered conventional and sound financial policy. Trillions of dollars were printed out of thin air, also know as QE (quantitative easing), which debased the US dollar. These analysts were predicting bubble-pop events for years, none of which materialized, always stymied by another round of QE.

Still, the dollar's status was protected, as it held as reserve king in petrodollar trades (buying and selling oil), and foreign Treasury hoarding (foreign countries buying our debt). Or to put it another way, by being "the least dirtiest toilet paper" around.

It worked, until September 2019's repo crisis. Liquidity vanished, rates spiked to 10%. Banks swapped assets (consumer mortgages, consumer auto loans) for Fed cash to avoid collapse. The trigger still isn't clear, but most believe it to be a combination of regulatory scars, reserve shortages, and second-order pain from Trump's 2018 tariffs, which sparked a mini-recession in manufacturing. By September 2019, the runway for QE had run out. Interest rates couldn't be cut any further, and the roosters were coming home to roost.

This should have triggered a crash, or "correction," but just months later the world was thrown into COVID chaos, while spending bills were quickly passed to inject liquidity into the financial system and stimulate the economy, in the range of trillions of dollars. This effectively masked the repo crisis, but kicked off insidious inflation, which has transformed into "stagflation."

In a "stagflation" scenario, prices remain high, even as demand drops. This irrational, but very real phenomenon runs contrary to Econ 101, which tells us that as the cost of goods rise, demand drops (and vice versa). There's no real way to handle this scenario, as a citizen, except to hold hard assets (real estate, gold), invest (and hope the market doesn't pop), or find ways to hustle harder and make more money. Financial institutions don't really have an answer for addressing stagflation, either, except to play shell games increasing and decreasing interest rates in a desperate attempt to try and keep the circus going.

Just last week (October 2025), the repo market way haywire again as banks struggle with liquidity issues, speculated to be caused by the current longest-ever historical US government shutdown.

There are two ways to solve this stagflation problem, and politicians are now facing a cliff: they can decide to keep printing and let inflation rip, or decide to let a very painful but proper correction hit (overdue since 2008), with the upside that we return to value and fundamental financial policy. Take your best on which they'll pick.

It's Not Umbraco

We're all now working harder to maintain the standard of living we're used to, we have less time and means to participate in communities. Our employers tighten down in austerity, layoffs continue to accelerate across the industry, creating a chilling effect.

And then one day, all of the sudden, you're just tired. Real, fucking, tired.

Kudos to Owain for spotting this, but it's not just the Umbraco community. The broader financialization of our economy means this broken system applies to every facet of your life, even your Chipotle burritos.

This isn't a failure of the Umbraco community not showing up, or of Umbraco not investing enough, or of the devrel team not working hard enough (how many festivals and community meetups have been re-ignited in the last few years?). I'd actually argue that Umbraco and festival committees seem to be doing more than I can ever remember. What we're all feeling is the endgame of an ugly economic war so raw that no politician would dare be honest about.

Inflation is silently stealing our live, breaking our spirits, and it's extremely unfair.

Nah, the Umbraco Community Hasn't Lost It's Spark - We Have

Thu, 06 Nov 2025 22:30:55 Z

What a contradictory title, please let me explain.

This article is a response to Owain William's thought-provoking blogpost, Has the Umbraco Community lost its Spark?.

While I understand where Owain is coming from and I too feel the change, I'd like to set up a defense: It's not Umbraco, it's not you, it's not me.

So what has changed?

We're Exhausted

People are so eager to blame this zombification on smartphone usage, but that's such a lazy analysis and so far off the mark that it makes my skin crawl.

You probably haven't heard this story before. I'll admit up front: this is going to be contrarian and politically incorrect, but I promise to do my best to be truthful and objective.

How Did We Get Here?

The 2008 crisis wasn't fixed; it was papered over. Politicians bailed out arrogant and irresponsible bankers in a now familiar pattern of "socialism for corporations, capitalism for the rest."

Through the 2010s, every hiccup or slowdown triggered Fed rate cuts, plunging deeper into a ZIRP (zero interest rate policy) environment. We had historic low interest rates on everything, and money was cheap. Each rate cut did in fact stimulate economic activity and kept the economy from actually, finally, correcting. You likely observed this in your own life with residential home mortgages, or in the news with historic investment banking deals.

It worked, until September 2019's repo crisis. Liquidity vanished, rates spiked to 10%. Banks swapped assets (consumer mortgages, consumer auto loans) for Fed cash to avoid collapse. The trigger still isn't clear, but most believe it to be a combination of regulatory scars, reserve shortages, and second-order pain from Trump's 2018 tariffs, which sparked a mini-recession in manufacturing. By September 2019, the runway for more QE had run out. Interest rates couldn't be cut any further, and the roosters were coming home to roost.

Just last week (October 2025), the repo market way haywire again as banks struggle with liquidity issues, speculated to be caused by the current longest-ever historical US government shutdown.

It's Not Umbraco

And then one day, all of the sudden, you're just tired. Real, fucking, tired.

Inflation is silently stealing our live, breaking our spirits, and it's extremely unfair.

Regularly Expressed Regular Expressions

Thu, 06 Nov 2025 01:42:38 Z

Examples of common or useful regular expressions I've created over the years.

Useful expressions

I'll keep coming back to this blog post as I create more, so it might be worth a bookmark!

The regular expressions that start with ^ (start of string/line) and end with $ (end of string/line) will ensure the whole string matches. This is useful for validating a string is in the format you expect. To find a string in the format you expect inside another string, these can be omitted.

Most of these regular expressions can be changed to the other method simply by adding/removing the ^(start of string/line) and $ (end of string/line) characters at the start and end respectively.

GUID

Validate a string is a GUID

^(?:$(?=.*$)|{(?=.*}))?[a-fA-F0-9]{8}(?:-(?=(?:.*-){3}))?(?:[a-fA-F0-9]{4}-?){3}[a-fA-F0-9]{12}(?:\)(?<=\(.*)|}(?<={.*))?$

Open in RegExr

Matches guids in most formats that .NET's Guid.Parse can handle (except 0x format), is case insensitive, dashes and brackets are optional, but brackets must match.

Replace a GUID inside a longer string

As above without leading ^ and trailing $.

Find inside a longer string

[a-fA-F0-9]{8}(?:-(?=(?:.*-){3}))?(?:[a-fA-F0-9]{4}-?){3}[a-fA-F0-9]{12}

Open in RegExr

This one is simpler as it doesn't need to worry about the brackets - we're looking for the bare minimum that constitutes a GUID.

YouTube URLs

https?:\/\/(?:www.)?(?:(?:youtube.com\/(?:v\/|embed\/|watch\?v=|\&v=))|(?:youtu.be\/))([^#\&\?\s]+)\S*

Open in RegExr

Will match many forms of YouTube URL (default, short links, embed). The first group in the match will be the video ID which can be used to construct an embed URL.

Vimeo URLs

Open in RegExr

With thanks to Mike Masey for the starting point of this one.

Announcing Umbraco Scotland!

Wed, 05 Nov 2025 18:36:13 Z

https://www.linkedin.com/posts/carole-rennie-logan-13227328_umbraco-scotland-linkedin-activity-7391889380203966464-5faA?utm_source=share&utm_medium=member_ios&rcm=ACoAAABj9KwBjr581HKBv-M3TbQu69Ia79rmfPw

No, you don’t need Lit, Vite, or TypeScript to Extend the Umbraco Backoffice

Wed, 05 Nov 2025 10:30:59 Z

One of the biggest misconceptions I see pop up regularly among developers who start working on the new Umbraco "Bellissima" backoffice for the first time is that they think you need a lot of scaffolding and an entire build pipeline to extend the Umbraco 14+ backoffice.

This makes it seem like arbitrary extensions to the backoffice are very hard, especially for backend developers who aren’t into npm and such.

I'm here to tell you that you don’t need to use Lit, Vite, or TypeScript if you don’t want to.

Why do so many developers think you need all that scaffolding?

For the most part, this is a documentation thing. Umbraco itself uses Lit, Vite, and TypeScript in its codebase, and as a result, most examples in the documentation are based on Lit. Also, the Setup your development environment article talks about setting up TypeScript and Vite, which reinforces that impression.

You might think it’s just a matter of better documentation, and although I agree that the docs could improve, the problem is actually a bit bigger.

A well-designed (and overly flexible) architecture

The funny thing is that biggest problem is that the backoffice architecture is really well designed. That sounds like a contradiction, but hear me out.

The backoffice is built to be flexible, extensible, and framework-agnostic. Because of this, there are actually very few hard requirements for extending it.

UI extensions (like property editors, buttons, or workspaces) must be web components.
Other extensions (like repositories or stores) must follow the requirements of their extension type.
And lastly, you need an umbraco-package.json file to register the extensions.

But that’s practically it.

This means that as long as you follow these basic rules, you can create your extension however you want. Yes, Umbraco uses TypeScript for their code, Lit for its web components, and Vite to bundle it all, but you don’t have to. You can use your own framework and bundler if you like, as long as your bundles use the ES module syntax.

No scaffolding? No problem

You can also use plain JavaScript and skip any compilation or bundling entirely. As long as the requirements are met. That means no npm packages, no build scripts, and no scaffolding.

So, there are many ways to go about this. And that’s what I mean when I say that the backoffice architecture is both a blessing and a curse: there are so many possibilities that it’s impossible to document every one of them.

That said, I also believe the documentation could do a better job at showing this flexibility. I’m part of the Umbraco Documentation Community Team, and I try to spread the message of this blog wherever I can.

When to use what

There’s no absolute right or wrong, but here’s my opinion:

Use plain JavaScript for small and simple things, like a block view or a small Tiptap extension.
For anything bigger, it’s worth investing the time to use TypeScript — it elevates the quality of your code and prevents bugs. Especially if you’re a C# developer, you’ll probably appreciate the strong typing.
Once you’re already using npm and build scripts, it’s just a small step to introduce Lit and bundle it with Vite.

In the end, it’s not that hard. I’m primarily a C# backend developer, and yes, the learning curve exists, but I can honestly say that the quality of my packages has improved significantly since adopting these tools.

I’d also recommend going with Lit for elements. The Umbraco source code and most examples use it, so unless you have a specific reason not to, it’s a good default.

Lit is lightweight and removes the most annoying parts of writing web components by hand.

Want to learn more?

Because I don’t want to bloat this blog with tons of examples, I’ll wrap up with a few useful links if you want to dive deeper:

I recently rewrote the documentation on the extension registry, which hopefully makes things a bit clearer.
For the Umbraco Autumn Contribution Challenge 2025, I created an example showing how to register a custom condition to an existing extension. The example illustrates three different approaches (with the same result): vanilla JavaScript, TypeScript without bundling, and Lit + Vite. You can find it on GitHub.

In short: you don’t need all the scaffolding to extend Umbraco’s backoffice, but knowing how to use it can make your life a lot easier.

No, you don’t need Lit, Vite, or TypeScript to Extend the Umbraco Backoffice

Wed, 05 Nov 2025 10:30:59 Z

Why do so many developers think you need all that scaffolding?

You might think it’s just a matter of better documentation, and although I agree that the docs could improve, the problem is actually a bit bigger.

A well-designed (and overly flexible) architecture

The funny thing is that biggest problem is that the backoffice architecture is really well designed. That sounds like a contradiction, but hear me out.

The backoffice is built to be flexible, extensible, and framework-agnostic. Because of this, there are actually very few hard requirements for extending it.

UI extensions (like property editors, buttons, or workspaces) must be web components.
Other extensions (like repositories or stores) must follow the requirements of their extension type.
And lastly, you need an umbraco-package.json file to register the extensions.

But that’s practically it.

No scaffolding? No problem

You can also use plain JavaScript and skip any compilation or bundling entirely. As long as the requirements are met. That means no npm packages, no build scripts, and no scaffolding.

When to use what

There’s no absolute right or wrong, but here’s my opinion:

Use plain JavaScript for small and simple things, like a block view or a small Tiptap extension.
For anything bigger, it’s worth investing the time to use TypeScript — it elevates the quality of your code and prevents bugs. Especially if you’re a C# developer, you’ll probably appreciate the strong typing.
Once you’re already using npm and build scripts, it’s just a small step to introduce Lit and bundle it with Vite.

Want to learn more?

Because I don’t want to bloat this blog with tons of examples, I’ll wrap up with a few useful links if you want to dive deeper:

I recently rewrote the documentation on the extension registry, which hopefully makes things a bit clearer.
For the Umbraco Autumn Contribution Challenge 2025, I created an example showing how to register a custom condition to an existing extension. The example illustrates three different approaches (with the same result): vanilla JavaScript, TypeScript without bundling, and Lit + Vite. You can find it on GitHub.

In short: you don’t need all the scaffolding to extend Umbraco’s backoffice, but knowing how to use it can make your life a lot easier.

Learn to secure your Umbraco website with best practices for 2026

Wed, 05 Nov 2025 09:14:36 Z

Learn to secure your Umbraco website with best practices for 2026

Limbo.Umbraco.Skyfish 13.0.2

Tue, 04 Nov 2025 13:28:40 Z

Video picker for inserting Skyfish videos in Umbraco.

Volunteers to MC at Umbraco Spark wanted

Tue, 04 Nov 2025 08:39:27 Z

We’re on the lookout for volunteers to MC at Umbraco Spark! 🎤🔥 What’s in it for you? 🎟️ FREE ticket to the event 🎁 A unique gift! Your duties include: ✨ Kicking off each session with enthusiasm ⏰ Keeping things on schedule and ensuring everything flows smoothly 👏 Concluding with thanks and building anticipation for what's to come. It's simple, enjoyable, and we’ll provide a detailed briefing and support calls! 🧡 Interested? Contact us at umbracospark@gibedigital.com

Skrift Issue #122

Tue, 04 Nov 2025 00:00:00 Z

Featuring guest posts by Michaël Latouche on "The Umbraco Community Teams Visits: The Outcome of a Successful Open Source Collaboration" and Nora Lahl on "The Four Causes of Content Debt and How to Fix Them Before Your Next Rebuild"

When the Umbraco Community responds.

Tue, 04 Nov 2025 00:00:00 Z

When the Umbraco Community responds.

Tue, 04 Nov 2025 00:00:00 Z

When the Umbraco Community responds.

Tue, 04 Nov 2025 00:00:00 Z

When the Umbraco Community responds.

Tue, 04 Nov 2025 00:00:00 Z

Growing Together: Umbraco Expands into Australia and New Zealand

Tue, 04 Nov 2025 00:00:00 Z

Umbraco expands into Australia & New Zealand, bringing local leadership, support, and flexible digital experiences to the APAC region.

UmBootstrap 17.0.0-rc1 released

Mon, 03 Nov 2025 09:56:45 Z

Released Today UmBootstrap 17.0.0.-rc1 https://www.nuget.org/packages/Umbraco.Community.Templates.UmBootstrap/17.0.0-rc1

Request Protect v1.3.1 released including CIDR support for IP whitelisting

Mon, 03 Nov 2025 09:26:48 Z

We’ve released Request Protect v1.3.1 for .NET projects. This update introduces CIDR support for IP whitelisting and lets you customise the access-denied response-giving you more control over how your environments stay protected. AI Summary: Request Protect provides flexible IP whitelisting, URL pattern matching, and query string authentication to help safeguard staging sites and preview environments. Get the latest version now on NuGet: https://www.nuget.org/packages/Moriyama.RequestProtect https://www.nuget.org/packages/Moriyama.RequestProtect.Umbraco #PackageUpdate

Has the Umbraco Community lost it's Spark?

Mon, 03 Nov 2025 00:00:00 Z

Has the Umbraco Community lost it's Spark?

Mon, 03 Nov 2025 00:00:00 Z

Has the Umbraco Community lost it's Spark?

Mon, 03 Nov 2025 00:00:00 Z

Has the Umbraco Community lost it's Spark?

Mon, 03 Nov 2025 00:00:00 Z

Portland, Oregon Meet-up group launches their first Meetup event

Fri, 31 Oct 2025 18:41:35 Z

Portland, Oregon Meet-up group: Hello UMB.FYI team - We are excited to share that we are working on creating a strong community presence in Portland, Oregon. Our first event "Open for Business: How Open Digital Platforms Fuel Innovation and Profitability” is on November 18th and features Mats Persson. Allen Smith recommended I get in touch to see if it’s an event that can be promoted? I’m happy to craft any kind of message needed. For more context, you can view our meet-up event page, or you can view this landing page: https://www.meetup.com/open-digital-pdx/events/311677037/?eventOrigin=group_upcoming_events https://www.wearediagram.com/event/umbraco/open-for-business-portland Thanks so much for your consideration! Allison Casey Digital Marketing Director / Co-Owner [A black background with letters Description automatically generated] acasey@wearediagram.com https://www.wearediagram.com/ [signature_1342719604]   [signature_315527351]   [signature_2219419470]

umbraCoffee - Spooky Season

Fri, 31 Oct 2025 09:57:34 Z

Welcome to your monthly dose of #umbraCoffee! Your hosts - Marcin and Callum - together with their guest(s) will drive through all of the community news and happenings in the Umbraco world. So... grab a cuppa, join us LIVE and enjoy! See ya?! --- ☕ Wanna buy us a coffee/pizza/donuts? https://www.buymeacoffee.com/umbracoffee --- Notes: // TODO

uSkinnedSiteBuilder.StarterKit.TheEstate

Fri, 31 Oct 2025 00:00:00 Z

Responsive Starter Kit & Theme design add-on for uSkinned Site Builder demonstrating a fictional website for a luxury countryside Estate Hotel.

Limbo.Umbraco.TwentyThree 13.0.3

Thu, 30 Oct 2025 16:29:04 Z

Video picker for inserting TwentyThree videos in Umbraco.

umbPublisher 1.2.0 is now available

Thu, 30 Oct 2025 15:20:08 Z

umbPublisher 1.2.0 is now available. Some major code refactoring and a new settings interface to make it easier to setup and use. What is it? Do you use Obsidian and Umbraco? Would you like to push your notes to Umbraco as content? This is what this plugin does for you :) Want to see it in action? Come to my talk at #UmbracoInTheCity next week. #umbraco #obsidian

Umbraco 17: Release Candidate

Thu, 30 Oct 2025 00:00:00 Z

WordPress vs Joomla vs Umbraco — Which is Best CMS for Your Website?

Tue, 28 Oct 2025 09:52:52 Z

Choosing the best content management system can help you build and manage a successful website smoothly. The CMS plays a pivotal role in…

Continue reading on Medium »

Limbo.Umbraco.TwentyThree 13.0.2

Tue, 28 Oct 2025 08:41:15 Z

Video picker for inserting TwentyThree videos in Umbraco.

UmbracoSpark seeking volunteers to MC at the 2026 event

Tue, 28 Oct 2025 00:01:00 Z

Join the Open Circle Discussion 6th November before Umbraco in the City Manchester

Tue, 28 Oct 2025 00:01:00 Z

Umbraco Tees Day happening this FRIDAY

Mon, 27 Oct 2025 16:17:42 Z

To mark 1 week until #UmbracoInTheCity - there is a special Umbraco Tees Day happening this FRIDAY! Share photos of you in your Umbraco Swag and use the tag #UmbracoTeeshttps://isitumbracoteesday.today/

Build Faster with Two New Starter Kits for Trades and Events

Mon, 27 Oct 2025 11:32:27 Z

Learning TDD by doing: Acceptance testing with Umbraco's management API

Mon, 27 Oct 2025 10:00:00 Z

Remember: 🔴 Red, 🟢 Green, ♻️ Refactor

In my previous post I speculated about end-to-end testing with Umbraco's management API. I have tried it out and I can confirm that it works! In this post I will dive into what I wanted to achieve, how I did it and what challenges I faced along the way.

The goal

My goal was to automate content scenarios in order to provide a consistent initial state for acceptance tests. The result should be a suite of tests that interact with the website like an end user would.

If you want to skip straight to the end result: check out my github repository with testing examples. I shared all my code there.

D-Inventor / automated-testing-in-umbraco

A working example of integration- and unittests with Umbraco. A demonstration of various concepts for testing your Umbraco website

Umbraco 16 automated testing setup

This project is a fully functioning setup for automated testing with Umbraco 16. You can use this project as a reference or starting point to get started with testing on your Umbraco website. The tests are set up with Test Driven Development (TDD) in mind.

Tools

The most important tools that are used in the automated tests are as follows:

Name	Description
xUnit v3	The testing framework. You can use any testing framework that you like though
NSubstitute	Library for mocking. Any mocking library will work. This project doesn't do extensive mocking, but for example `IPublishedValueFallback` is a mandatory parameter for any published content item, even if you don't actually use it. It's just convenient to insert a mock.
Test Containers	Automatically creates docker containers while running tests. It is used to create an empty SQL Server database that is automatically cleaned up after testing.

…

View on GitHub

The journey

There were two steps to my plan: First, I created a client that could communicate with Umbraco's management API. Then, I built an interface on top of the client, so that I could describe the different kinds of content in easy-to-use models. I also created a small website to create a realistic test-case to use these tests on.

Step 1: Management API Client

Umbraco's management API is the interface that the Umbraco backoffice communicates with when you edit content. It is built with external integrations in mind.

To create the API client, I used NSwagStudio. With this tool, I can consume the OpenAPI spec that Umbraco exposes and automatically generate a C# client. Although it didn't go perfectly, the generated client was very usable and Umbraco appears to have designed very nice and clear models and endpoints. The generated C# code couldn't compile right away, because for some reason it depended on a type FileResponse, which doesn't exist. Fortunately, creating an empty class was enough to make it work.

NSwagStudio does not generate the authentication code, so I had to extend the generated client to include authentication. This was easy enough with Umbraco's documentation on external access. After this, I was able to write a crude script that could access the backoffice and produce some basic content items.

Step 2: A layer of convenience

The client works, but preparing a scenario using the Management API Client alone takes a lot of code. My goal was to be able to describe a scenario in code the same way as I would describe it to a coworker. So before I got to work, I wrote down some example sentences that I would use to describe a test scenario:

Given a content page with a tag, when I go to the page, I see related content with the same tag.
Given a content page with the content from our figma design, when I go to the page, I see the page just like in our design
Given a news overview with many news articles, when I load more articles, I see the next N articles

I designed a test that would describe a simple scenario:

[Fact]
public void ShouldDisplayTitleFromContent()
{
    // given
    var contentPage = Scenario
        .WithContentPage()
        .WithHeader(title: "My content page");

    // when
    User.Visits(contentPage);

    // then
    Assert.Equal("My content page", CurrentPage.Title);
}

The focus here was to get the 'given' part working. I used test-driven development to design and build this scenario builder. The tests that I wrote are included in the github repository, so you can have a look at those if it interests you. The fun thing about test-driven development is that a test makes me think about how I'm going to use the code that I'm about to write.

In the end, I didn't get exactly the design that I wanted, simply because "I want content with a header" is too vague, but I did get close. The test above ended up looking like this:

[Fact]
public async Task ShouldDisplayTitleFromContent()
{
    // given
    Scenario.Homepage()
        .HasContent(Variation.Invariant, content => content.WithHeader(title: "Welcome to the website"));
    await Scenario.BuildAsync(TestContext.Current.CancellationToken);
    var homepage = new HomePageObject(await Browser.NewPageAsync(), Scenario.Website());

    // when
    await homepage.GoToAsync();

    // then
    await Expect(homepage.Title).ToHaveTextAsync("Welcome to the website");
}

Instead of saying "The homepage has a header", it now says "The invariant content of the homepage has a header". It's a bit longer, but also more explicit. It also allows you to specify cultures and variants. Very useful when you want to test multilingual sites or if you use segments to personalize content. Additionally, I couldn't get around an explicit call to BuildAsync, because I need a trigger to actually make the changes.

Challenges / difficulties

Here are some of the things that surprised me, some things that I found difficult and some roadblocks that I came across while developing this.

Visual regression testing? Yes, but not in dotnet

The biggest challenge and also my largest surprise, was the fact that there don't seem to be any visual regression testing tools available for dotnet. Playwright for example supports comparing screenshots in the version for javascript / typescript, but does not support this for its dotnet version. I had no plans to create my own visual regression testing tool, so I had to give up. It might have been better to create my scenario builder in javascript / typescript, in retrospect.

This was somewhat disappointing for me. In my team at work, it is very important that our websites look like the designs that we make upfront. One of our success criteria is that we can recreate the design using content in Umbraco. Being able to match a browser screenshot with an export from our design software would have been very valuable.

Domains in Umbraco didn't quite work

Just before writing this blog, I submitted a bug report to Umbraco, because it appears that Umbraco has a stale caching layer on top of their domain service. When I ran the tests more than once or on multiple scenario's, I would run into bad status codes because the domain was reserved for the content of the previous scenario, even though that content was deleted.

I worked around this issue by creating my own custom endpoint in the management api. A sort of "delete everything" endpoint that deletes all the content in the content tree and makes sure that domains are deleted explicitly first. Although it's not ideal, it's a workable solution and shows how flexible the system as a whole is.

Content is inherently complex

My example on GitHub and the example code above is simple on purpose. String values are easy to model. But how do you model related media? Images with crops? What about a blocklist? These types of content are inherently complex and there is no single best answer. Blocklists have quite complex rules, take this article in the Umbraco documentation about block-level-variance for example. Media has its own section in the backoffice and introduces an additional external dependency: the filesystem. Do I need to recreate all media items on every test as well? Or maybe I can simply reserve a set of media items in the backoffice and reuse them? It really depends on your use-case and I haven't quite figured this out for myself yet.

Layers and abstractions

I found it difficult to assign clear responsibilities between the ScenarioBuilder and the DocumentClient. I had a gut-feeling that somewhere here is supposed to be a "repository". Intuitively, the ScenarioBuilder seemed to play the role of repository, because it translated domain models into DTOs for the management api, but after building everything, the IDocumentClient ended up looking more like a repository than the ScenarioBuilder. In the end, I couldn't really make a proper case for either, so neither of these types turned into a repository. This once again shows how test-driven development helps you make better design choices. I didn't need a repository, so I didn't make one.

final thoughts

Most of all, I'm very excited that I managed to make it work. I have to admit that without visual regression testing, I'm not exactly sure how I'm going to use this technology. That doesn't mean that it's useless though. I feel like there is a lot of potential and I am very happy with how easy everything turned out to be.

Please check out my repository in GitHub with testing examples. It includes everything that I talked about in this post. Let me know your thoughts: do you have extensive test suites for your Umbraco sites? What kind of tests do you find most valuable?

Thank you for reading and I'll see you in my next blog! 😊

Running Umbraco on a Fairphone 5

Sun, 26 Oct 2025 14:31:37 Z

Visualise Document JSON in Umbraco Content section

Fri, 24 Oct 2025 19:14:23 Z

Limbo.Umbraco.MediaPicker 13.0.1

Fri, 24 Oct 2025 09:34:11 Z

Umbraco package that extends the functionality of Umbraco's build-in media picker property editor.

Composable Regrets: Lessons From the First Wave

Fri, 24 Oct 2025 00:00:00 Z

Rivlo.FriendlyMembers

Fri, 24 Oct 2025 00:00:00 Z

Friendly Members — handy member management utilities for Umbraco 13.

Umbraco Cms 16.3.3 released

Thu, 23 Oct 2025 23:01:00 Z

Finding the Right Path: Getting More Involved in the Umbraco Community

Wed, 22 Oct 2025 00:00:00 Z

Limbo.Umbraco.Skyfish 13.0.1

Tue, 21 Oct 2025 18:00:05 Z

Video picker for inserting Skyfish videos in Umbraco.

DigitalWonderlab.MultiDomainEmail

Tue, 21 Oct 2025 00:00:00 Z

Streamline multi-domain umbraco forms submissions with domain-specific SMTP and reCAPTCHA configurations. The ultimate solution for multi-site Umbraco installations, designed specifically for agencies managing multiple client sites.

Umbraco Technical Writers Group returns 28th October

Mon, 20 Oct 2025 16:46:20 Z

UmBloggers - Umbraco Technical Writers Group - returns with a co-writing event! Tuesday 28th October, 6:30pm GMT. We'll be writing, then discussing, then writing, then discussing - all as a group, supporting one another's ideas. I'd post the Meetup link but AWS Things. #technicalwriting #writers

Write for 24 Days In Umbraco

Mon, 20 Oct 2025 07:52:26 Z

Have you built a great extension for #Umbraco? Or maybe you tried but failed miserably? Think anyone else could learn something from that process (spoiler: they can!) — write it up in an article for this year's 24 Days In Umbraco - apply here: https://24days.in/umbraco-cms/write-for-us/

Limbo.Umbraco.RecycleBin 13.0.1

Mon, 20 Oct 2025 07:45:41 Z

Limbo.Umbraco.RecycleBin is small package for Umbraco that takes out the trash.

Mix and match search providers

Mon, 20 Oct 2025 00:00:00 Z

A tutorial showcasing how multiple search providers can run simultaneously with Umbraco Search.

Umbraco.Commerce.Portal

Sat, 18 Oct 2025 00:00:00 Z

A drop in customer portal for Umbraco Commerce.

Umbraco upgrades – Bump Digital

Fri, 17 Oct 2025 07:09:26 Z

Umbraco upgrades – Bump Digital - YouTube

UmbAnchorPoint

Fri, 17 Oct 2025 00:00:00 Z

A property editor for easily managing css/flex alignment via 9 anchor points

Rivlo.Licensing.UI

Fri, 17 Oct 2025 00:00:00 Z

Add-on for Rivlo Licensing, providing UI elements for displaying licence status.

Rivlo.Licensing

Fri, 17 Oct 2025 00:00:00 Z

Reusable licensing validator for Umbraco packages, with support for domain, version and expiry checks.

UmbNav V4.0.0-beta for Umbraco V17

Thu, 16 Oct 2025 16:56:54 Z

What's that I spy... UmbNav for #Umbraco V17? Yes, in deedy 😁 Grab #UmbNav V4.0.0-beta0052 here: www.nuget.org/packages/Umb...

Limbo.Umbraco.MultiNodeTreePicker 13.0.2

Thu, 16 Oct 2025 13:09:33 Z

Umbraco package that extends the functionality of Umbraco's build-in Multinode Treepicker property editor.

Limbo.Umbraco.FilterList 13.0.0-alpha002

Thu, 16 Oct 2025 12:59:41 Z

Umbraco In The City: Manchester is SOLD OUT

Thu, 16 Oct 2025 08:54:45 Z

🎉 We’re SOLD OUT! 🎉 Umbraco In The City: Manchester is full to the brim. 10 incredible talks. 80 amazing attendees. It’s gonna be a proper good one. 📍 7 Nov · x+why Manchester #UITC #Umbraco #MCRTech #WebDev

Applications for CODECABIN 2026 in the US are now open

Thu, 16 Oct 2025 08:29:23 Z

Feeling nostalgia for CodeCabin already or want to find out firsthand what the ultimate Umbraco retreat is all about? Applications for CodeCabin 2026 are now open! For the first time ever, join us in the US! Spots are limited; submit your application now! codecab.in #codecabin #h5yr #umbraco

DigitalWonderlab.CountThings

Thu, 16 Oct 2025 00:00:00 Z

A friendly Umbraco backoffice dashboard that shows counts of content, media, users, schema, forms and more.

UmbNumericDropdown

Thu, 16 Oct 2025 00:00:00 Z

A property editor that combines numeric + dropdown into one

The Umbraco 17 Beta is here

Wed, 15 Oct 2025 09:20:24 Z

🚀 The #Umbraco 17 Beta is here! And we can’t wait to get your contributions💪👉 Read the blog for all the details (and how to access the Beta): https://umbraco.com/blog/umbraco-17-beta-is-out/

Umbraco 17: Ready, Reliable, and Less Scary than It Sounds

Wed, 15 Oct 2025 00:00:00 Z

uProfile October 2025 - Helen Chaplin

Wed, 15 Oct 2025 00:00:00 Z

Meet Helen Chaplin — a passionate sustainability advocate and avid world traveller

SPECKL: Testing a Human-First Approach to AI-Assisted Development

Tue, 14 Oct 2025 14:14:01 Z

Umbraco launches new releases.umbraco.com

Tue, 14 Oct 2025 14:13:43 Z

🚀 New site launch!We’ve replaced the old Download section on Our Umbraco with the shiny new https://releases.umbraco.com!The new home for Umbraco releases — everything works again (including Compare 🎉) and old links redirect smoothly.Soon to be open source 👀#Umbraco

Taking Stripe Payments in Umbraco Commerce

Tue, 14 Oct 2025 09:56:20 Z

Umbraco Spark Call for speakers is now open!

Tue, 14 Oct 2025 07:54:37 Z

🚨 Call for speakers is now open! Join us at Umbraco Spark in Bristol on March 20, 2026. We're looking for tech enthusiasts eager to push the boundaries of the Umbraco CMS💥 👉 Share your insights: https://sessionize.com/umbraco-spark-2026/ #UmbracoSpark #Umbraco

[Breaking change]: Removal of backoffice tours

Tue, 14 Oct 2025 04:47:56 Z

[Breaking change]: Removal of `BackOfficeDevelopment` runtime mode and `InModelsBuilder` models builder mode due to deprecation of Razor runtime compilation support in .NET

Tue, 14 Oct 2025 04:42:03 Z

Exploring GitMCP with Umbraco Repositories

Mon, 13 Oct 2025 20:30:00 Z

GitMCP lets you connect public GitHub repositories directly to AI tools like GitHub Copilot, Claude, Cursor, and VS Code MCP clients. In this article, I show how to use GitMCP with the Umbraco source code so you can ask AI real questions based on rea...

Umbraco Session Timeout Configuration and Security

Sun, 12 Oct 2025 12:00:00 Z

Sometimes even the simplest settings deserve a second look. Umbraco’s session timeout appears straightforward in the documentation, but I decided to investigate what actually controls it and how far it can be safely tuned.

Missing umbracoExternalLogin Data After Migration in Umbraco 13

Fri, 10 Oct 2025 12:00:00 Z

During a migration from Nested Content to Block List in Umbraco 13, I noticed that the `umbracoExternalLogin` table had suddenly become empty. The reason turned out to be missing external login provider settings in my local `appsettings.json`. In thi...

UMB.FYI Firehose - News

ProWorks.Umbraco.AI.PageEvaluator

File Uploads in Umbraco.AI

Our.Community.Tags.Popular

Umbraco Cloud testimonials

ProWorks Umbraco AI Page Evaluator

Indexing Word, Excel and PowerPoint Documents in Umbraco Using Examine

Meet the nominees for the Umbraco Awards 2026!

Why Umbraco 17.4.0 Is a Big Deal for AI

Announcing the 2026 Umbraco Awards Nominees 🏆

Skrift Issue #126

SplatDev.Umbraco.Plugins.Schema2Yaml

Skybrud.Umbraco.Redirects 17.0.4

Umbraco Spark 2026 is a wrap!

Umbraco AI Prompts: Template Syntax and Variables

[Breaking change]: Casing on EF Core code constructs

Our.Umbraco.PostgreSql

Umbraco.Community.Examine.OpenXml

Umbraco Spark 2026

Merchello v17 Starter Site Template now available

AI agent workflows sneak peek

Finding my Spark through Community

V17 of IconPicker has been released

Live from Spark 2026: AI, Play and the Human in the Loop

uTPro.Feature.FileManager

Phases.Umbraco.Community.Tiptap.Rte.Emoji

Umbraco.Community.TipTap.MarkdownImport

Optimizing Umbraco Member Pagination From Slow to Lightning Fast

Umbraco.Community.DataTypeCleanup

Searching file content with Umbraco Search

SplatDev.Umbraco.Plugins.Yaml2Schema

Umbraco.Community.EnvironmentIndicator

Content Lock 17.1.0 - aka the WebRTC Audio Calling edition

umbraCoffee - Spring Sips

Umbraco.Community.PropertyInfo

uTPro.Feature.AuditLog

Understanding Contexts in Umbraco AI

Early concepts for Reuse Content of Blocks

Modgift.Umbraco.CronInput

Announcing the Umbraco in AI Community Team & the AI in Umbraco Advisory Board

Building an AI-Powered Log Analyser for Umbraco at the Spark Hackathon

Rescope.ContentDelivery

Umbraco.Community.UpDoc

Rescope.uAstro

MetaMateAI

GitKraken CLI Beginner's Guide: A Better Git CLI for Developers

Umbraco In Action - Introduction to CMS for students

Conzent.Umbraco

Modgift.Umbraco.DataGrid

Umbraco.Community.DeliveryApiModelMapper

Growcreate.SchemaGenerator.DeployAddon

Jumoo.TranslationManager.Cleanup

Growcreate.SchemaGenerator.uSyncAddon

Umbraco.Community.AI.LogAnalyser

Growcreate.SchemaGenerator.Core

Developer’s Guide to Creating a Custom Umbraco 17 Backoffice Dashboard

Setting Up a New Umbraco Package Dev Environment with Umbraco.AI

Prerequisites

Step 1: Install the template

Step 2: Scaffold the solution

Step 3: The Linux/macOS gotcha -- setup.cmd won't run

Step 4: Build the frontend & verify the base site

Step 5: Add the Umbraco.AI packages

Step 6: Add the seed demo data

API key (optional)

Step 7: Run and verify

Step 8: Make the initial commit

What's next

Umbraco.Community.AI.PropertyValidation

Kraftvaerk.Umbraco.Alchemy

Growcreate.SchemaGenerator

OC.PowerSort

OC.PowerSort package

The Call for Speakers for UMBRAAD 2026 is open!

Getting Started with Umbraco AI

OC.UFMFallbacks Package

Umbraco.Community.JobsJobsJobs

OC.UFMFallbacks

Umbraco Recognized as a G2 Leader Across CMS and Headless in the Spring 2026 Reports

The Umbraco Playground — Experiment, build, and share 1

Step 3: The Linux/macOS gotcha -- `setup.cmd` won't run