consera.io
Which updates matter? Your platform knows.
- updates per month
- 300
- matching to the Azure services in use
- Automated
- progress for each update
- Trackable
Finding a Microsoft update does not answer the crucial question: What does this change mean for your own infrastructure?
With consera, I developed a platform that centrally collects updates for Microsoft 365 and Azure, processes them, and relates them to each customer’s context. The focus was on IT teams’ workflow: identifying relevant changes, assessing their impact, and tracking how they are handled.
Development required decisions about scope, the quality of assessments, and how to handle external data sources. Technical changes were also product-development questions: How much effort does a feature justify? Which dependency threatens the core value? And what prerequisites must be met before a process can be automated?

Finding information was only the first step
Microsoft continuously publishes changes to its cloud services. New features, changed settings, and security adjustments reach organizations through different communication channels.
This created recurring work for IT teams: compiling information, identifying affected services, and assessing whether a change requires a response. They then had to determine whether the issue had already been addressed.
A central overview could make the search easier. But making a specific decision required more information: Does the organization use the affected service at all? What impact can be expected? Is action required?
The product’s goal was therefore to support the path from a published change to a decision by the IT team.
Relevance over volume of information
The problem gave rise to three interconnected tasks for the platform:
Task | Support needed |
|---|---|
Review changes | Automatically collect updates and provide them in a single, consistent overview |
Assess significance | Evaluate information and compare it with the services actually in use |
Track progress | Assign a status to updates and keep their progress visible |
This breakdown gave the product a clear direction. The value of an additional data source depended on whether its information could be processed reliably and placed in context. An assessment had to help users form their own judgment. Status tracking had to carry this information forward into the rest of the workflow.
This made it possible to shape the scope around the outcome for users: What do they need to assess a change and then act on it?
Turning an overview into a workflow
The requirements went beyond collecting updates. Information from different sources had to be made comparable. The platform needed to identify which services a customer uses. Assessments needed a sound domain-specific basis, and progress had to remain traceable across individual visits.
The following questions were particularly important in shaping the solution:
- What information does an update need to be clearly understood and evaluated?
- How can a change be mapped to the affected services?
- What customer data is needed for matching?
- What kind of assessment supports the IT team’s decision?
- What information needs to be retained for later follow-up?
These questions connect business requirements with technical implementation. For example, a missing service reference directly affects matching. An unclear assessment undermines the user’s decision. An unrecorded status interrupts the workflow.

Infrastructure as context
Connecting Azure tenants added crucial context to the central overview. The services actually in use could be used to match updates to each customer.
This turned a general collection of information into a selection tailored to the organization’s infrastructure. Users no longer had to establish the link between a published change and their service inventory from scratch for every update.
The limits of this feature are just as important as its benefits: A match indicates a connection to a service in use. Whether a specific action is required must then be assessed.
This distinction shapes expectations of the product. Matching helps select relevant information; assessment supports the subsequent decision.
Domain expertise as the basis for automation
The original idea was to have experts provide domain-specific assessments. This would prepare updates so IT teams could more easily understand their significance.
As the volume grew, manual assessment was supplemented with AI-assisted processing via the OpenAI API. The experts’ knowledge base provided the domain-specific foundation for this.
This sequence was essential to product development. First, we had to define what makes an assessment useful. Only then could processing be automated on that basis.
AI thus augmented a defined domain-specific process. The goal was to process larger volumes of updates without having to assess every entry entirely by hand. Whether the assessments achieve the desired quality remains a matter for expert review; an automated output alone does not prove that.
Turning information into action
Customers could track updates and assign a status. This made it clear which changes had already been addressed and which were still open.
This feature bridged the gap between information and implementation. A relevant update remained as an item the team could continue working on.
The status documents progress within the platform. By itself, it is not technical evidence that a change has been implemented in the infrastructure.

Account for dependencies in the core workflow
The features were closely interconnected. Without up-to-date data, the overview loses its value. Without consistent service mapping, matching becomes unreliable. Without a domain-specific assessment, the results remain of limited use.
This provided a clear benchmark for further development: changes should improve the complete workflow or safeguard a prerequisite for it.
Standardizing update data was therefore a key foundation. It made it easier to process different sources and created a common structure for further processing. Tenant matching added customer context. Assessments and status tracking supported subsequent follow-up.
These dependencies explain the importance of each feature. They do not describe a sprint or delivery plan inferred after the fact.
External dependency: When the update source went down
A major challenge arose when Microsoft changed its RSS interface. The existing source stopped working and later returned in a modified form. As a result, no new updates could initially be collected through the existing method.
The outage directly affected the platform’s core value: an update overview must be able to provide current information.
In response, the structure of collected updates was standardized. Source-specific formats were converted into a shared internal structure. This made it easier to connect new sources and adapt to changed formats.
The reliance on external information remained. However, it became easier to limit the effort required to adapt when its formats changed. For further development, this meant that processing had to distinguish between a source’s format and the platform’s data model.
Balancing effort and product value
Unifying the backend
The backend was initially developed with Express.js, while many Azure Functions already used Python. This meant maintaining different toolchains and development workflows.
Migrating to Python with FastAPI initially required additional development work. However, it brought backend processing together in a single language and simplified further development.
What mattered was the effort over the product’s entire lifetime: the short-term cost of migration had to be weighed against the recurring overhead of a split backend landscape.
Adapting authentication to actual needs
Auth0 was initially used for authentication. As the project progressed, its feature set, cost, and integration effort became increasingly disproportionate to the benefits needed.
Switching to custom JWT-based authentication brought the solution closer to the backend and the platform’s requirements. At the same time, responsibility for implementation, maintenance, and security shifted to the application itself.
The decision reduced an external dependency while requiring additional in-house development effort. Both sides belong in the assessment of a change like this.
Separating the customer interface and administration
The frontend was built with Nuxt.js. PostgreSQL stored the platform’s structured data. The interface was designed to make accessing and handling updates clear, while processing took place in the backend.
A separate frontend with its own API interface and middleware protection was created for administration. This made it possible to provide administrative tasks separately from customer-facing features.

Result
A connected process for Microsoft updates
consera combines centralized update collection with domain-specific assessment, customer-specific matching, and status tracking. The platform thus covers several steps that IT teams previously had to bring together using different information sources and their own workflows.
The features described show how an information problem became a product with a concrete workflow. Decisions were guided by what support users need to select, assess, and handle changes.
Three metrics would be particularly relevant for a robust assessment of the impact: the time it takes to assess an update, the quality of customer-specific matching, and the proportion of relevant changes whose handling can be tracked through to completion. Without corresponding usage data, time savings and error reduction cannot be quantified.
Looking back
Measuring product decisions by their impact
Developing consera repeatedly required adaptations: to external data sources, to the effort involved in technical implementation, and to processing growing volumes of information.
For me, the project shows just how closely product concept and implementation are connected. A technical dependency can threaten the currency of information. A complex architecture can slow further development. Automated assessment requires clear domain-specific expectations.
The benchmark for these decisions is the workflow the product is intended to enable. At consera, that means finding relevant changes, assessing their significance, and tracking how they are handled.
