Integrity, Innovation, and Craftsmanship: Three criteria to evaluate software development partner

Beyond the obvious criteria such as technology stack expertise, domain experience, and value, hiring a software development partner (i.e., an outsourcer) is ultimately about trust. For my part, I’ve worked in the software industry for nearly 25 years, but only five of those years have been as an outsourcer.  For the first 20 years, I was on the other side of the proverbial table, where I hired and/or worked with many outsourcers. With few exceptions, I found the experiences working with outsourcers to be, at best, bittersweet and, at worst, absolute nightmares.

At a micro level, the reasons for the nightmares were some combination of poor communication, over-promising and under-delivering, and feeling nickel-and-dimed for highly questionable “increases in scope” that led to an endless stream of “change orders” (i.e., demands for more money to do the same job).

At a macro level, I find the performance of most software development partners to be a combination of dishonesty, coin-operated behavior, and low-quality work.

When we started CodeStringers, our leadership team wanted to be different -- to genuinely set ourselves apart from the typical outsourcer. In fact, our first tagline was “upsource your software development” because we associate the word “outsource” with the aforementioned bad behaviors, and we wanted to define ourselves in a way that underscored our deliberate effort to be different.

The values and associated behaviors we wanted to institutionalize within CodeStringers were: integrity, innovation, and craftsmanship.

Integrity

Organizational integrity, or the lack thereof, manifests itself in many ways through the lifecycle of a business relationship, but it all starts at the very beginning of a typical client/outsourcer relationship. It usually begins like this:

You call an outsourcer to build a new software application. Maybe you’ve got a detailed specification and user interface designs. Or maybe you just have a few pages of notes. After an initial meeting to get acquainted, you request a quote and timeline from the outsourcer to meet your requirements. A few days later, the outsourcer gives you the budget and the time frame that you were hoping to hear, and you agree to move forward.

As the planning progresses, it becomes apparent that your initial requirements were incomplete. You might have overlooked entire features, or perhaps you included all features but didn't provide detailed acceptance criteria, use cases, or user interface designs. In agile terms, this is often referred to as a lack of a 'definition of done'. When the outsourcer notices these missing elements, they highlight the increased scope. Consequently, they inform you that they will need to significantly expand both the budget and the timeframe. The revised budget and timeframe are so substantial that, had you been aware of them during the bidding stage, you likely wouldn't have agreed to them. This scenario is a common challenge in software development projects.

This is where the nightmare begins. The client is now locked into a relationship with an outsourcer they feel has cheated them, and consequently, the two parties no longer trust each other and are unable to create a successful software product.

---

So what should have happened?

Most importantly, the outsourcer should have collaborated with you during the pre-sales process to point out the missing requirements and done one of the following:

1. Provide some assistance in planning without charging you (betting that their effort will result in you awarding them the business);

2. Suggested that a paid “discovery” phase is needed, during which requirements would be more fully defined to ultimately get to a more accurate estimate;

3. We proposed structuring our relationship differently from a traditional fixed bid for a defined scope. Instead, we offered to provide a team that acts as an extension of your organization. This team would be available on a monthly cost-per-resource basis. This approach allows for flexibility in scope changes and requirement refinements during the development process, much like an internal software development organization operates.

Accurately setting a client’s expectations and clearly communicating is critical to the success of a partnership. Starting any partnership by telling lies to secure your business under false pretenses, then gouging you thereafter, is a short-term strategy that CodeStringers does not embrace.

Innovation

Many outsourcers are like vending machines. Put in coins, and the code comes out. In other words, they build EXACTLY what you ask them to build, nothing more. Unfortunately, it's not uncommon for a software development partner to be aware of a client's product's likely failure, yet proceed to build it. Making matters worse, the outsourcer might also include terms in the contract that stipulate joint ownership of all intellectual property. This approach can be detrimental to the client's interests.

CodeStringers feels that this behavior is egregious and shameful. Our goal is NOT simply to build code for our clients; we exist to make our clients more successful. This often means:

1. At CodeStringers, we believe in challenging our clients' ideas, especially when they seem misguided. In the software industry, ideation is a key part of design thinking. However, not all ideas should be implemented. Many outsourcing companies simply agree to clients' requests without critically analyzing the problems or solutions. We see our role differently. Our job is to be a partner in creating software that achieves user adoption, and for commercial products, generates revenue and profitability. We consistently question and refine our clients' ideas to improve them. In every project we've undertaken, our team has either contributed to or directly created intellectual property for our clients.

2. Ideate for the client. Good outsourcing partners will make the effort to understand your market, competitors, buyers, users, and the problems your product is intended to solve and will then generate their own ideas about how the product might more effectively and uniquely solve those problems. This often leads to the creation of intellectual property.

3. Allow clients to own all intellectual property invented during a partnership. CodeStringers' standard contracts unambiguously declare that our clients own all intellectual property.

Craftsmanship

Most people think of craftsmanship at an individual level. A cabinet maker is a craftsman. That word is less frequently used to describe organizations.

Every organization has its own culture. This culture often stems from the organization's norms and values. In some cases, leaders do not deliberately shape this culture. When this happens, the culture naturally evolves. It reflects the personalities of the people in the organization.

At CodeStringers, we established core values from the start. We expect every team member to adopt and embody these values. The most important of these is craftsmanship.

Craftsmanship is about building high-quality, manageable, high-performance software, which ultimately comes down to code quality. We recruit and train personnel to share this value. I convey the same message to our team members as I do to my children: We tolerate mistakes. Failing to own and fix them is not.

At an organizational level, we describe this trait as being “product-focused” versus “project-focused”. Project-focused organizations spend more time trying to obtain the client’s acceptance so they can end the project, be paid, and move on to the next. Product-focused organizations set internal standards that are often higher than the client's.

Conclusion

Whether you choose CodeStringers or not, we urge you to assess other vendors using these criteria. They increase the likelihood of success.

CodeStringers - A quality-focused boutique software development company