A simple workaround can unlock one of the most requested Jira Product Discovery outcomes: showing idea dependencies (inside Jira Plans). The gap is straightforward. JPD stores timing as flexible Intervals, while Plans expects fixed date values to render bars, sequence work, and expose dependency lines.
The good news is that you do not need custom code. With Jira Automation and regular-expression smart values, you can translate JPD interval fields into Plans-compatible start and due dates, then use native Plans views to connect ideas to each other or to delivery work items.
Where the mismatch comes from
JPD time fields such as Project start and Project target are not stored as standard datepicker values. They use an interval model with bounded start and end dates serialized in JSON. Plans, on the other hand, requires strict scalar dates in YYYY-MM-DD format.
That mismatch is why direct field mapping through standard Automation UI actions tends to fail. A common validation error is:
The Start date must be of the format "yyyy-MM-dd"
Under the hood, JPD intervals resolve like this:
- Specific date:
{"start":"2027-07-27","end":"2027-07-27"} - Month:
{"start":"2027-11-01","end":"2027-11-30"} - Quarter:
{"start":"2027-01-01","end":"2027-03-31"}
That structure is the key. If Automation can extract the first or last date from the serialized interval, Plans can use the result like any other scheduling field.
Layer | Source or target | Field type | What happens |
|---|
Discovery | Project start
| Interval | Automation extracts the first date boundary and writes it into a Plans start field. |
Discovery | Project target
| Interval | Automation extracts the final date boundary and writes it into a Plans due-date field. |
Planning | Start date / Due date
| Datepicker | Plans can render bars, schedule work, and visualize dependencies. |
Why field IDs matter
Another practical wrinkle is field selection. In many cases, the easiest path is to bypass UI selector issues and work directly with explicit field keys such as customfield_XXXXX.
You can retrieve these through the Jira REST API endpoint:
https://your-domain.atlassian.net/rest/api/3/field
Then search the payload to identify the correct source and target fields in your own instance, because the IDs can differ between environments.
Role | Field name | Field type | Example key |
|---|
JPD source start | Project start
| Interval | customfield_13466
|
JPD source target | Project target
| Interval | customfield_13460
|
Plans target start | Start date
| Datepicker | customfield_10015
|
Plans target due | Due date / Target due date
| Datepicker | customfield_10016 or duedate
|
These field IDs are example values from one instance. Reconfirm every mapping in your own tenant before enabling the rules.
Two automation rules do the job
The cleanest setup is to split the synchronization into two separate automation rules: one for project start and one for project target. That keeps execution predictable and avoids unwanted coupling when only one of the date intervals changes.
The rule will throw an error but will work. Ignore the error, trigger the automation, and the error will be gone.
1. Project start synchronization
- Trigger:
Field value changed - Field to monitor:
Project start (customfield_13466) - Change type: Any change to the field value
- Action:
Edit work item using More options and Additional fields
{ "fields": { "customfield_10015": "{{issue.customfield_13466.asJsonString.match("([0-9]{4}-[0-9]{2}-[0-9]{2})")}}" }}
The regex captures the first date in the interval JSON. That means:
- a specific date stays the same,
- a month resolves to its first day,
- a quarter resolves to its first day.
2. Project target synchronization
- Trigger:
Field value changed - Field to monitor:
Project target (customfield_13460) - Change type: Any change to the field value
- Action 1:
Re-fetch issue data - Action 2:
Edit work item or Edit issue using More options and Additional fields
{ "fields": { "customfield_10016": "{{issue.customfield_13460.asJsonString.match(".*([0-9]{4}-[0-9]{2}-[0-9]{2})")}}" }}
Here the greedy prefix .* forces the match to the final date in the serialized interval. That makes the due date land on the last day of the chosen period, such as 2027-03-31 for Q1.
Net effect: JPD can keep its flexible planning model, while Plans receives exact dates it can actually schedule against.
What to configure in Plans next
Once the dates are syncing, the remaining setup is in Plans.
- Verify scheduling mappings. In your Plan configuration, confirm that your selected
Start date maps to the start field and your selected Due date maps to the synced target field. - Include the right sources. Use the JPD space alone if you only want idea-to-idea dependency visibility, or add broader work-item sources if you want idea-to-delivery views.
- Use dependency-capable views. Timeline, Dependency view, and Program Board can all help surface the relationships once the dates exist as proper scalar values.
- Create links directly. You can connect idea bars to other ideas or delivery items using native dependency relationships such as Blocks or Depends on.
What this unlocks for teams
A roadmap shows what teams want to achieve. Dependencies reveal what needs to happen first and who needs who to make it possible. That matters while ideas are still being prioritized in JPD, not only after they become delivery work. Customer research highlights this gap: teams struggle to see cross-team blockers, understand the consequences of changing priorities, and keep planning conversations connected to the roadmap.
Product managers: prioritise with the bigger picture in view
An idea can be valuable without being ready to deliver. Seeing its dependencies helps product managers recognise prerequisites, negotiate with other teams, and explain why the highest-priority idea might not be the next one to start. The conversation shifts from “Which idea scores highest?” to “What needs to happen to unlock this outcome?”
Portfolio and program teams: coordinate across roadmaps
Individual roadmaps can look achievable while depending on the same platform, design, or data team. Visualising those connections helps portfolio and program teams spot shared blockers, discuss sequencing conflicts, and understand which initiatives could be affected by a delay—before separate teams make incompatible commitments.
Engineering and delivery teams: surface constraints earlier
Dependency visibility makes it easier to see both what a team is waiting for and who is waiting on that team. Bringing those relationships into planning discussions helps product and engineering agree on prerequisites and handoffs before work reaches execution, rather than discovering the constraint after priorities have already been communicated.
Product leaders and stakeholders: make better trade-offs
A dependency view adds context to decisions about moving, delaying, or deprioritising an initiative. Instead of reviewing each roadmap item in isolation, leaders can discuss the wider consequences: what else becomes blocked, which outcomes are put at risk, and where teams need help resolving competing priorities. These are the kinds of conversations customers currently describe managing through meetings, spreadsheets, and manual workarounds.
This pattern provides a practical bridge: teams retain flexible planning intervals in JPD while using Plans to visualise dependencies between ideas—and, where needed, delivery work. It does not add dependency visualisation inside JPD, automatically discover relationships, or resolve capacity constraints. It makes those relationships available for a more informed planning conversation.