How to handle hand-outs from one jira project to another?

Question

there! First time user here!

Given that we have three Jira projects:

• USERS, which users use to enter issues;
• BACKEND, which is internal to our backend team;
• FRONTEND, which is internal to our Frontend team

Our flow today is as follows:

• User enters a ticket into the USERS project
• The PM creates two linked issues: one for the BACKEND project, and one for the FRONTEND project.
• The PM links the BACKEND ticket as "blocks" the FRONTEND ticket.
• Both the BACKEND and the FRONTEND tickets go into the usual backlog/sprint process

My problem today is on the handout process. The FRONTEND team has to wait for the BACKEND team to finish their work on their ticket. When the first team is done, they tell the FRONTEND team, and the frontend team will start working on their part of the job. This, of course, is not optimal, because the first team will often forget to tell the other team after they are done. It's up to me to keep an eye on their tickets to see what's marked as RESOLVED and then trigger the start of the work on the Frontend court.

How can we do this better (without re-engineering the whole organization and the way our teams are organized)? Is there any way to automate this handout with Jira?

Thank you a lot!

Some remarks: 1. Both teams are already big enough to be separated. One big team would be too big to be properly managed. 2. I'll add more remarks as I think of them ;)

Answer 1

TLDR

• Combine the teams into one.
• Combine the Stories into one.
• Use SubTasks for segregating work.
• Have a single board that shows all work.
• Work in tandem if possible.

There's a lot here that I see as problematic, so let me hit a few major points:

Teams should be cross-functional.

Why separate development into two teams? This is exactly why that's a bad idea - it creates dependencies and hand-offs, which creates waste. Combine the two teams into one team.

Both teams are already big enough to be separated. One big team would be too big to be properly managed.

Okay. So then take half of team A and swap them with half of team B. Now you have two cross-functional teams that don't have dependencies between them.

Stories should, by themselves, provide business value.

See the INVEST mnemonic. Stories should be Independent. Otherwise, you end up with a lot of finished stories as part of half-finished requirements. You can use SubTasks to segregate the front/back-end work, if desired. Ideally, over time, your developers should work together and become T-shaped, thereby allowing one person to complete some stories entirely.

There is no overall view of the Project's work

Now, this should be a nonissue if you heed the above advice, but if for whatever reason you can't/won't, then you need to create either a single Jira project (separating by epics if necessary) or else a single board that shows both Jira projects. This way there's a consolidated view of the state of the project.

Why a block?

Why would you even need to have a block, here? All you need is an agreed-upon API, after which the two teams should be able to work on the feature simultaneously. What advantage do you gain from adding a roadblock?