By Leonardo Mattiazzi, Vice President, International Business for Ci&T
At the advent of the industry, writing software was an individual’s task. This was clear as the developer’s touch was all over the final product. But over time, that personal touch seemingly disappeared. As the industry evolved, software was called upon to solve increasingly larger problems, computers got smaller and the task of development became too large for a single individual. It fast became a team sport and processes were put in place to make the development more efficient.
The growth of the industry was of course a good thing, resulting in flourishing project management, new collaboration tools and the creation of processes to ensure adherence to standards. As a result, today Nearshore teams can work with clients to deliver cost-effective projects quickly and efficiently.
But during the process of standardization, which followed in the footsteps of mass production in manufacturing, something was lost. With an ever-increasing demand for new applications, as well as the need to maintain existing ones, scalability (in the sense of being able to produce enough software) became more important. In an effort to become less dependent on artisan-developers, following repeatable processes became more important than getting the best outcomes. In desperation to reduce costs, paying the lowest amount for a unit of work became the only unquestionable metric. The “software factory” became the status quo.
Is this scenario ideal for achieving business goals? Is it something companies should settle for? If the goal is merely to survive, then the software factory paradigm is adequate. But if the goal is to build successful applications that contribute to business growth, then something more is needed. Nearshore providers need to perform at the highest possible level, and mass-production simply won’t do. What is needed is a high-performance development team. In this two-part post, I will explain the qualities of a high-performance team, and why organizations should look to Nearshore providers that cultivate these types of teams whose skills will benefit resulting projects.
So just what is a high-performance team?
A high-performance team is one that bucks the “software factory” trend and ensures consistent delivery of business value in the projects it delivers. To do this, each high-performance team embodies five distinct components that contribute to the delivery of value. These are: talent, skills mastery, autonomy, a lean frame of mind and vision/shared purpose.
Let’s consider these components individually, and how together they contribute to a more effective outcome in software projects.
Seems obvious, doesn’t it? When building a team of software developers, everyone wants to draw from a deep talent pool and look for developers with the best skill sets. However, the mass-production concept has led many companies to overlook this crucial factor. With a market that always grows faster than the overall economy – not to mention the high turnover rate – why should companies care about talent? Ostensibly, it is much more expensive to attract and keep the best talent then to live with the rotation of low-cost, adequate professionals.
Nearshore providers that need to build business-critical applications for their clients can create high-performance teams only by recruiting the best and brightest developers around, and then focusing on retaining that talent with a culture and path for professional development that inspires them to stay. This means looking to the best technical and engineering universities for potential recruits, bringing them into the fold early and creating an environment that breeds passion, enthusiasm and growth.
Talent is a great place to start, but it’s just the beginning. The next step in constructing a high-performance team is skills mastery. The tendency for too many companies is to create a factory-like atmosphere, which emphasizes developing software repeatedly, following prescriptive processes and specs. This instills the idea that an individual could be replaced at any time by someone else, leaving little room for passion in your work.
Malcolm Gladwell, in his 2008 book Outliers, repeatedly discusses the “10,000 hour rule,” which essentially states that to truly master a skill, you must practice a single task for 10,000 hours. But there is a catch that may go unnoticed: you have to be passionate enough about that task to want to practice it for 10,000 hours. Most of the “outliers” mentioned by Gladwell have reached 10,000 hours even before starting their professional careers. More than anything it’s about starting early and learning fast, and no one does that without passion. Companies can facilitate mastery by promoting a culture of continuous learning and passion in developers’ daily tasks, and introducing concepts like Agile methodologies and PDCA (Plan-Do-Check-Adapt) cycles that constantly push their ability to adopt new techniques and perfect old ones. In doing so, they can ensure that developers are constantly mastering the techniques that will turn them into seasoned, multi-skilled practitioners, and make them essential contributors to high-performance teams.
Communication also plays a crucial role in skills mastery. Emphasizing direct, daily communication between team members and short cycles of feedback reinforces the skills that have been learned and helps identify where improvements can be made. Highly skilled teams will be highly productive teams, contributing to the overall goal of high-quality software and consistent value delivery.
The second half of this post will discuss the final three key traits of a high-performance team: autonomy; a Lean frame of mind; and vision and a shared purpose. To receive the best return possible on their software projects, companies should seek Nearshore providers that buck the software factory trend within their own organizations, identify these traits in their own employees and cultivate them into high-performance teams.