A shared foundation for application delivery at Roche

At Roche, I worked on an application registry, a shared capability for registering applications and managing their versions. It provided a foundation for application delivery, giving the teams involved a common place to work with release information.

My responsibility covered the journey from stakeholder discussions to technical design, implementation, delivery and ongoing support. I worked within an engineering team and helped connect the needs behind the feature with the decisions needed to build it.

Starting with how people would use it

An application registry needs to answer practical questions. What is the application? Which version are we talking about? Is that version ready to be published, and where is it compatible? Those questions connect the data model to the decisions people make when delivering software.

I worked with stakeholders to understand the requirements and helped shape the design around them. The feature needed to make sense as a shared product capability, as well as a set of technical interfaces.

Designing the technical foundation

The registry combined Python API development with PostgreSQL for application and release metadata. The work covered API contracts, relational data modelling and version management. Other parts of the platform depended on that information, so consistency and compatibility were part of the design from the start. Access control also needed to be considered alongside the core functionality.

One important distinction was between the application itself and each release of it. The interfaces needed to represent that lifecycle clearly, so that creating or updating release information had a predictable meaning. I worked through the design with the team and carried it into implementation.

There was also a useful distinction between storing a software package and managing a release. A release carries information that other systems rely on, including its version and compatibility. Keeping those concepts clear helped make the APIs understandable and gave the implementation a consistent model to work from.

Owning the work beyond implementation

I followed the feature through delivery and continued to support it afterwards. The work included the conversations and follow through needed to get a shared capability into use, alongside the engineering itself.

The result was a delivered registry capability for application and version management. I stayed involved from the initial need through to support, working with the team responsible for the wider platform. It was a piece of product work that required both technical design and the willingness to see the details through.