Garnering Empathy during Siloed Development via Code Collaboration
My team, the platform team, had to recently implement a very difficult system capability around Single Sign On (SSO) based on SAML2. We created a new micro-service which orchestrated the SAML flow based on the user email. The diagram below drove our underlying architecture:
This was all good. The team was able to get this working on their local machine and used Okta for testing. All worked flawlessly. Our Cypress integration tests was also passing.
When the UI team started integrating with our endpoints, they started running into issues that had to do with CORS. We made some assumptions during development, (including the library we leveraged), on all communication occurring on the same domain, which is generally true during deployment. However, during tests, we encountered situations where requests were being triggered from localhost to our development instance which implies a cross domain request. Our strategy of using secured cookies to pass along authentication state did not fare too well in this setup and as a result, we ended up replacing all cookie persistence with Redis persistence.
Throughout the interaction with the UI team, there was friction. At one point prior to this interaction, we thought our original design was flawless; we had built something bullet-proof. It was based on 302 redirects and http cookies. However, the UI team exposed an edge case we did not for-see: cross domain communication for testing purposes.
For this final challenge, we decided to jump onto a call with team leads from both the platform team and the UI team. The UI team presented their testing methods, which made sense. The platform team then walked the UI team through its implementation until we arrived at where the issue occurred. We discussed what the platform team can do to get past this last road block, which involved creating a RedisRequestTracker implementation for this interface. In simpler terms, use Redis to persist authentication state across sessions.
What this simple exercise of getting both teams on Zoom achieved was empathy. The UI team came out of this meeting with an appreciation of the complexity of the framework the platform team built in Golang. With this appreciation, there has been acquisition of a certain degree of empathy from both parties as each team is now somewhat aware of the complexities of the underlying framework which avoids quick throw over the fence decisions when teams do not empathize with one another.
When your teams are thrashings, as one of my colleagues call it, get on the phone or Zoom and look at code together.
Happy Collaborating.
