Manish's – Thoughts and Learnings

Working in a multi-team program often feels like being part of a big fat Indian wedding. Everyone has their own responsibilities, but the chaos is real. People stepping on each other’s toes? That’s bound to happen if boundaries aren’t set and respected. If you’re part of a small engineering team, it can be tricky to keep your scope intact. Balancing collaboration while maintaining your scope is challenging. It’s not just about managing code or APIs, it’s also about handling relationships, having open communication, and knowing when to take a stand. Here are few tips to master this balancing act.

What Your Team Should Do to Keep Boundaries

Clearly Define and Document Your Scope

Imagine explaining cricket rules like “silly point” or “gully” to someone who’s never seen the game. You’d go into every detail, right? Similarly, your team’s scope should be crystal clear. Write down responsibilities, ownership, and boundaries. Use detailed diagrams. Add specifications. If needed, use the trusty old RACI matrix (Responsible, Accountable, Consulted, Informed) to clarify who does what.

For instance, if you’re building an integration layer, don’t just say, “We’ll connect System A to System B”. Document API specs and interfaces in detail. Sit down with the other teams, have written agreements, and avoid “he said, she said” moments later.

Embrace Modular Design

We are champions of jugaad (quick fixes) as Indians. However, trust me, jugaad in software design is a highway to tech debt. Instead, build modular systems with clear boundaries. Use abstraction layers to minimize dependencies between your modules and others.

Sure, abstraction layers might feel like extra work initially, but they’ll save you countless headaches down the road. Imagine this: you’re building a Lego Taj Mahal. If one-part breaks, you don’t want the entire structure collapsing. Modular design ensures that even if someone else’s piece is delayed or broken, your part remains intact.

Keep a Close Eye on Dependencies

Think of your team as part of a relay race. If one runner is late, the entire team is delayed. Track dependencies diligently using tools like Jira or Azure DevOps. Know exactly who’s delivering what and by when.

Once, my team once had a critical dependency from another team. The deadline came and went, and we were stuck waiting and wondering. Turns out, another team wasn't even aware of the deadline. Since then, we religiously track dependencies and raise risks early. Better to ruffle some feathers now than face a meltdown later.

Use Mocks as Lifelines

What if the team delivering your dependency is running behind? Don’t wait around helplessly. Use mock implementations for testing. They act as stand-ins, allowing you to keep moving forward. If your contracts and abstraction layers are well-defined, creating mocks becomes a cakewalk.

What Your Team Should Not Do

Knowing what to do is great. But equally important is knowing what NOT to do. Here’s a list of don’t to keep your team from stepping on others’ toes.

Don’t Criticize Other Teams’ Work

Nobody likes a nosy neighbour, right? Instead of picking on another team’s quality or delays, offer constructive feedback. A casual, “Let me know if I can help” makes a big difference. It is much better than a snarky, “Why isn’t this done yet?”

Like to learn more about giving constructive feedback, read my earlier post – Maximizing Professional Growth: The Art of Constructive Feedback – Manish’s – Thoughts and Learnings

Don’t Be a Cry Baby

Raising red flags for every small hiccup isn’t helpful. For example, if a data field change format unexpectedly, can your team adjust without escalating? If yes, do it. Constantly escalating trivial issues frustrates others and dilutes your team’s credibility. Pick your battles wisely and save escalations for when they truly matter.

Don’t Take Over Other’s Responsibilities or Overstep Boundaries

Once, I saw an over enthusiastic colleague fixed an API from another team without asking. He thought he was helping, but guess what? His fix broke their entire flow. Lesson learned – stick to your scope. If something’s wrong, flag it politely and let the responsible team handle it. Respect their space, and they’ll respect yours.

The Balancing Act

Thriving in a multi-team program is like being the head of the bride’s family at a Indian wedding. You have to manage your side of the event while coordinating seamlessly with everyone else. Keep communication clear, respect boundaries, and tackle challenges with a solution-focused mindset.

At the end of the day, the goal isn’t just to deliver your piece of the puzzle. It’s also about helping make the entire program a grand success. Keep these tips in mind, and you’ll not only survive but thrive in this multi-team chaos!