Current Situation
When working on an application with multiple developers and multiple published versions, it can sometimes be difficult to understand exactly what changed between a previous version and the currently published version.
OutSystems already provides version comparison capabilities, which are useful for inspecting differences. However, when a module contains many changes, developers may still need to manually go through different elements to understand the overall scope of the changes.
I would like to suggest adding a “View Changes” option when opening a previous version of a module.
For example, when selecting a previous version from “Open Other Version”, there could be an option such as:
View Changes
This would automatically compare the selected version with the currently published version and provide a clear, consolidated summary of all the changes between those versions.
What Should Be Included?
The change summary could cover different levels of the module, for example:
UI / Screens
- Screens added, removed, or renamed
- Containers/widgets added or removed
- Container/widget names changed
- CSS classes changed
- Widget properties modified
- Screen Actions/Event Handlers added, removed, or modified
Client Actions
- Client Actions added, removed, or renamed
- Logic modified
- Input/output parameters added, removed, or changed
- Variables added, removed, or modified
- Dependencies/references changed
Server Actions
- Server Actions added, removed, or renamed
- Logic modified
- Input/output parameters changed
- Variables added, removed, or modified
- Dependencies/references changed
Data / Entities
- Entities added or removed
- Attributes added, removed, or modified
- Data types changed
- Relationships or other relevant properties modified
Module-Level Changes
- Module properties changed
- Public elements changed
- References added, removed, or updated
- Dependencies changed
- Other relevant module-level configuration changes
Example
If the current published version is Version 100 and a developer opens Version 95, clicking “View Changes” could display something like:
Changes from Version 95 → Version 100
Screens
✓ HomeScreen
- Container "MainContainer" renamed to "DashboardContainer"
- CSS Class changed
- New Button added
Client Actions
✓ RefreshData
- Logic modified
- New input parameter added
Server Actions
✓ GetCustomers
- Aggregate modified
- New filter condition added
Entities
✓ Customer
- Attribute "Status" added
- Attribute "IsActive" changed
References
✓ CustomerAPI
- Reference updated
Ideally, each change could be clickable so that the developer can directly navigate to the affected element and inspect the detailed difference.
Why Would This Be Useful?
This would be particularly useful when:
- Debugging: Developers can quickly identify what changed between two versions instead of manually inspecting the entire module.
- Code reviews: It provides a quick overview of the actual changes introduced between versions.
- Maintenance: Developers can easily understand when and where a particular change was introduced.
- Troubleshooting: If an issue appears after a particular publish, developers can quickly identify the relevant changes.
- Team collaboration: It becomes easier to understand changes made by other developers.
- Large applications: It reduces the effort required to inspect changes across complex modules.
- Overwritten changes: Sometimes a developer may unintentionally overwrite or replace existing code/logic while making changes. In such cases, being able to quickly see what was changed compared with an earlier version would be extremely helpful as a reference for identifying what was overwritten or modified.
- Rollback decisions: Before reverting to an older version, developers can clearly understand what changes would be affected.
Related Existing Ideas / Clarification
Before posting this idea, I searched the OutSystems Community to make sure there wasn't already an existing idea covering the same requirement.
I found the existing idea “History of change in Actions and Screens and compare with previous versions”, which focuses mainly on maintaining history and comparing changes for individual Actions and Screens.
There are also existing discussions around comparing a module with a previous published version, as well as functionality related to publish/change comments.
However, my understanding is that the proposed idea is slightly different:
The goal is not simply to compare two versions, but to provide an automatically generated, consolidated “View Changes” summary covering the entire module.
This could include Screens, UI elements, Client Actions, Server Actions, Entities, References, Dependencies, and module-level changes, all in one easy-to-understand list.
The existing comparison functionality could still remain available for developers who need detailed inspection. The proposed “View Changes” feature would act as a high-level summary layer on top of that, making it much easier to understand the overall changes between two versions.
This is why I believe this could complement the existing version comparison/history capabilities rather than duplicate them.