<img height="1" width="1" style="display:none" src="https://www.facebook.com/tr?id=1063935717132479&amp;ev=PageView&amp;noscript=1 https://www.facebook.com/tr?id=1063935717132479&amp;ev=PageView&amp;noscript=1 "> Bitovi Blog - UX and UI design, JavaScript and Front-end development

Project Management |

Conflict-Free Leadership: Roles, Goals, & Expectations [Part 1]

Learn how to mitigate conflict and boost productivity on large-scale software projects by laying a foundation of clear roles, goals, and expectations.

Travis Draper

Travis Draper

Twitter Reddit

conflict-free leadership conflict thrives when teams operate without a strong foundation

Clashing visions, unclear expectations, and team members who don’t pull their weight—issues arise in every industry and on projects of all scales. But they tend to be especially common in large-scale, highly complex software projects. With so many moving pieces, nuanced tasks, and tight deadlines, it’s tempting to dive into a new project and build the plane as you fly it. However, conflict thrives when teams operate without a strong foundation.

So how do you mitigate conflict and boost productivity on your next big job? We’ve done the research and mined our team for real-world scenarios to bring you a basic project management framework. Our framework is built by laying a foundation of clear roles, goals, and expectations for the client and your team and then building a support system with creative problem-solving from a humanistic perspective.

Organizing New Projects

A few years ago, I sat in what should have been a thirty-minute check-in meeting to answer a few questions and offer support when needed. We were building an e-commerce platform, and things seemed to be rolling along from a project management standpoint.

That is until the meeting devolved into a chaotic flurry of discovering duplicated efforts, team members unclear on their individual roles, and the realization that we were dangerously close to missing a critical deadline.

We sat in that meeting for over ninety minutes, reassigning everyone’s individual tasks and deadlines and setting up new workflows. The meeting left a team of bright, enthusiastic developers frantic, stressed, and a little defeated. It also left the project leaders wondering where the disconnect originated and what else could be slipping through the cracks.

These roadblocks and communication breakdowns appear in projects at all levels—whether you’re in a high school science class, organizing a conference, or in daily virtual scrums. It’s easy for team members to feel unclear about their role in the grand scheme.

Often, no one intentionally drops the ball—we can trust our team to do good work. But that can only happen when leadership is strong and clear on a project’s objectives. Leadership must explicitly communicate each role. Otherwise, misunderstandings create unnecessary tension, which in turn engenders conflict and leads to a decrease in productivity and overall morale.

Before transitioning into software development, I worked in theater. I navigated the egos of several people, mine included, to build new, creative projects from the ground up. I often ran into insurmountable conflicts with my collaborators until I learned about Jeff Klein’s leadership framework. Since transitioning into web development, I’ve found that Klein’s process makes a tremendous difference in establishing a workflow with my clients and team. As a bonus, the framework has also significantly contributed to coveted soft skills: collaboration, communication, and leadership.

Defining Roles, Goals, & Expectations

Klein’s framework establishes a consensual bedrock of understanding for project development through clearly defined roles, goals, and expectations. While the principles of this method have ubiquitous applications, I’ve found the framework incredibly impactful in managing software development projects here at Bitovi.


In the context of our leadership framework, roles refer to job titles and descriptions that help clarify organizational hierarchy. Examples of roles might include:

  • Product Owner
  • Frontend Developer
  • Team Lead
  • Junior Developer

Roles are fundamental in establishing a clear flow of communication. A junior developer should have a team leader they feel comfortable approaching with questions or asking for support. Additionally, it should be made clear to the junior developer that the team lead is available to answer questions - defining a straightforward and quick method to solve issues as quickly as they surface.


Goals are the objectives of the project. The list of objectives might be expansive, depending on the scale and timeline. Laying out goals answers the question, “What needs to be accomplished on X day for the project to be considered successful?” Example goals include:

  • Implement X, Y, and Z new features
  • Minimize tech debt in the implementation of these new features
  • Clean up tech debt wherever refactoring takes place
  • Flag instances of tech debt for future clean-up projects (...seriously, let’s clean up this tech debt)

You can break down goals by role, day, and task. Goals must be specific and include a timeline so each team member understands the larger picture (end product) and day-to-day accomplishments (benchmarks).


Expectations are a list of obligations agreed upon by all involved parties. Leadership should establish expectations to maintain proper communication, resolve issues, and help define workflows to benefit the team and encourage productivity. Example expectations include:

  • We expect to have daily stand-ups at 11:00 am
  • We expect everyone to be on time for meetings
  • We expect happy hour Friday drink chats to be available but optional

Defining expectations is a great way to maintain accountability for every team member. A reliable, exhaustive list of expectations should leave little room for surprises throughout a project. It also sets up behavior and workflow assurances, so team members don’t have to guess what constitutes being a team player.

Too often, workflow and quality standards are subjective. By adding specificity to those standards and conveying them clearly to everyone on the team—from leadership down to junior developers—those subjective standards become clearly defined expectations of quality team contribution.

Why Conflict-Free Leadership Matters

At Bitovi, we consult on various projects, and our developers may move between several clients each year. As a result, our team faces varied workflows that they need to be able to drop into quickly and without confusion or conflict.

As I’ve settled into my role as the bridge between developer teams and clients, it has become increasingly evident that no matter the scale, duration, or type of project, we must define the roles, goals, and expectations for each new project. Since its inception, the Conflict-Free Leadership framework has contributed to the success of our developer teams and allowed us to transition into a new consulting gig with confidence.

How to Implement the Conflict-Free Leadership Framework

Okay. You understand the basics of Conflict-Free Leadership and why roles, goals, and expectations are essential. You’ve got a handle on the theory, and now you’re ready to implement the Conflict-Free Leadership Framework. Where do you start?

Prepare for a Discussion

Implementing the Conflict-Free Leadership and project management framework might take time on the front end, depending on your team structure. For example, securing time for a big-picture conversation can be challenging, especially in the development world.

For most teams, big-picture meetings tend to emphasize basic onboarding and insight into a client’s codebase rather than defining roles, goals, and expectations. Be sure to prepare your team to discuss the framework by sending them this post ahead of time, setting an agenda, and making yourself available for questions.

Once the meeting is scheduled (and let’s be honest, sometimes that’s the most complicated step), it’s time to present the framework. It may take time to establish the foundational aspects of Roles, Goals, and Expectations, but it’s worth it! Ensuring everyone has the same understanding of the framework is crucial to its success.

Present the Framework

Conflict-free leadership taking an hour at the outset of a project to outline each team member's role, project goals, and expectations can save time, money, and morale

Think about it like this—that thirty-minute meeting turned ninety-minute scramble, and all the frustration that came with it was avoidable.

Taking an hour at the outset of a project to outline each team member’s role, project goals, and expectations can save time, money, and morale down the line.

In practice, Conflict-Free Leadership looks like a meeting request before any work on the project happens. A sit down with relevant parties to review each role, the goals of the project, and team expectations.

In that meeting, take notes and ask about your team’s roles in the project. If applicable, cover the external team’s roles so you know which gaps they need to fill. Anyone who will have a hand in the project must be accounted for to ensure

Next, reiterate the goals as you understand them, allowing the opportunity for clarification and elaboration. Goal sharing is a good moment for everyone to sync up before work begins.

Goals should be measurable and achievable with realistic timelines agreed upon by all parties. It’s not enough to say, “We’d like to add an observability layer to our system.” If the client has that listed as a goal for the project, a more extensive discussion around objectives, tooling, and usability is required.

Take the time to ask for details about how and why they want something done to prevent mistakes that might bubble up when a developer implements a feature without clear insight into its final use case.

Finally, we discuss expectations to ensure everyone understands how a successful day and project outcome will look.

Are there clear code-commit standards? Are daily stand-ups an expectation, and if so, who attends them? Success is subjective—setting expectations helps define what success looks like for a specific project. The client, the team, and the leadership must share the same definition of success to create it.

Depending on the length of the project, it might be a good idea to schedule another follow-up meeting partway through the project—to check in on the roles, goals, and expectations again. A follow-up meeting gives your team time to formally address anything that may have shifted since the project began.

Closing Thoughts

Miscommunication can completely derail a project. Duplicated efforts, unclear expectations, and unattainable goals lead to unnecessary conflict. It doesn’t have to be this way.

Bitovi’s Conflict-Free Leadership Framework addresses conflict at its source—miscommunication. Teams with clearly defined roles, goals, and expectations are empowered to succeed individually and collectively.

But what if a conflict arises?

Conflict is inevitable. Implementing processes and preventative measures for dealing with conflict will help your team move past conflict more quickly. Check out part two of our series, out soon, for more on how to help your team overcome conflict.

Join our Discord