Kaizen Teams

Dropdown

Table of Contents

Time to read

·

12

Published on

·

September 15, 2025

Last updated on

·

February 16, 2026

Ariel Erlijman, Tech Leader & Agile Coach at Kaizen Softworks

Ariel Erlijman

Part-time comedian

Tech Leader & Agile Coach

Software Outsourcing: From Extra Hands to a Core Partner

Published on

·

February 23, 2026

Last updated on

·

February 16, 2026

Time to read

·

12

Ariel Erlijman, Tech Leader & Agile Coach at Kaizen Softworks

Ariel Erlijman

Tech Leader & Agile Coach

What’s the hidden cost of high team turnover in software development? It’s not just missed deadlines or mounting frustration. It’s the constant re-explaining of your business. The knowledge that quietly walks out the door. And the sinking feeling that you're managing vendors, not building with partners.

This is all too common in outsourcing, where the relationship rarely goes beyond being just an “extra pair of hands.” But what’s possible when a collaboration is built to last?

This is the story of one such partnership. A journey that began in 2016 with a single developer and grew into a fully integrated team of 30. It shows what happens when a relationship is built on stability, shared ownership, and mutual trust.

The Foundation

Our journey with our client started with a clear goal: to merge multiple legacy systems into a single modern web platform that facilitates electronic customs and border entry filings for the US and Canada.

Our involvement began with just one developer joining our client’s team. But their first task wasn’t writing code, it was flying to our client’s headquarters. We felt it was essential to sit at the same table, to listen, and to understand the “why” before ever building the “what.” 

From Execution to Strategic Insight

In the early years, our relationship grew not just because of the quality of our code, but because of the quality of our questions.

Our philosophy is to invest heavily in our people’s well-being and growth. With a horizontal culture built on participatory decision-making, competitive salaries, and top-tier benefits, we’ve created an environment where high performers choose to build a career.

That translates directly into value for our clients. With just 5% annual turnover, and 0% among key roles, the team our clients start with is the team they grow with.

This is where the value of a stable team really comes into focus. When people stick around, they have the opportunity to compound business context, understanding not only how the system works, but why it matters. They start to see around corners, anticipating challenges and contributing to strategy, not just executing tasks.

We flagged problems in specs before they became blockers. We suggested simpler solutions that saved time and money. That’s when the relationship started to shift. It was the first sign of something deeper taking shape.

From Collaboration to Shared Ownership

The strength of our partnership was proven when our collaboration grew beyond the initial project. Our client entrusted us with four more of their development initiatives, which brought us to a pivotal moment: how to scale our team to meet this new level of responsibility.

The pivotal moment wasn't a single event, but a gradual shift in mindset. In many projects, a client dictates the workflow. But as we demonstrated our deep understanding of their goals, the conversation changed. We earned the trust to not just follow a process, but to define it. 

That level of trust unlocked a new level of collaboration, proven by the tangible responsibilities we began to co-own.

We gained the autonomy to negotiate technical scope with stakeholders and took charge of defining the development processes.

The most significant proof of this partnership emerged when two key, high-responsibility positions on the client’s team became vacant. First, the critical role of coordinating all production deployments, a position of immense operational responsibility, was assumed by one of our team leaders. This shifted our role from simply building software to owning its safe delivery.

Shortly after, when a veteran developer who handled complex custom work also departed, the critical tasks were not filled by a new hire. Instead, the client entrusted these responsibilities to our entire team. Stepping up to absorb those tasks together was the moment we truly became co-owners of the project, sharing a deep sense of accountability.

A Single Team, A Shared Identity

Eight years after that first visit, the lines between our teams have all but disappeared.

This deep connection was built on more than just good work. It grew from our commitment to face-to-face team building, organizing more trips as the team grew, and from finding common ground in the small things, like talking about the same sports, TV shows, and movies. This shared culture turned daily meetings into genuine conversations between colleagues.

The result is an integration so complete that, in the words of the team:

“We’re the same. There’s practically no difference who is who. There is no ‘us and them.’”

When you give a partnership the space to grow, you don’t just get better software, you get the stability you need to innovate and grow.

What’s the hidden cost of high team turnover in software development? It’s not just missed deadlines or mounting frustration. It’s the constant re-explaining of your business. The knowledge that quietly walks out the door. And the sinking feeling that you're managing vendors, not building with partners.

This is all too common in outsourcing, where the relationship rarely goes beyond being just an “extra pair of hands.” But what’s possible when a collaboration is built to last?

This is the story of one such partnership. A journey that began in 2016 with a single developer and grew into a fully integrated team of 30. It shows what happens when a relationship is built on stability, shared ownership, and mutual trust.

The Foundation

Our journey with our client started with a clear goal: to merge multiple legacy systems into a single modern web platform that facilitates electronic customs and border entry filings for the US and Canada.

Our involvement began with just one developer joining our client’s team. But their first task wasn’t writing code, it was flying to our client’s headquarters. We felt it was essential to sit at the same table, to listen, and to understand the “why” before ever building the “what.” 

From Execution to Strategic Insight

In the early years, our relationship grew not just because of the quality of our code, but because of the quality of our questions.

Our philosophy is to invest heavily in our people’s well-being and growth. With a horizontal culture built on participatory decision-making, competitive salaries, and top-tier benefits, we’ve created an environment where high performers choose to build a career.

That translates directly into value for our clients. With just 5% annual turnover, and 0% among key roles, the team our clients start with is the team they grow with.

This is where the value of a stable team really comes into focus. When people stick around, they have the opportunity to compound business context, understanding not only how the system works, but why it matters. They start to see around corners, anticipating challenges and contributing to strategy, not just executing tasks.

We flagged problems in specs before they became blockers. We suggested simpler solutions that saved time and money. That’s when the relationship started to shift. It was the first sign of something deeper taking shape.

From Collaboration to Shared Ownership

The strength of our partnership was proven when our collaboration grew beyond the initial project. Our client entrusted us with four more of their development initiatives, which brought us to a pivotal moment: how to scale our team to meet this new level of responsibility.

The pivotal moment wasn't a single event, but a gradual shift in mindset. In many projects, a client dictates the workflow. But as we demonstrated our deep understanding of their goals, the conversation changed. We earned the trust to not just follow a process, but to define it. 

That level of trust unlocked a new level of collaboration, proven by the tangible responsibilities we began to co-own.

We gained the autonomy to negotiate technical scope with stakeholders and took charge of defining the development processes.

The most significant proof of this partnership emerged when two key, high-responsibility positions on the client’s team became vacant. First, the critical role of coordinating all production deployments, a position of immense operational responsibility, was assumed by one of our team leaders. This shifted our role from simply building software to owning its safe delivery.

Shortly after, when a veteran developer who handled complex custom work also departed, the critical tasks were not filled by a new hire. Instead, the client entrusted these responsibilities to our entire team. Stepping up to absorb those tasks together was the moment we truly became co-owners of the project, sharing a deep sense of accountability.

A Single Team, A Shared Identity

Eight years after that first visit, the lines between our teams have all but disappeared.

This deep connection was built on more than just good work. It grew from our commitment to face-to-face team building, organizing more trips as the team grew, and from finding common ground in the small things, like talking about the same sports, TV shows, and movies. This shared culture turned daily meetings into genuine conversations between colleagues.

The result is an integration so complete that, in the words of the team:

“We’re the same. There’s practically no difference who is who. There is no ‘us and them.’”

When you give a partnership the space to grow, you don’t just get better software, you get the stability you need to innovate and grow.

Related Articles

·

May 15, 2026

Can AI Safely Apply Changes Across Microservices?

Learn how AI can apply changes across microservices when service ownership, message contracts, DTOs, and architectural context are clearly defined.

12 read time

Read more

Applying changes across microservices is difficult because business logic is distributed across multiple services, each with its own data, contracts, and responsibilities.

In our experiment at Kaizen Softworks, we tested whether an AI system could safely apply coordinated changes across a microservices architecture using only minimal input.

Short answer: Yes, but only when the AI has enough architectural context.

Why are coordinated changes in microservices so hard?

In distributed systems, a single business change rarely affects just one service.

It often requires:

  • Updating multiple microservices
  • Modifying message contracts
  • Keeping DTOs (Data Transfer Objects) consistent
  • Respecting domain boundaries defined by Domain-Driven Design (DDD)

Key entities in this system:

  • Microservice: An independently deployable service responsible for a specific domain
  • Aggregate (DDD): A cluster of domain objects treated as a single unit
  • DTO (Data Transfer Object): A structured format used to transfer data between services
  • Message/Event: A communication mechanism between services

The complexity is not in the code, it’s in the relationships between components.

The experiment: Can AI reason across services with minimal input?

We designed a controlled experiment to test whether an AI model could apply system-wide changes with limited information.

Input given to the AI:

  • Message definitions (events between services)
  • DTOs (data contracts)

Tasks the AI had to perform:

  1. Identify affected aggregates
  2. Determine service ownership
  3. Apply coordinated changes across services
  4. Maintain consistency in messages and DTOs

In other words, the AI had to behave like a software architect, not just a code generator.

What was the biggest obstacle?

The biggest challenge was not technical, it was contextual.

Before and after diagram showing how ambiguous microservice names prevent AI from understanding service ownership, while aggregate-to-service mapping helps AI apply safe coordinated changes.

Problem: unclear service naming

Instead of descriptive names like:

  • order-service
  • billing-service

Our services were named:

  • john
  • sally
  • roger

This removed any semantic clues about responsibility.

Result: The AI could not infer which service owned which domain logic.

The missing piece: aggregate ownership mapping

To solve this, we introduced a simple but powerful structure:

Aggregate → Service mapping

  • Order → john
  • Shipment → sally
  • Invoice → roger

This created a clear relationship between domain concepts and system components.

Once ownership was explicit, the architecture became understandable.

How we used AI to generate architectural context

Instead of building this mapping manually, we used AI to analyze the codebase and extract:

  • Where each aggregate was defined
  • Which microservice implemented it
  • The relationship between domain and infrastructure

The result was a machine-readable architecture map.

In practice, we used AI to generate the context that AI itself needed.

Results: Can AI safely apply distributed changes?

With the architecture map in place, the AI was able to:

  • Trace message flows across services
  • Identify affected aggregates
  • Locate the correct microservices
  • Apply coordinated updates
  • Maintain consistency between DTOs and messages

While not perfect, the system worked reliably as a proof of concept.

What is the real limitation of AI in microservices?

The main limitation of AI is not code generation, it’s architectural understanding.

Without knowing:

  • Which components exist
  • How they relate
  • Who owns what

AI cannot safely modify a distributed system.

AI performance depends more on context quality than model capability.

When can AI safely modify microservices?

AI works well when:

  • Aggregate ownership is clearly defined
  • Message contracts are explicit
  • Architecture is structured and consistent

AI struggles when:

  • Naming is ambiguous
  • Relationships are implicit
  • Context is incomplete

Simple rule: If the architecture is clear, AI can reason. If not, it guesses.

Final thoughts

This experiment revealed something important:

AI doesn’t fail because it can’t write code.
It fails because it can’t see the system.

As teams move toward AI-assisted development, the focus will likely shift from:

Writing better code to Designing better systems for machines to understand

At Kaizen Softworks, we see this as a foundational shift.

Because when AI can understand architecture, it doesn’t just generate code, it helps evolve systems.

·

Mar 13, 2026

How We Make Decisions Without Managers

We don’t have traditional managers. This is how we make decisions and keep things moving.

12 read time

Read more

There's a myth that in flat organizations, everyone decides on everything.

That's not how it works. At least not at Kaizen.

When people hear "no managers," they often picture one of two extremes: either total chaos where nobody is accountable, or endless meetings where 80 people vote on which coffee to buy. The reality is neither.

Not everyone decides on everything. Not everyone votes. What we do have is a clear set of decision-making methods that we choose based on context.

It depends on who's affected and how deep the impact goes

Before choosing how to decide, we ask ourselves a few questions:

  • Who is affected? A decision that only impacts one team doesn't need the whole company involved. A decision that affects everyone's daily work does.
  • How deep is the impact? Changing the office furniture is wide but shallow. Changing the salary model is deep and lasting.
  • Is it reversible? If we can easily undo it, we can move fast and just inform. If it's hard to reverse, we slow down and include more people.
  • How urgent is it? And here we're careful to distinguish real urgency from anxiety, the pressure to decide quickly because someone already has "the answer" in mind.

These dimensions help us pick the right method. Not every decision deserves the same process.

Our decision-making toolkit

Over the years, we've landed on a few methods that we use depending on the situation:

1. Role-based decisions

Some decisions belong to a specific role. If someone owns a responsibility, say, office logistics or hiring for a team,  they decide within that domain. No committee needed. The key is that roles are transparent: everyone knows who owns what, and the scope of each role's authority is clear.

2. Advice Process

When a decision doesn't clearly belong to one role, or when it crosses boundaries, we use the advice process. Here's how it works:

  1. Someone takes the initiative. They identify the problem and own the process.
  2. They gather input from people who are affected and people with expertise.
  3. They seek advice, real conversations, not rubber-stamping.
  4. They make the decision and communicate it, including what advice they incorporated and what they didn't (and why).

The decision-maker is not a committee. It's one person (or a small group) who takes responsibility. But they don't decide in isolation, they bring in the perspectives that matter.

We sometimes call this "Team Advice" when a working group forms around an issue that doesn't naturally fall into anyone's area, and "Area Advice" when a team opens up a topic that exceeds their own scope.

3. Consent (not consensus)

Consent is not "everyone agrees." Consent means "no one has a strong enough objection to block this." We do use a poll, but not to count votes — we use a 1-to-5 scale to measure the level of agreement and surface objections, not to let the majority rule.

We use it in two flavors:

  • High-participation consent: For decisions with deep, company-wide impact. This is our most expensive and slowest method, which is exactly why we reserve it for high-impact decisions that affect many people. The Board sets the boundaries, for example, when we moved offices, they defined the monthly budget. Then a working group produced proposals, collected feedback, evolved them, and the whole company expressed their position for the final decision. Silence is not approval; we explicitly ask people to weigh in, even if it's just "I have no objection."
  • Lightweight consent: For decisions that are broad but not deep. Participation is optional, anyone who's interested can jump in. We share the proposal, open a window for objections, and if nobody opposes, we move forward. This gives us speed without sacrificing transparency. If nobody engages, that's a signal too, maybe the proposal doesn't add enough value, or we're using the wrong channel.

4. Inform, don't fake-consult

Not everything needs participation. When a decision has already been made through a legitimate process, the right move is to inform, not to fake-consult. One of the fastest ways to kill self-management is to ask for feedback and then ignore it. If you're not going to change course based on input, don't ask for it, just be transparent about the decision and the reasons behind it.

What we explicitly avoid

  • Decision by Voting. In a company context, majority rule creates losers. And losers become detractors, often generating more resistance than an autocratic decision would have. Instead of voting, we prefer to evolve a proposal through feedback until it's "good enough for now," and then introduce a review point to adjust later. If voting happens at all, it's the cherry on top, not the main course.
  • The "surprise" approach. Working behind closed doors and then unveiling a finished decision is a recipe for frustration. Adults don't need surprises. Adults need to feel like they're part of the process. The complaints that follow a surprise aren't about the decision itself, they're about not being included.

Why we work this way

We didn't adopt these methods because they're trendy. We adopted them because they solve real problems:

  • Better decisions. When you include affected people, you get information you wouldn't have had otherwise. Ideas emerge that no single person would have come up with alone.
  • Less resistance. A person who feels heard is far less likely to resist a decision, even one they wouldn't have made themselves.
  • Faster execution. It sounds counterintuitive, but participative decisions often execute faster because people already understand and support them. The time you "save" by deciding alone, you spend later managing pushback.
  • Distributed authority. When people can make decisions within their domain without escalating everything to a founder, the organization scales. The bottleneck disappears.
  • Resilience. If a shared decision fails, the group adjusts together. If a top-down decision fails, the blame falls on one person and the chances of proactive correction drop.

The real principle behind all of this

Transparency is the foundation. Every method we use, from role-based decisions to high-participation consent, works because information flows openly. People know what's being decided, who's deciding it, and how they can participate.

Horizontal doesn't mean structureless. It means fewer hierarchical levels, clearer roles, and intentional decision-making processes that match the weight of each decision.

Not everyone decides on everything. But everyone knows how things get decided.