Managing content changes in Kontent.ai: A technical perspective

Content management systems need to excel at handling change. Whether it's updating performing a site rebuild, restructuring your navigation, or rolling out a complete rebrand, your technical infrastructure needs to support these changes efficiently and reliably.

In this article, we'll take a look at three capabilities in Kontent.ai that work together to make content change management more effecient: enhanced webhooks, the new used-in API call, and improvements to our sync API. These features form a robust toolkit that helps developers build more responsive, efficient content applications.

We also sat down with our Developer Experience Product Manager, Rostislav Striz, for a conversation about these features and how they help developers. You can watch the full conversation below.

Enhanced webhooks: Greater control and reliability

Webhooks have long been a staple for developers integrating Kontent.ai with other systems. Our enhanced webhook system, released last year, brings significant improvements over the legacy implementation, with improvements focused on giving developers more control while reducing unnecessary overhead.

Key upgrades over legacy webhooks

• More predictability. The enhanced webhooks watch for changes in individual objects only, eliminating dependencies that previously caused performance bottlenecks. This architecture ensures greater reliability of notifications due to more granular contracts.
• Additional entities. The enhanced webhooks are now available for assets as well, and it’s easier to distinguish which entity was the source of a change (e.g. a content type, taxonomy, etc.).
• Enhanced filtering. One of the most requested features, enhanced filtering gives you granular control over which notifications you receive. Rather than processing every content change, you can now specify exactly what events trigger webhooks. This filtering capability significantly reduces noise in your logs and prevents unnecessary processing, allowing your applications to focus only on relevant changes.
• Technical improvements. The webhook delivery system now features improved performance with faster delivery times and more reliable scaling during traffic spikes. We've rebuilt the infrastructure to handle increased volumes while maintaining consistent delivery SLAs.

What’s the impact?

These enhancements directly address common pain points we've heard from customers:

• Reduced noise: Cleaner logs and no more sifting through hundreds of webhook notifications to find relevant ones
• Lower processing overhead: Your applications only process the events they care about
• More focused rebuilds: Only update or rebuild what needs to change

By implementing more granular control over webhook notifications, we've made real-time content change management more efficient and developer-friendly.

Used-in API call: Track content relationships with precision

Content rarely exists in isolation. Understanding how content items relate to one another is crucial for maintaining consistency and managing updates efficiently. Our new used-in API call addresses this challenge by providing a clear view of content relationships.

What is the used-in API call?

The used-in API call enables you to quickly discover all of the places where a particular content item is referenced. This is essentially the inverse of the traditional content relationships you're familiar with, allowing you to traverse the content graph upward via child items rather than just downward.

For example, if you have an "Author" item that's referenced in multiple "Blog post" items, the used-in API call lets you immediately identify all of those blog posts. This bidirectional relationship tracking opens up new possibilities for how you manage content updates and propagate changes throughout your system.

How it helps with content management

Propagating content updates
When a component or reusable content fragment changes, you need to know which pages or articles use that content to ensure they're properly updated. The used-in API call makes this process straightforward by providing a clear map of dependencies.

Navigation building
For complex navigation structures that rely on content relationships, the used-in API call helps track which navigation elements need updating when underlying content changes. It also makes it possible to build navigation based on parent items, for things like breadcrumbs.

Content auditing and maintenance
The API enables more thorough content audits by revealing the full impact of potential content changes, helping content teams make informed decisions about updates and maintenance.

From a technical perspective, the used-in API call delivers several important capabilities:

Faster rebuilds and updates 

Instead of rebuilding entire sections of your site when content changes, you can precisely target only the affected pages. This leads to more efficient processing and faster content deployments.

Simplified relationship tracking
Developers no longer need to implement custom solutions to track content relationships—the API provides this information out of the box.

Improved search and caching  

The relationship data enables more intelligent caching strategies and can improve search relevance by understanding content connections.

More efficient content lifecycle management

The API makes it easier to implement governance workflows, particularly for complex approval processes where changes to one item might require review of dependent content.

Sync API: An alternative approach to change management

While webhooks are ideal for providing real-time notifications, not every architecture benefits from this push-based approach. Our Sync API offers an alternative, queue-based model for consuming content changes on your own schedule.

How the Sync API complements webhooks

The Sync API follows a fundamentally different pattern than webhooks:

• Webhooks push notifications to your endpoints when changes occur
• Sync API maintains a queue of changes that you can pull when ready

The Sync API is particularly valuable when:

• You need to periodically check for content to translate
• You want to rebuild static sites on a schedule rather than with every change
• Your application experiences occasional connectivity issues
• You want to process updates in batches for efficiency

You can use both webhooks and the Sync API in your projects, taking advantage of their particular strengths.

Updated Sync API coming soon

We're currently working on a new version of the Sync API (with a different contract) that will bring many of the same improvements we've made to our webhooks system, including:

• More robust filtering capabilities
• Improved performance and reliability
• Better error handling and reporting

Combining Sync API with the Used-in API call

The Sync API and used-in API call complement each other perfectly when combined. When processing the change queue from the Sync API, you can use the used-in API call to quickly identify all related content that needs updating. This enables you to:

• Process changes on your own schedule via the Sync API
• Use the Used-In API to trace the full impact of each change
• Update only what needs to be updated

This pattern allows for efficient cascade updates without having to scan your entire content inventory.

Building a comprehensive change management strategy

When combined, these three capabilities enable a sophisticated approach to content change management:

• Use webhooks for time-sensitive updates that need immediate processing
• Use the Sync API for batch processing changes on your schedule
• Apply the used-in API call with both methods to understand relationship impacts

This flexible toolkit supports all types of implementation patterns, from simple websites to complex multi-channel content delivery architectures.

Getting started

Ready to start using these change management capabilities in your Kontent.ai project? Here are the next steps:

• Review our webhook documentation and update to the enhanced version if you haven’t already
• Explore the used-in API call in our API reference and try using it in your development environment
• Consider the Sync API: Evaluate whether your use case would benefit from the controlled synchronization approach
• Provide feedback: As you implement these features, let us know your experience and suggestions for improvement (you can share feedback directly in Kontent.ai via Intercom)

By leveraging these three capabilities, you can build more responsive, efficient, and reliable content applications that handle change gracefully, keeping your content fresh and your development and content teams happy.​​​​​​​​​​​​​​​​