Beyond the obvious criteria such as the technology stack expertise, domain experience, and value, hiring a software development partner (i.e. outsourcer) is entirely 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, bitter-sweet 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 nickeled 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 some combination of dishonesty, coin-operated behavior, and low quality of 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 tag line was “upsource your software development” because we associate the word “outsource” with the aforementioned bad behaviors, and we wanted to define ourselves in a manner that illustrated our deliberate effort to be different.
The values and associated behaviors we wanted to institutionalize within CodeStringers were: integrity, innovation, and craftsmanship.
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 price and timeline from the outsourcer to deliver on 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 who they feel cheated by, 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:
- Provide some assistance in planning without charging you (betting that their effort will result in you awarding them the business);
- Suggested that a paid “discovery” phase is needed during which requirements would be more fully defined to ultimately get to a more accurate estimate;
- 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 off any partnership based on telling lies in order to secure your business under false pretenses, and then gouging you thereafter, is a short-term strategy that CodeStringers does not embrace.
Many outsourcers are like vending machines. Put in coins and 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, rather we exist to make our clients more successful. This often means:
- 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 client requests without critical analysis of 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.
- Ideate for the client. Good outsourcing partners will make the effort to understand your market, competitors, buyers, users, and the problems your product is intending 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.
- Allow clients to own all intellectual property invented during a partnership. CodeStringers’ standard contracts unambiguously declare that our clients own all intellectual property.
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 the quality of the code. 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 onto the next. Product-focused organizations set standards internally that are often higher than those of the client.
Whether you choose CodeStringers or not, we urge you to assess other vendors using these criteria. They increase the likelihood of success.
However, if you buy into our philosophy and you are looking for a software development partner, then please contact us. We would honor the opportunity to help bring your ideas to life.
CodeStringers – A quality-focused boutique software development company