Requirements Management - Export Data from OpenRose

 

Hello again, and thanks a lot for joining this session.

Today, we're going to talk about the latest release—version 0.2.0-32—of OpenRose.

In this particular version, we’ve delivered a significant new capability requested by our users: the ability to export data from OpenRose. Here are the release notes.

Version 0.2.0-32 is all about supporting the export of data in JSON format, including requirements breakdown structure. Now, we support exporting:

• Project requirements ItemzType data
• Requirements Itemz data
• Baseline data
• Baseline Requirements ItemzType data
• Baseline Itemz data

All of these are now supported in the latest version.

Let me start by showing you the user story we received, visible in the project area. It was a simple one:

“As a user of the OpenRose tool or application, I want to be able to export project Requirement ItemzType or Requirement Itemz to the file system so that I can share it with others or import it into another OpenRose repository.”

The import functionality will follow later. For now, we've completed the export functionality for six types of data.

When this enhancement request came in, our team sat down to define the scope, impact, and technical design. We considered:

• How the solution should be architected and delivered
• What should be included in the JSON file
• How traceability and filtering criteria should work

All of this was documented in our wiki, under the concept of exporting data from OpenRose. You’ll find a comprehensive explanation there.

Before we began implementation, we recorded a video outlining our understanding and shared it with the community—giving insight into the design decisions around this enhancement. You can find it on YouTube or via our blog page.

So let’s dive into the new enhancement delivered in this release.

If you've upgraded to version 0.2.0-32, the settings will reflect that, and you'll notice a new “Export” option in the menu on the left.

We’ll use the "Charity Fundraising Project" for this demo. When opened in tree view, you’ll see the three different ItemzTypes associated with this project. In the third ItemzType, “Post Fundraising Activity,” you can also explore the requirements breakdown structure.

Today, we’ll export the entire project. Each ItemzType has:

• Flat requirements or items immediately beneath it
• Hierarchical requirements (in some cases)
• Traceability connections among requirements

For example, a requirement like "Publish and Promote" has traceability links to "Engage Participants and Volunteers," which itself exists under "Fundraising Event Execution." We even created a duplicate of that requirement within the same area to demonstrate traceability consistency.

To begin the export:

1. We pick up the Project ID.
2. Since we're exporting a project, we select "Project" in the export tab.
3. After submitting the ID, we see project details—here, the Charity Fundraising Project.

Once we click Export Selected Project, the export succeeds. In the Downloads section, we see a file named something like "openrose_exportproject".

The exported JSON includes:

• The repository ID (representing all projects)
• Our selected project and its data
• All associated ItemzTypes, Itemz, and breakdown structures
• Traceability within the scope of those requirements

Now, let’s move on to exporting just an individual ItemzType.

• We gather the ID of that ItemzType
• In the export tab, we switch to "ItemzType" mode
• We input the ID and submit

If you mistakenly submit an ItemzType ID under “Project” mode, the system returns an error (since it expects a Project ID). Selecting the correct mode ensures success.

This export will include:

• The selected ItemzType and all its associated Itemz
• A JSON structure without the project info (null in that field)
• No traceability if none exists (empty array instead of null)

This update gives OpenRose users the flexibility to export full project data or narrow it down to specific components. More enhancements—including import features—are on the roadmap.

Let me close this and move over to another item type export.

I'm now going to select the third item type, which is Post Fundraising Activity. Let's pick up its ID. I'm doing this because it contains a requirements breakdown structure with multiple layers, and I know some of these requirements have internal traceability among themselves. I want to demonstrate that, if there are any traceabilities within the scope of exported requirements, you'll see them included in the export output.

Returning to the export screen under Item Types, I punch in the ID and export the data.

Let's open the file. We're exporting an item type—not a project—specifically the "Post Fundraising Activity" item type. It includes a data structure, but... oh, there are no traceability records. Perhaps none exist within this data.

Maybe I was mistaken. Let me create a traceability entry for demo purposes.

Back in the project, let’s say “Plan Video Content” is the parent. I’ll make it the parent of “Publish and Promote the Fundraising Activities.” That means I’ll create a new parent reference pointing to “Plan Video Content.”

That requirement falls within the scope of the exportable data. Now, we’ve just introduced a trace between “Plan Video Content” and “Publish and Promote,” where the former is the parent, and the latter is the child.

Let’s return to the export screen and re-export the third item type: Post Fundraising Activities. This time, we should see both the breakdown structure and the traceability we just added.

Heading back to the top, I search for the ID of “Plan Video Content,” the parent. Then I search for the child, which is the "Publish and Promote" item. At first, I assumed this trace already existed—but apparently, it didn’t in my demo data. So I had to create it to show how traceability within the exported scope is reflected in the output.

Now onto the third part of the demo: exporting a single item.

Since there's a link between these two requirements, I’ll pick the item “Create and Publish Social Media Video and Resources Showcasing Fundraising Success”—which is the parent.

When I export this parent item, it includes the entire requirements breakdown structure, along with all traceability within the export scope. I copy the ID, submit it via the export screen, and get a file.

This export doesn't include project or item type data—it only includes the items and sub-items.

In the file, we see the main item we exported, plus “Plan Video Content” (ID: Ble9B) and “Publish and Promote” (ID: DDB53). That’s our traceability pair—Ble9B → DDB53. It's exactly the outcome we expected from the OpenRose export functionality.

Now, let’s move on to baseline exports.

If a project doesn't yet have a baseline, we first create one. Opening the Tree View, we currently see no baselines. I create a new one named “Export Baseline Demo”, adding some description. Once created, we can view it in the baseline tree. We now see the baseline name and the familiar three item types with their associated breakdown structures.

We have more videos about baseline features available on our YouTube channel—do check them out!

Let’s export the entire baseline next.

We have many requirements, including breakdown structures. When exporting a baseline, there are special options. I rearrange the tabs so I can see both the baseline data and the export screen.

We now decide: should we export all requirements, or only those marked for inclusion in the baseline? We'll cover inclusion/exclusion shortly, but for now, we’ll export everything.

Once exported, a file appears in the downloads—named something like “export of baseline from OpenRose.”

Opening it, we notice no data from the live project (fields like Project, Item Type, Item, and Item Traceability are null). This is expected—our export targets the baseline.

We see:

• Baseline Item Types
• Baseline Items (including sub-items)
• All traceability data in scope

We now have four traces. Initially, the project had three; we introduced a fourth one under the third item type. All are exported.

Note: Each record has a unique baseline ID, not the original item ID. When creating a snapshot/baseline, new records and IDs are assigned for traceability and tracking.

Next, let’s export a particular baseline item type.

For example, Post Fundraising Activity, which exists in the current baseline. I copy its baseline item type ID, return to the export screen, and export it.

The resulting JSON file focuses on Baseline Item Type only. Inside, we see:

• Baseline Item Type data
• Baseline Requirement Items
• Requirements Breakdown Structure
• One traceability link between "Plan Video Content" and "Publish Video Content" (as expected)

I can even search for those records to confirm their linkage via baseline IDs.

Finally, we export a specific baseline item.

Within the same "Export Baseline Demo," I select “Create and Publish Social Media Video” from the baseline view. After confirming the summary, I export everything related to that item.

In the output, we get:

• The main item
• All sub-items under it
• Traceability details (e.g. link between "Plan Video Content" and "Publish Video Content")

Again, these are based on baseline IDs.

One final note: within a baseline, you can choose what to include or exclude. This is useful during scoping discussions with stakeholders—teams, marketing, business owners, etc.—to agree on what's baseline-relevant.

For this demo, we’ll exclude the entire set under Post Fundraising Activities. I’ll now export the item type that’s its parent to demonstrate that change.

Certainly! Here’s a cleaned-up version of your text block with punctuation, paragraph breaks, and improved flow for easier reading—while keeping it conversational and suited for documentation or a walkthrough:

Let’s select that, go to the baseline item type, and export that particular record. It found it!

This time, I'm not going to include items that are excluded—those marked with a red "X." These are not part of the baseline, and I don’t want their data exported. I also don’t want any traceability data related to those excluded items to appear in the export.

So in this scenario, I’m exporting my item type with exactly six included items:
1, 2, 3, 4, 5, and 6. Let’s go ahead with that.

I select the option: “Only export baseline items marked for inclusion.” That limits the export to just the six selected items.

The new file is now generated. We should see the item type and then exactly six records.

Let’s verify:

• Record one — no sub-items
• Record two — no sub-items
• Record three
• Record four
• Record five
• Record six

That’s it! There’s no traceability, as expected, because within these six exported records, no traceability links exist.

Now, let me show you the contrast.

I’ll go back to the same export, using the same ID to identify the third baseline item type. But this time, I won’t restrict the export to included items only. Instead, I’ll choose to include everything, both included and excluded items.

Naturally, this will generate an output representing the entire breakdown structure, regardless of inclusion status.

If you look closely, you can see which records were included or excluded. For instance:

• isIncluded: true for included records
• isIncluded: false for excluded ones

So in our example, "Create and Publish Social Media Video Reels" was previously excluded—but is now present in the output because we exported everything.

And yes, because we included all data, we also see traceability records for those baseline items that fall within the export scope.

In summary, when exporting baselines, you’ve got one extra decision to make:
Do you want to include excluded items, or just those marked for inclusion?

With that, we’ve covered a lot of ground!

The goal of this feature is multi-fold. While we showed the output in JSON format, the data can also be:

• Consumed by other products or software
• Shared with integration partners
• Fed into AI platforms to power smarter interactions with your own requirements data

This capability helps set the context for downstream use—like asking an AI tool to analyze your exported data. We’ll cover more of that in a future video.

For now, that wraps up our walkthrough of version 0.2.0-32 of OpenRose, and its powerful new export features. We’d love your feedback, and please share this information with others who may benefit.

Thanks so much for your time. Have a great day, and see you next time.

 OpenRose, a free and open-source requirements management application / tool. For more information, visit 

https://github.com/openrose