Xperience by Kentico at 20,025 Feet - Part 3
This is part 3 of the Xperience by Kentico at 20,2025 ft. blog post series. Make sure to read part 1 and part 2 first!
Introduction
Imagine flying in a jet at 20,025 feet as a developer, and the cabin lights come back on at full strength. The flight is now almost over. At this point, most pilots realize that in any flight, the landing is where all the preparation, technology, and precision come together. Similarly, Xperience by Kentico brings developers in for a smooth technical landing with its suite of cutting-edge technology and updated multichannel features, ensuring that every project is built to perform at its best. Most importantly, it offers a best-in-class developer experience, making working on this next-generation platform from Kentico feel like a breath of fresh air.
.NET 8 Support and the Final Approach to .NET 9
Flying and landing a modern aircraft requires the latest avionics, and with .NET 8 support (and soon .NET 9), Xperience by Kentico equips developers with the tools they need for building the most modern websites. Think of .NET 8 as a state-of-the-art navigation system; reliable, secure, and designed to guide you through turbulence-free skies. This is what Kentico has now standardized on for the foundation of Xperience. The solution was completely built from the ground up on modern .NET. Gone are the days of the legacy .NET Framework 4.x and WebForms 2.0.
With upcoming .NET 9 support on the horizon, Kentico ensures that the platform evolves seamlessly alongside the latest technology. In fact, because of modern .NET and the way it works, the update to all future .NET versions 9,10, or 11 will be somewhat easy for Kentico to do. It’s why the rewrite was so critical to making Xperience state-of-the-art.
If you have seen me speak at the annual Kentico conferences in Miami or Nashville, or listened to any of my recent interviews on YouTube or LinkedIn with Kentico, you know this is a huge deal. What modern .NET ultimately boils down to is speed and performance. Xperience by Kentico is fast, super-fast actually, and modern .NET is why.
APIs: New Avionics for a Modern Cockpit
After the re-write in modern .NET, the next biggest change to Xperience is the actual code itself. The updated APIs in Xperience by Kentico are like swapping out an older cockpit with updated avionics. Compared to Kentico 13, these APIs are actually drastically different. The new APIs need to be different though. That is because they need to support both channel specific content that is tied to a page, as well as re-usable content from the Content Hub.
Here’s how I like to explain it to developers with knowledge of legacy Kentico versions; There is no TreeNode APIs anymore. Let that sink in. There is no TreeNode.
The place to start learning about the new APIs is at the new Content item API. This documentation shows you how to build queries, run those queries, and map the results to strongly typed objects. You will end up using the ContentItemQueryBuilder quite a bit now. It is used to retrieve page content in Xperience and retrieve content items in Xperience.
After working with those APIs you can move on to reviewing the Object Query API and the and so on and so on.
Don’t forget that after modeling your content types and other system objects, you will want to be sure to get familiar with generating your code files using some of the new CLI tooling (more on that next).
After getting through the learning curve of the differences, I do feel that the APIs are more streamlined and intuitive, giving developers greater control and visibility, much like a pilot monitoring flight data with those newly installed latest instruments.
CLI Tools: Your Ground Crew
Landing safely requires collaboration, and the CLI tools in Xperience by Kentico act as your trusted ground crew. The new CLI tools are designed to provide developers with a streamlined and efficient development experience, leveraging the power of the .NET CLI. I’m assuming if you are reading this you are familiar with it, but if you are not go check out the Microsoft Learn page on .NET tools.
At the heart of these tool enhancements is .NET templates, which allow developers to kick-start their projects with ease. Kentico has embraced this and created multiple new .NET templates. The main one to use with Xperience by Kentico is:
dotnet new install Kentico.Xperience.Templates
After you install Kentico’s official templates by running that command at a terminal it enables project scaffolding tailored for Xperience by Kentico. These templates simplify the initial setup and ensure consistency across projects. There is a template for a self-hosted project as well as a template for a deploying to a Kentico SaaS environment.
But that’s just the start. The CLI tools also include powerful utilities like the new kentico-xperience-dbmanager. This tool offers developers a command-line interface for managing database operations, providing a faster and more flexible alternative to traditional UI-based approaches. From initializing databases to applying schema updates, this tool makes database management straightforward and efficient, reducing friction in the development process. It looks like this to install a new instance:
dotnet kentico-xperience-dbmanager -s -d -u -p -a --license-file (with params filled in)
These tools are perfect for CI/CD pipelines, where automation and scripting are key. Tasks like setting up environments or managing databases can be easily incorporated into scripts, reducing manual effort.
Updating your version of Xperience by Kentico also happens via CLI commands. This command is something you will use often. It’s how
dotnet run --no-build --kxp-update
You’ll also run a lot of the following commands for CI in Xperience by Kentico, but more about these later too.
dotnet run --no-build --kxp-ci-store
and
dotnet run --no-build --kxp-ci-restore
The result of running a command like kxp-ci-store:
Much like a pilot relying on ground crew coordination for a safe landing, developers can depend on these CLI tools to ensure a smooth development process. The ability to quickly scaffold projects, efficiently manage databases, and automate routine tasks frees developers to focus on the high-level architecture and functionality of their applications. The integration with the .NET CLI is a reflection of Kentico’s commitment to delivering a developer-friendly platform, ensuring that every flight—whether it’s a new project or a legacy upgrade—lands with precision and ease.
CI/CD Options: Navigating Multiple Runways
Just as a pilot might need to coordinate between multiple runways, developers often need to synchronize environments. The new Continuous Integration and Continuous Deployment (CI/CD) features in "Xperience by Kentico" enable precise serialization of database objects into XML files, akin to plotting out a perfect descent path. By integrating with Azure DevOps or GitHub, the Xperience platform ensures smooth transitions between environments—avoiding crosswinds that might disrupt deployment.
Today, the best practice for team development and/or projects where multiple environments are involved (such as localhost, development, and stage) is to use CI and NOT use a shared database. Yes, it is time to let go of shared databases. It is very much worth your time to invest in learning and using CI in Xperience by Kentico. It’s pretty much the only way that my team and I work at BizStream now.
One a developer creates an environment (their own database and codebase is spun up), they are going to want to enable CI so that Xperience starts tracking changes to the objects in the database as XML files in the filesystem. And to actually make sure the filesystem correctly represents the state of the CMS database, a developer would run the dotnet run --no-build --kxp-ci-store command to represent everything in the database as XML files in the filesystem. Those files can be placed into a commit in your source control system (with a whitelist and blacklist configuration to only pay attention to the files you want to share).
Then if another developer wants to update their local instance with the first developers “state” of the CMS, that new developer can retrieve the commit from the repo and run the dotnet run --no-build --kxp-ci-restore command to import all the XML files into the CMS database and update the state of the second database to match. It is a great way to share page content, object changes, and settings between developers. The same applies to keeping a testing environment up to date.
To be clear, this is not the CI we had in Kentico 13. Xperience by Kentico’s CI feature is fully rebuilt to handle this scenario much better, more accurately, and easier than before.
By contrast, a brand new feature of Xperience is the Continuous Depoloyment (CD) tool. CD allows you to automate deployments to different environments, specifically the content stored in the Xperience database. At a high level it works in three steps
First you would generate a CD repository and related config files via:
dotnet run --no-build -- --kxp-cd-config --path "C:\Project\_CDConfigs\Envionment\repository.config"
Then you would store objects to a CD repository via:
dotnet run --no-build -- --kxp-cd-store --repository-path "C:\Project \_CDRepository" --config-path " C:\Project\_CDConfigs\ Envionment\repository.config "
The above command would create a zip file that contains the state of your Xperience database. Lastly you need restore the CD repository to the target database via:
dotnet run -- --kxp-cd-restore --repository-path " C:\Project \_CDRepository "
One thing I really like about the CD feature is that it comes with a PowerShell script to handle deploying the zip file automatically as well (after some configuration edits).
This tool is meant again mostly for developers to use. It is not a replacement to the old Content Staging that was in legacy Kentico. A new, different tool is coming for that (hopefully in the next 6 months or less). It is meant for being using in your pipelines for automated deployments though. It’s also very useful in the SaaS model (and basically required).
Hosting in Azure App Services (Linux-based): Fuel Efficiency in the Air
Pilots always consider fuel efficiency and reliability when planning their flights, and hosting "Xperience by Kentico" on Azure App Services that are Linux-based delivers just that. This setup provides not only cost-effective scaling but also optimal performance; a critical factor when cruising at high altitudes. Azure's integration with other services acts like a co-pilot, ensuring every aspect of your hosting environment works seamlessly together. Platform as a Service (PaaS) is truly the way to go for Xperience by Kentico. There are very few reasons why in 2025 you would want to use a full virtual machine or IaaS for Kentico. This is something you could not do in legacy Kentico.
Also, gone is the two separate applications for MVC development in legacy Kentico. Because of modern .NET, the entire Xperience by Kentico application can now be deployed as just one project into one App Service. This is a really nice benefit of simplification and cost reduction.
Custom Modules with React: Building a Custom Control Tower
Just as airports rely on their control towers for coordination, developers will now use React to build custom modules in "Xperience by Kentico." This approach allows for modular, maintainable components. It is like having a bespoke tower to direct the flow of your digital project. The flexibility and responsiveness of React ensure that your applications are always ready for takeoff.
The new way to add customization to the administration side of the Xperience by Kentico is best described in the documentation. The key thing to remember though is that the administration consists of two main parts. The Client application – the front-end (client-side) part of the administration interface implemented as a single-page browser application using the React JavaScript library. It’s the GUI side. And the Back end, which sits in the ASP.NET Core web application as a set of API endpoints called by the client application. The back-end implementation is responsible for interacting with Xperience APIs and other business.
I would also recommend reading admin customization model overview to understand what options you have and don’t have for custom modules as it is much different than before.
The downside of this new change in Xperience is that all of your old admin facing custom modules built in Kentico 10, Kentico 11, Kentico 12, and Kentico 13 are not supported. They need to be rebuilt using the new model described above.
Migration to Xperience by Kentico from Kentico 13 (and everything else)
After landing we have to get that luggage out of the plane and into the terminal somehow right? The Xperience by Kentico Migration Toolkit is how that happens. The toolkit has a set of utilities that developers can use to migrate content from legacy Kentico or other CMS platforms into your new Xperience instance. I’m not going to cover that hear because we have other blog posts and resources on how to do that. Go check them out if you are interested, because they are very good. You can click on the digram to get to the tool in GitHub.
Conclusion
Ok, there are actually more technical differences and capabilities with Xperience by Kentico, but I feel like I have hit the biggest ones in this post. Plus, we need to finally finish this plane ride, it’s been a really long flight.
Landing a plane requires a balance of skill, technology, and teamwork—qualities that "Xperience by Kentico" mirrors in its technology stack. With these advanced features, you’re not just flying the plane; you’re landing it with confidence, precision, and a sense of achievement.
So, as you descend down from20,025 feet, the wheels have touched down on the runway, and we have taxied to our gate, you now know much more about "Xperience by Kentico". I hope you have enjoyed this high level view of how Xperience by Kentico is not just Kentico 14. It’s the forever version and new flagship from Kentico. The hybrid headless DXP that maximizes ROI, that solves the modernization and consolidation challenges that marketers face in 2025, and that developers love to use. Do you still have questions? Feel free to contact me about Xperience by Kentico at any time.
