Set your team up for success by deciding how your team will manage changes and collaborate before diving in.
In this approach, each developer has a local copy of the project's code, which is synchronized via source control, and their own copy of the database. Database changes are synchronized through Continuous Integration (CI). There is a continuous integration server (CIS) that monitors changes in source control. When changes are detected, the CIS builds and deploys code to an integrated testing environment.
In this scenario, manual merges may be necessary to resolve conflicts for both code and database changes.
The testing environment has its own copy of the database and is used for previewing and testing.
With this approach, each developer has a local copy of the code, which is synchronized via source control and uses a single shared database. Developers also use shared storage to keep content assets and other physical files synchronized. There is a continuous integration server (CIS) that monitors changes in source control. When changes are detected, the CIS builds and deploys code to an integrated testing environment.
In this scenario, open communication within the team is crucial whenever a developer makes changes to information stored in the database. Otherwise, different developers may overwrite each other's data changes.
Manual merges may also be necessary in the event of conflicts in the code.
The testing environment is also connected to the shared development database and media library storage, and is used for previewing and testing.
Regardless of the approach you take, you should use some form of source control to keep track of changes in the project and facilitate automated builds and even deployments.
There are a multitude of options for handling this, but Git is the most commonly used.
Beware that incorrect .gitignore settings could prevent specific CI files from getting into source control after they are generated by Xperience.
For example, the default "Visual Studio" .gitignore ignores *.user paths, which also match CI repository folders named after object types, such as cms.user. Keep the whole CI repository folder (~/App_Data/CIRepository by default) in source control, and ignore only the paths generated locally by Xperience and the build:
We recommend using User Secrets (opens in a new tab) to keep sensitive information like connection strings and API keys out of the application's settings.
Here are some example scenarios to demonstrate how different teams have chosen an approach in the past.
A development team found themselves working on several small projects that only warranted one or two developers per project. Generally, each developer would only work on one or two of these projects at a time, but occasionally they would help with some aspect of another project.
In order to limit the setup time for these one-off sub-projects, the team elected to use the centralized development approach, so they did not need to set up local copies of the database each time. The small number of developers working on a project at any given time facilitated easy communication about data changes.
In this case, a global company had multiple development teams in several countries.
In order to keep development running smoothly, they chose the distributed development approach, allowing local developers to operate independently. If they had chosen to have each developer connect to some centralized system, it would have been slow for one or more of the development teams.
This development department had two teams: one that primarily focused on back-end development and one that primarily focused on front-end development.
The front-end team didn't want to have local copies of the full site running on their machines, so they did their work locally in static HTML/CSS files and then replicated the changes directly in the integrated development environment. In order to prevent changes from being lost, they went with the centralized development approach; they didn't want to worry about committing changes from the integrated development environment into source control.
If your team has access to the relevant Xperience by Kentico knowledge, your project conventions, and your content model, then AI-assisted development tools can help you to work more effectively. The KentiCopilot includes MCP servers, curated skills and workflows, and best practices for AI coding assistants that are working on Xperience by Kentico projects.
Arrange this tooling as early as possible in the project so that all team members have the same starting point and achieve the same results. The agentify (opens in a new tab) skill assesses whether your project is ready for AI-assisted development and spots any missing agent instructions, development standards, and MCP server configuration. For information on how to set it up and details regarding the available KentiCopilot tools, such as the web development plugin (opens in a new tab), see the KentiCopilot overview.
Want to see KentiCopilot in action? Watch a short video that explains how AI assistants can help you build the Developer kickstart project. You'll see how KentiCopilot tooling accelerates common Xperience development tasks and helps automate much of the implementation work.
Save time and effort by encouraging your developers to remember key concepts like performance and security.
There are two sides to security. The first is related to properly configuring access to content and functionality for authorized users.
The second is making sure that hackers are not able to exploit flaws in the implementation to gain unauthorized access to content and functionality.
With Xperience by Kentico development, you need to consider the following:
Xperience's admin UI and APIs make it easy for you to secure your application by providing an easy to use interface, some automatic protections, and tools to make sure you are able to easily secure your code.
Find more information about how we approach security at Kentico and an overview of the product’s security features in the Security guidelines.
Many times, developers primarily focus on building something functional. This can lead to scalability issues, higher running costs, and dissatisfied users.
Xperience by Kentico does a lot of optimization automatically, and provides many ways to improve your project's performance with features like:
It's important to note that while Xperience does a lot of things automatically, it can be very easy to introduce performance issues. Here are a few practices to keep in mind as you develop:
When building something new, you need to consider what it depends on (data structures, third-party APIs, etc.) and what will depend on it (templates, custom modules, etc.).
It is important to plan how what you are building will interact with its dependencies in order to avoid re-work or extra effort. This is also important when considering how to deploy new features/functionality down the line.
Some examples of dependencies to think about in Kentico Xperience include:
If your solution integrates with decoupled external systems, plan messaging infrastructure as an explicit dependency from the start. Xperience does not include a built-in integration bus or message broker, so you need an external messaging service.
Whether the project will be maintained by the same team or not, implementations should be created with future maintenance in mind.
If something is built sloppily the first time, maintenance can be exponentially more costly. It is important to consider every aspect of what you are developing when it comes to maintainability.
For example, you will want to pay attention to some of the following things in Xperience:
This applies to both editors and visitors. Your solutions should be built with ease of use in mind. Your editors will have an easier time keeping the site up to date, and your visitors will be more engaged.
Some examples of how you can create a good experience for editors and visitors are:
Projects are very rarely built once and never extended. Thinking about how a feature might need to be enhanced in the future can help save effort and time in the future.
However, do bear in mind that there is a need to balance the effort/time with the project's budget/timeline. Be sure to think about:
Consider using Xperience's built-in extensibility points to help with this process:
The next guide in this handbook covers the Testing phase of your project. It discusses what to consider when testing the functionality and performance of your site.