One example is the issue of when to ask DEV guys to see problems the QA engineers have discovered.
Reasons for calling DEV might be:

• Wish to reopen a bug
• Bug was reproduced and a developer was interested to see the reproduction.
• New severe bug

There are a couple of forces affecting this issue:

• QA wishes to finish the context of the specific problem/defect, open the bug, and get on with their work.

• DEV wishes to finish the context of their specific task, and wish to avoid the “context switch” of looking at the QA issue.

• In general, both QA and DEV have learned to wave the “Context Switching Overhead” flag quite effectively. (A more pragmatic conclusion is that some context switching overhead is unavoidable, and sometimes the alternative is more expensive…)

• In some cases, “saving” the state of the problem for asynchronous later processing by DEV is difficult or takes too many resources to be a practical alternative.

A possible compromise between all those forces is to define some sort of SLA between the groups, stating the expected service provided by DEV to QA according to the specific situation (Reopen, Reproduced, New Severe, etc.). This SLA can provide QA a scope of time they can expect answers in, without feeling they are asking for personal favours or “bothering” the DEVs. The developers get some reasonable time to finish up the context they were in without feeling they are “avoiding” QA. The SLA can also cover the expected actions to be taken by QA before calling in the DEV, or in parallel to waiting for them. This maximizes the effectiveness of the DEV person when he does free up for looking at the issue, while better utilizing the time of the QA while waiting. (for example - fill the bug description, look for existing similar bugs, provide the connectivity information into the test environment, log excerpts/screenshots, etc.)

Another question is who to call on when QA needs help. The options here depend on the way the DEV group/teams share responsibility on the different modules of the system.

• In case there are strict “owners” for each module, and they are the only ones capable of effectively assisting QA, the only reasonable choice is to call on them… this requires everyone to always be available at some level.
  I have to say though that I strongly advise against such an ownership mode. Look at code stewardship for a better alternative (in my oppinion) and see below how it looks better for this use case and in general…

• In case there is a group of people that can look at each issue, one alternative is to have an “on call” cycle where people know they have QA duty for a day/week. In this case there will be issues which will require some learning on their part, and perhaps assistance from the expert on a specific area. This incurs overhead, but is worth its price in gold, when the time comes and you need to support that area in real time, need to send the DEVs to the field to survive on their own, or when the owner/expert moves on…

To sum up, like in many h2h (human-to-human) protocols, understanding the forces affecting both sides of the transaction is key to create a win-win solution. A pragmatic view trying to minimize the prices paid and showing the advantages of the solution to both sides and to the overall organization can solve some hard problems, as long as people are willing to openly discuss their issues and differences. I’ve seen this work in my organization, hopefully it helps others as well.