For O11 there’s no built‑in “XML diff” action, but you can implement this cleanly using existing patterns and/or a small Extension. You basically have three options:

1. XML Records + Custom Diff Logic (all in OutSystems)

If you want to stay 100% in OutSystems and keep it maintainable, I’d start here.

a) Parse both XMLs into Structures

Use the XML Records O11 Forge component to convert each XML into OutSystems Record / Record List structures that mirror the XML tree. Parsing complex XML files

Typical flow on upload:

1. Store the raw XML in an Entity (text or binary) as your “previous version”.
2. When a user uploads a new XML:
   • Retrieve the previous version for that “document”.
   • Use XML Records to map OldXML → OldRootStructure.
   • Use XML Records to map NewXML → NewRootStructure.

b) Implement a generic diff between two structure trees

Once both XMLs are represented as Record/Record List structures, you can compare them using normal OutSystems logic:

• Define a DiffResult structure with fields like:

  • Path (XPath‑like string, e.g. /Invoice/Lines[3]/ProductCode)
  • ChangeType (Added / Removed / Modified)
  • OldValue
  • NewValue
  • NodeType (Element / Attribute)

• Implement server actions that:

  • Compare lists of elements:
    • Use a key (e.g. Id, Code, Name) to match items in Old vs New.
    • If in New but not Old → Added.
    • If in Old but not New → Removed.
    • If present in both → recurse into child elements / attributes and compare values.
  • Compare simple attributes/values:
    • If OldValue <> NewValue → Modified.

This gives you:

• A reusable XMLDiff_BuildResult action that returns a list of DiffResult items.
• A simple table in the UI bound to DiffResult to show all changes (added/removed/modified).

Pros

• Pure OutSystems, easy to maintain and debug.
• You work with typed structures instead of raw XML strings.
• Plays nicely with O11 version control and Compare/Merge. Version Control > OutSystems Version Control > Compare and Merge Functionality

Cons / considerations

• You have to define structures reflecting the XML (or generate them, if complex).
• You must design your matching strategy between nodes (unique identifiers, paths, etc.).
• Very large XMLs will mean large Record Lists; you may need pagination or limits.

If your XML is “business data” (e.g. invoices, products, configs), this is usually the most maintainable solution.

2. XML Extension + XPath + Diff Logic (semi‑manual XML)

If you prefer to work at XML level (no auto‑mapping to structures), you can use OutSystems’ XML extension with XPath and build the diff yourself. How to parse XML files with XPath expressions

Typical flow:

1. Convert binary to text (if needed) and load each XML:
   • XmlDocument_Load_v2 → OldDoc, NewDoc.
2. Traverse the DOM with XPath:
   • For each relevant node in OldDoc, try to find the corresponding node in NewDoc.
   • If not found → Removed.
   • If found but value/attributes differ → Modified.
3. For nodes present in NewDoc but not in OldDoc → Added.
4. Accumulate results in a DiffResult list (similar structure as above).

Pros

• Full control over XML tree and namespaces.
• Good for complex, deeply nested XML where you want fine‑grained custom logic. How to parse XML files with XPath expressions

Cons

• More “manual” than XML Records.
• XPath logic can get complex for large schemas.
• You must carefully handle namespaces (prefixes) in XPath expressions.

This is still maintainable if you encapsulate all logic in a small set of server actions (e.g. XMLDiff_CompareDocuments) and keep the XPath rules clearly documented.

3. C# Extension (using a .NET XML diff library)

If you need a robust, generic XML diff with full support for namespaces, attributes, ordering rules, and want to reuse existing .NET libraries (e.g. Microsoft XML Diff & Patch), then an OutSystems Extension is a good choice.

Approach

1. Create an Integration Studio Extension (C#).
2. Wrap a library or your own code that:
   • Accepts two XML strings.
   • Produces:
     • Either a “diff XML” (e.g. an XML with <add>, <remove>, <change> nodes), or
     • A flattened list of changes (that you map to an OutSystems structure).
3. Expose a simple server action, e.g. XMLDiff_Compare(OldXmlText, NewXmlText) → DiffResultList.
4. Use this action in your O11 module and display DiffResultList in a table.

Pros

• Less logic in Service Studio; complex diff handled by tested .NET code.
• Potentially better performance for very large XMLs, depending on the library.
• Easier to support advanced cases (e.g. ignore certain nodes, whitespace, ordering).

Cons

• Requires C# skills and Integration Studio.
• Debugging is split between OutSystems and .NET.
• More overhead to deploy and maintain the Extension over time.

If your team is comfortable with C# and you want a “black box” XML diff, this is often the most straightforward.

4. Forge Components for XML Comparison?

Currently, there is no widely‑used, generic Forge component dedicated to XML diff equivalent to “Compare Entity” for entities. I want to compare two structure data and display the different data in list

However, you can combine Forge components:

• XML Records O11: Parse XML to structures for easy processing and display. Parsing complex XML files
• Compare Entity (or similar “compare” Forge components):
  • These generally compare entities / records, not raw XML.
  • If your XML maps nicely to entities or structures, you may reuse them to identify changes between old and new object lists. I want to compare two structure data and display the different data in list
• XML Prettify O11:
  • Useful to present either the full XML, or a diff XML, nicely formatted.
  • Not a comparer; just for formatted display. Display XML content on screen with nodes

Limitations / considerations if using Forge components

• Structure mapping:
  • XML Records expects reasonably well‑structured XML; very dynamic/irregular XML may be harder to map.
• Namespaces:
  • XML Records supports namespaces, but you have to configure mapping carefully if your XML is heavily namespaced.
• File size / performance:
  • Very large XMLs (MBs with tens/hundreds of thousands of nodes) can consume significant memory if fully converted to Record Lists.
  • You may need:
    • Streaming / incremental processing.
    • Limits on file size.
    • Background processing (e.g. timers) instead of synchronous comparison on screen.
• Upgrade path:
  • Check Forge component compatibility with your O11 version and any future upgrade plans.

Recommended approach (for maintainability + performance)

Given your requirements (track added/removed/modified nodes and values, show differences to the user, O11, maintainable):

1. Persist XML versions:

   • Create an Entity XmlDocument with fields like:
     • DocumentKey (e.g. a business key or filename).
     • Version (integer).
     • XmlContent (Text or Binary).
     • UploadedOn, UploadedBy.

2. Compare on upload:

   • When a new version is uploaded:
     • Fetch previous version by DocumentKey.
     • If none, just store as version 1.
     • Else:
       • Either:
         • Option A (pure OutSystems): Use XML Records → structures → your own diff logic.
         • Option B (Extension): Call XMLDiff_Compare in C#.

3. Generate a DiffResult list:

   • Structure with:
     • Path, ChangeType, OldValue, NewValue.
   • Use this to drive your UI (table, grouping by section, etc.).

4. Optionally:

   • For “visual diff”, generate an XML that highlights changes and show it using XML Prettify. Display XML content on screen with nodes

If you don’t have strong C# experience, I’d start with XML Records + custom OutSystems diff; it’s very maintainable, transparent to OutSystems developers, and leverages the platform’s strengths. If later you hit performance or need more advanced comparison rules, you can encapsulate the diff in a C# Extension and keep the rest (storage, UI, flows) unchanged.