Productivity Ratio: Understanding the “invisible work” of software development

Productivity Ratio: Understanding the “invisible work” of software development

Project Management, Software Development

Curated by: Sergio A. Martínez

We know that software development is not all just coding. As with any big project, there are plenty of tasks that must be fulfilled to create an effective end product, such as stakeholder supervision, decision-making, problem-solving, communication, and time management. Which is why it is  essential to have a clear understanding of the business goals of the software being developed, while also analyzing and interpreting the user requirements that must be worked into the development phase.

When-Excel-is-not-enough-icono

That’s part of the reason why productivity in this context is a tricky thing to track. Sure, you can see how long it takes to reach the end goal and measure it against timelines and expectations, but that doesn’t take into account all the nuances of software creation, as well as the challenges of debugging, refactoring, tweaking, editing and other tedious but crucial elements of every successful project. And this is further complicated by progress not always being linear — as soon as you start working on a project, it’s almost certain things will follow their own kaleidoscope-like paths that don’t always make sense from the outside. 

With all that, it might seem that tracking productivity is like nailing jelly to a wall: not an easy task by any stretch of the imagination, and sadly without a one-size-fits-all solution. Doing the required following isn’t impossible, though, but it requires finesse and forethought to obtain meaningful results. It also requires being aware of the “invisible work” going into the development of an application, and it requires having a complete understanding of how that many pieces fit together. Unfortunately, for some teams, ignoring the tediousness of tracking productivity can be seen as more desirable than going through the hassle. However, with the correct approach, any team can achieve such a goal.

Getting ratio’d

Productivity Ratio

Working with other professionals like designers, business analysts, or testers, is part of every software development project, so good collaboration skills are necessary to reach any goal. Furthermore, making sure that the tools you are using are appropriate for the task ahead can have a dramatic impact on how successful the project would turn out to be in the long run. All these requirements mean that a positive outcome demands a spectrum of skills, which makes the whole process more challenging, and not all of them are obvious at a first glance. In the words of this Crossing the Equator article:

“This invisible work increases the communications gap between the hidden, almost abstract world of coding on the one side and that of marketers, purchasers, and investors on the other. It’s a gap that can cause frustration and misunderstanding and can lead to employee turnover and a slowdown of business growth. It is usually the responsibility of engineering leaders to close this gap.”

In other words, measuring «invisible work» can be difficult due to the complexity of any project. While time and effort can obviously be used to gauge progress, many intangible elements must be factored into the equation, but it’s hard to quantify the value of research, problem-solving strategies, code refactoring, and investigating emerging technologies that all help to improve software quality. In addition, developers must often adjust their efforts on the fly if stakeholders change their expectations or new information comes in. As a result, measuring invisible work requires an experienced team who understands what needs to be tracked and how to factor it into the overall process. And one of the more interesting approaches to this comes from a very simple formula: productivity ratios.

Productivity ratios in software development are the gauge by which you measure whether or not a process is successful, indicating the amount of work completed versus the amount of time and effort expended. In other words, it looks at how much time and resources have been invested in a project, such as coding and bug fixes, against the end result. The productivity ratio, consequently, it’s an important metric for gauging how effective a development team is at producing quality work. And understanding how to calculate it can be an invaluable tool for ensuring a project’s success. The formula to do so can be expressed as the following:

productivity ratio

The tricky part, however, is how to define what the input and the output mean in the context of development. The most common approach is looking at the basic resources that go into the project (work hours, number of developers, cost per hour, among others), against a specified result, like development milestones reached, user stories, pull requests, and many others, with the general idea that something is being produced continuously. 

The result of the equation is then compared to a baseline (industry standards, or past development story, for example) to obtain an estimate of the total productivity of a given team. But how does this tie back to the invisible work involved in software development? Coming back to the Crossing the Equator article:

“It’s a human-focused thing. It also applies to collaboration, knowledge sharing, and team-building activities. Successful organizations build products that customers love, which can only happen when the right people are involved and treated correctly. Teams cannot afford to hire people who merely hit the keyboard to write code without any profound understanding of or connection to the end user. Understanding the business means understanding its processes and goals and ensuring full team alignment.”

A different way to look at development

Productivity Ratio

In short, without a holistic view of development, a productivity ratio cannot work as is because a lot of the effort is not directly apparent in the final product (like planning, writing documentation, ensuring clear communication between stakeholders, managers, and developers, implementing and maintaining the adequate tools, observing security, refactoring the code, etc.), but it’s required to guarantee the timely delivery of a product, its quality, and the overall success of it. 

After all, putting all the focus on coding is not enough and in fact can lead to disaster if other aspects of the project such as design, testing, debugging, and the actual use case are not taken into consideration. Without properly assessing these elements a lot of issues can arise while rolling out the software to customers resulting in wasted effort and resources. That last part is key: developers should take an all-encompassing approach by focusing on the final users as the overall destination of the whole process, and what they are getting from the whole ordeal is, perhaps, the most important point of all. Consequently, an effective productivity ratio should be defined less in terms of input/output, and more like:

productivity work

The core of this approach is to stop seeing the development process as an isolated black box where effort goes in and results come out, and instead get into a mindset of the “total work” output by a team against what the client and final user will be receiving. This should not just be an abstract idea but rather a value that’s central to all efforts during production, helping align everyone with a clear goal. Additionally, when strong ties exist between a software development team and its users, trust is established allowing for up-front feedback before any changes or upgrades would be made, all but ensuring that technical implementations fit with user expectations. Bottom line – all software development projects should prioritize the user experience, helping teams align their efforts from day one. Making sure everyone understands and is deeply invested in this user focus allows for more meaningful and consistent collaborations internally, bridging the gap between the visible and invisible work. Ensuring there is a clear baseline for the productivity ratio, will end up manifesting into an ideal, successful product that satisfies users completely.

The Key Takeaways

  • Productivity is always an important concern for any software development project because it can give a clear picture of the effort and resources put into development.
  • One of the biggest challenges of tracking productivity is the “invisible work” involved in creating a successful application, which is never obvious in the final product.
  • A successful approach might be the “productivity ratio” that measures the input against the output of any project, but it needs to be used carefully to consider invisible work.
  • To that end, keeping the focus on the final product that the user will be receiving can give a better idea of the productivity of a team, comparing the ratio of effort put in versus what the user will be getting.

Scio is an established Nearshore software development company based in Mexico that specializes in providing high-quality, cost-effective technologies for pioneering tech companies. We have been building and mentoring teams of engineers since 2003 and our experience gives us access not only to the knowledge but also the expertise needed when tackling any project. Get started today by contacting us about your project needs – We have teams available to help you achieve your business goals. Get in contact today!

Do you want to be a great software developer? Embrace a Growth Mindset

Do you want to be a great software developer? Embrace a Growth Mindset

Scio, Software Development

Curated by: Sergio A. Martínez

What makes one a great software developer? When you work in a field where there is no “right” way to do things, this can be a pretty important question. Some say that the best developers are those who can find creative solutions to difficult problems, willing to experiment and take risks, always learning from their mistakes. Others say that a great developer has a strong understanding of the latest technologies and trends, enabling them to think outside the box and come up with new and innovative ideas. And yet others say that a good developer is simply one who writes good, stable code with discipline and consistency.

Cloud-Computing-2023

Of course, all of these are very good qualities for a software developer to have, but here at Scio, we think that there’s something else involved, a “secret ingredient” of sorts that every developer can have if they put in the necessary effort and that we encourage as often as we can: a growth mindset.

What is a growth mindset? Simply put, it’s the belief that intelligence and ability can be developed through hard work and practice. It means having the ability to constantly learn new things, adapt to new situations and be open to feedback with a willingness to experiment. It’s never getting too comfortable with your skills because the industry is always changing. We believe that the best developers are always learning, always growing, and always looking for ways to improve.

The research of Stanford University psychologist Carol Dweck has shown that people with a growth mindset are more likely to persevere in the face of setbacks, take on challenging tasks, and embrace failure as an opportunity to learn. With this, you can see why any great developer would know that having a growth mindset is critical for success. Your skills can be developed through hard work, determination, and persistence, and this mindset allows you to approach challenges with a positive attitude and the belief that you can overcome them. It also gives you the chance to learn from your mistakes and view “failure” as an opportunity to evolve. Without a growth mindset, it is easy to become discouraged when faced with difficult problems or to give up when encountering setbacks. Getting yourself into this headspace will leave you better equipped to continue growing as a developer.

Developing a growth mindset

The rise of the industry-specific Cloud: Here’s everything you need to know

As we said, a growth mindset believes that intelligence and talent are skills that can be developed, rather than static traits that you’re born with. The latter is known as a “fixed mindset”, which maintains that ability is static or predetermined, and there’s little you can do to change that. In other words, it’s thinking in terms of “natural talents” instead of “acquired skills” that can dissuade a lot of people from learning and improving an aspect of themselves, leaving them stuck in place. 

The idea of “natural talent” is very powerful. It’s often used to describe someone good at something seemingly without any effort, a sort of “Life’s Lottery Winner” that either you are, or you aren’t. However, this is far from the truth; what we call «talent» is simply the result of hard work, practice, and dedication, so anyone can become good at anything if they are willing to put in the time and effort. The belief that some people are born with inherent abilities, while others are not, is nothing more than a harmful myth, discouraging people from trying new things and pursuing their goals, because they believe that they will never be as good as those with «natural talent», no matter what. In reality, everyone has the same potential for greatness, but it’s up to each individual to get into this mindset.

But how to shed this worldview and embrace the idea that you can always learn and become better? How can you develop a growth mindset to become the developer you always wanted to be? Well, the most important thing you should know is that having a growth mindset is not always an innate attitude for most people, so it requires effort to get one. We all have a specific aspect of our personality somewhere that we believe impossible to change, that is just “part of who we are”, making us likely to give up in the face of adversity, stick to familiar tasks, and see failure as a reflection of our lack of ability, which is rarely the case. Recognizing the presence of this “fixed mindset” is the first step to start improving.

With that in mind, you should start by practicing self-advocacy. This is the ability to communicate your wants and needs to others, which requires an honest assessment of your strengths and weaknesses. Doing so makes it easier to identify areas of opportunity where you can improve a skill or learn something new. In software development, for example, you need a lot more than just writing good code; you need to communicate with the client and your team effectively, understanding their needs and challenges, and in a Nearshore company like Scio, often in a different language than your native one. All of these skills require time and commitment to master, so to get started…

  1. Make a list of all the skills you use daily, both hard and soft (tools, frameworks, platforms, and programming languages, for example, as well as stuff like planning, communicating with others, giving feedback, etc.)
  2.  Make a note of which ones you feel completely confident about, and which ones require more effort on your part. 
  3. Try to see what’s the difference between these skills: maybe it’s the amount of practice you put into it, or maybe you feel more interested in doing one rather than the other. Maybe you never had the chance to use that skill before.
  4. Apply self-advocacy to find the help you need to bring these skills up. Sign up for a course, ask a more experienced friend, or make the time to improve.

“By understanding what you’re good at and what you need to work on, you can set yourself up for success”, says Luis Aburto, CEO and Co-Founder of Scio. “If you’re aware of your weaknesses, you can take steps to improve them. And if you know your strengths, you can use them to your advantage. Which is an essential quality if you want to grow and evolve as a developer. By taking the time to understand what makes you tick, you can set yourself up for success both now and in the future.”

However, even after doing all of this, we understand that this growth doesn’t happen instantaneously; it requires a continued effort and the support of everyone in your environment to reach your maximum potential as a developer. This is why choosing to collaborate with an organization that takes growth seriously is just as important as recognizing your need to improve your skill set. After all, what good comes out of knowing your areas of opportunity if you don’t have the chance to act on them?

Growing together

Growth Mindset 6

However, a true growth mindset goes beyond simply believing that you can get better by just expanding your knowledge or your technical toolset. It involves taking the initiative to explore new skills and going through learning experiences outside of your “comfort zone”. In a previous blog, we talked about how actual “comfort zones” are less about getting stuck on a single place, without feeling the need to go beyond it, and more about expanding your areas of expertise, getting comfortable in areas of software development that are just as important as technical knowledge, but demand a very different kind of effort. Soft skills like  communication, negotiation, problem solving, teamwork or strategic thinking that will help you become a well-rounded developer. Going into places you have never gone before is how a person truly grows.

That’s why it’s so important to work with people that help you improve all your skills, or with an organization that provides opportunities for skill development outside of what you thought possible before, commiting to create a strong team capable of taking on any challenge. Companies like Scio, for example, know the value not only in offering workshops, courses, and programs like Sensei-Creati, but also in letting developers “stretch their legs”, so to speak, with assignments and responsibilities that might help them develop a new skill, like letting a Senior take the Lead in a project, or allowing people that not normally interact with the client to have a more “first hand” experience” to practice communication and planning. Actions like these allow taking something you are not “skilled at” and practice it to perfection on a daily basis, even if it’s outside of your normal interests. That’s how we participate in the creation of well-rounded developers capable of joining any team and overcoming any challenge.

So, to get back to our point, a growth mindset is essential for any software developer that wants to be excellent at their craft. With this mindset, you will never stop learning and expanding your skillset, always looking for new challenges to conquer and ways to improve yourself. If you can adopt a growth mindset and let go of preconceived notions about what you are and aren’t good at, you will set yourself up for success as a great software developer. And We will always be in need of those.

The Key Takeaways

  • A good software developer knows that the key to greatness is always improving your skills and learning new things.
  • To achieve this, you need to get into a “growth mindset” where improving is a continuing process that never stops.
  • To get this mindset, myths like “natural talent” or that there are things about yourself that cannot be changed need to be left behind.
  • However, doing this by yourself can be difficult, which is why you, as a developer, should choose to collaborate with a company or organization that sees the value in growing and learning at every step.

Scio is an established Nearshore software development company based in Mexico that specializes in providing high-quality, cost-effective technologies for pioneering tech companies. We have been building and mentoring teams of engineers since 2003 and our experience gives us access not only to the knowledge but also the expertise needed when tackling any project. Get started today by contacting us about your project needs – We have teams available to help you achieve your business goals. Get in contact today!

Normalization of Deviance: What to do when human nature collides with procedures in the workplace.

Normalization of Deviance: What to do when human nature collides with procedures in the workplace.

Product Development, Project Management, Software Development

Curated by: Sergio A. Martínez

Let’s think of the following example: imagine a brand-new bridge connecting two highways over a river. This highway sees a lot of traffic, including transport trucks that must pass from one side to the other daily, which tend to have a weight, on average, of about 25 tons. Thus, they mark the bridge accordingly: Limit Weight: 25 tons. However, the engineers know that they need a safety margin to ensure that the bridge doesn’t stress and wear out too quickly, so it’s designed to actually support up to 35 tons. It all seems good until one day, ten years later, the bridge collapses; a 40-ton trailer tried to cross it, and a tragedy occurred.

Why-will-platform-engineering-and-self-service-be-two-of-the-biggest-trends-in-2023-icono

It’s easy to point a finger at the culprit, right? That truck was way too heavy for this bridge, so we need to build sturdier bridges and think of a system that checks if a truck has the appropriate weight before crossing. Maybe even instill punishments and fines for people going over this limit. Easy stuff. Well, if that’s the case, then nothing was learned from this disaster. It will happen again in the future.

This is normalization of deviance. Simply put, it’s when people become so accustomed to seeing certain things done wrong that they no longer register as problems, but instead as the way “things work”. And they do work, until the day they don’t: catastrophic failures like a bridge collapsing are seldom the result of a single, unavoidable act of God, but instead the accumulation of small problems that one day reach a breaking point.  And normalization of deviance is a huge problem in the software development industry. 

However, how exactly does the normalization of deviance work, how does it affect software development, and what could be the steps to mitigate, or outright eliminate, the risks it presents?

Bending the rules (until they break)

Normalization of deviance

Software and civil engineering are not that different, at least when it comes to the complexity and precision needed to build things. After all, engineering of any kind is the art of finding solutions that work under stress: creating stuff that works reliably, no matter who is using it. So, no matter if you work with code or concrete, the process is roughly the same: you need to take into account every single situation that the design demands. And thus, both disciplines also tend to have very similar problems, with the normalization of deviance being one of them.

Let’s go back to our bridge example: what was the actual problem? The truck was way too heavy to safely cross that bridge, for sure. But why was such a truck trying to cross it in the first place? Because simply put, it was a normal thing to happen, and if that sounds like a contradiction, you would be right. After all, the normalization of deviance is a lesson in human nature.

People like to bend the rules. That’s what we do. Intellectually, we know rules are meant to keep things working properly, but rigidity is not our strong suit as a species. In the words of veteran programmer Foone Turing: “We always want to optimize. We want to do things cheaper, quicker, and more at once. And the thing is, most of the time going a little faster, a little hotter, that’s fine. Nothing goes wrong. Engineers always design with a safety margin, as we’ve learned the hard way that if you don’t, stuff goes wrong very fast. So going 110% as fast as the spec says? probably OK.”

So, you may see where this is going. In our bridge example, an interesting wrinkle is that the disaster didn’t happen right away, it was a full decade after the bridge was constructed. That’s the tricky thing with the normalization of deviance: it takes time to build up. It works through subtlety: if your bridge says that it has a limit of 25 tons, but you once drove a 30-ton truck through it and nothing happened, then the actual limit is higher, right? You can do it again. And if you do it enough times?

“You’ve been going 110% all the time. It’s worked out just fine. You’re doing great, no problems. You start to think of 110% as the new normal, and you think of it as just 100%. […] Then one day you’re running into 5 other problems and need to push something, well, maybe you do 120% today? After all, it’s basically just 10% of normal…”. That’s how you get a 40-ton trailer trying to cross a bridge rated way lower than that: someone drove through it with 35 tons of cargo, and nothing happened. 36 should be fine, right? Or 37, or 38, and so on. Bending the rules became so normal, without any immediate consequence, that it ceased to be wrong. Slowly, it became the standard, and a standard supported by bent rules is always a time bomb.

But how to avoid deviance?

Normalization of deviance

In software development, the normalization of deviance can happen at every level. For example, at a product level, it’s not exactly unheard of to release software that is not fully tested, on the assumption that the bugs will be fixed in future releases, which can lead to serious problems, such as data loss or security vulnerabilities. At the development level, programmers can start to disregard code style conventions if they feel slowed down by them (there’s a deadline to meet after all), resulting in a codebase that is difficult to read and maintain. And at the security level, it’s often easier to just write down a password than wait half an hour for IT to reset your account if you forget it. In either case, the result is the same: an organization will start accumulating issues until something serious breaks one day.

However, diagnosing the normalization of deviance can be difficult because there’s no immediate feedback loop to it. The bridge probably doesn’t produce a loud cracking sound if you go a couple of pounds above the limit, or the code doesn’t stop working immediately if you deviate a little from a style convention, so implementing effective ways to detect when it’s happening, or to deter this kind of behavior, can be tricky.   

The aforementioned Twitter thread gives a great example of why: “Susan gets in trouble because she put a post-it note with her password on her monitor, and we had to sit through a boring security meeting about password security. So, people learned to put their passwords in their wallets and their phones.” Or in other words, maybe the systems we have in place provide the incentive to deviate from the rules in the first place, and having after-the-fact measures don’t do enough to stop the buildup of problems. In that case, it falls on the culture of an organization to take into account these possible challenges and take the steps necessary to avoid lowering standards as a normal practice. These four key points might help:

  1. Rules are not forever. When it comes to technology, a year might as well be a decade in terms of advancement and innovation, so every procedure and workflow must be constantly reviewed to ensure “rule-bending” is not encouraged when certain parts lag behind, becoming obsolete or just ineffective. Revising and streamlining are always valuable skills for the leadership of any company to have, and giving people the power to always ask “why” could help avoid problems down the line.
  2. Open communication is critical. In that same sense, the main danger of deviance is that it develops in secret. Effective project management means communicating effectively with people, making clear the purpose of every rule, and being open to opinions, suggestions, and discussions to ensure those rules are effective and followed. Also, promoting an environment where a developer can communicate when a rule must be broken for the good of a project is crucial, as it allows management to respond and control such changes. “This situation has happened to us in the past”, says Jesús Magaña, Senior Project Manager at Scio. “And this decision has never been taken lightly. The objective, after all, is reaching the finish line without compromising quality or performance. This ‘shortcut’ has to be done with the consent of the Project Manager and the client, keeping in mind the possible consequences of doing so.”  
  3. Any change has to be clear and well-thought. The software sector is also ripe for new technologies, frameworks, languages, and tools to be implemented during development, but these changes are not trivial. If a new element is adopted within the development environment without proper measures (like clearly explaining the benefits and drawbacks of the new tool, giving people enough time to acclimate to change, being open to concerns, etc.), the risk of deviance grows.
  4. A culture of collaboration, not politics. Probably the most common cause of normalization of deviance, many of these examples don’t happen in isolation. Humans are social beings that tend to form cliques and in-groups that cover for each other, which can happen at every level of the organization, and thus be the perfect place to brew deviance that could snowball into disaster. So, promoting collaboration, being lenient enough with consequences so people feel comfortable about speaking up, but not to the point that developers feel they can get away with anything, and frequently promoting people to mix and work together in different configurations might be the key. It all comes down to skilled leadership.

And knowing is half the battle

Normalization of deiance

However, let’s not assume that these steps, although useful, are completely infallible when it comes to mitigating the normalization of deviance because this kind of behavior is simply human. We bend the rules when we know we shouldn’t, even at a personal level sometimes (“I’m on a diet, but this piece of cake shouldn’t be a problem, right?”), but that doesn’t mean that we cannot anticipate, learn, and improve at every opportunity. Understanding this is what separates good software organizations from the rest of them. After all, as Jesus Magaña tells us, “one of the values of the Agile Manifesto establishes that ‘people and interactions are above tools and processes’, which implies that a process doesn’t have to be a rigid path. Sometimes you need to veer off-course, and that’s not cheating. Let’s just keep in mind that, if everything is going well during development, a process is meant to help us to be consistent with the quality of our work.”

The Key Takeaways

  • Normalization of deviance, of lowering standards over time, is always a risk in any industry, especially software development.
  • Simply put, people are going to bend the rules when that benefits them because that’s simply human nature.
  • The main danger is that this normalization is almost always invisible until too late, helping the build-up of issues and problems until a disaster occurs.
  • It’s up to the management and culture of an organization to mitigate this deviance, which is virtually impossible to eliminate but can be avoided with the right approach to communication and collaboration.

Scio is an established Nearshore software development company based in Mexico that specializes in providing high-quality, cost-effective technologies for pioneering tech companies. We have been building and mentoring teams of engineers since 2003 and our experience gives us access not only to the knowledge but also the expertise needed when tackling any project. Get started today by contacting us about your project needs – We have teams available to help you achieve your business goals. Get in contact today!

Why will platform engineering and self-service be two of the biggest trends in 2023?

Why will platform engineering and self-service be two of the biggest trends in 2023?

Nearshore, Software Development

Curated by: Sergio A. Martínez

When it comes to the development of software applications, many companies, understandably, focus exclusively on creating products for their customers. The process has always been very simple, but as technology advances, and more and more options become available to develop and deploy products, a certain approach has started to shift. The SysAdmin days of yore are far behind, and since the start of the Cloud Age with the launch of AWS in 2006, technology has enabled developers all over the world to create better applications, but at the cost of making development a more complex endeavor.

Why-will-platform-engineering-and-self-service-be-two-of-the-biggest-trends-in-2023-icono

For example, let’s take the “Software-as-a-Service” (SaaS) model. An increasingly common way to offer software products with continuous support, it’s made possible by the widespread adoption of Cloud technology, allowing businesses to access software applications remotely through the Internet, on a pay-as-you-go basis. There are many advantages to this approach, including increased flexibility and scalability, but it also brought its own challenges. As this article puts it:

“Suddenly, engineers had to master 10 different tools, Helm charts, Terraform modules, etc. just to deploy and test a simple code change to one of multiple environments in your multi-cluster microservice setup. The problem is that throughout this toolchain evolution, the industry seemingly decided that division of labor (Ops and Devs), which proved successful in virtually every other sector of the global economy, was not a good idea. Instead, the DevOps paradigm was championed as the way to achieve a high-performing setup.”  

This approach, however, while making sense for companies the size of Amazon or Google, can also create something of a rift when it comes to more medium-sized organizations, where the resources and manpower can’t quite match the scale of modern SaaS and Cloud-based development, and “developers (usually the more senior ones) end up taking responsibility for managing environments, infrastructure, etc.”, putting a strain on the team that can doom the outcome of a project. The expectations regarding the number of tools and frameworks that a team must master to create effective products today are sky-high, and as such, a new approach for comparatively smaller organizations must be found elsewhere. With that in mind, let’s talk about the rise of platform engineering.

The glue binding development together

Why will platform engineering and self-service be two of the biggest trends in 2023 3

Platform engineering is a term that is used to describe the process of designing, building, and maintaining platforms that are used by other applications, and it’s all about creating systems that can be reused and repurposed, emphasizing flexibility and modularity. In other words, the industry is leaving behind the idea of designing systems with specific functions in mind as a result of the world becoming more connected, demanding a shift toward system design that can be adapted to changing needs. And platform engineering is at the forefront of this new paradigm. 

This is because platform engineering responds to the popularity of “self-service” as a development approach. To put it simply, self-service tools and platforms enable teams to have “the ability to create and configure resources” by themselves, away from more traditional models like a ticket system, which are a source of friction in the face of modern development methods. The trick, however, is that a good self-service platform is often developed and deployed internally, meaning that a lot of resources must be directed away from client-facing development, and toward the organization itself, and that can be a tough challenge to overcome.

There are real benefits to investing in internal tools and platforms, of course. For one thing, it can create a more efficient workflow that allows for greater collaboration between developers, helping to build a deeper understanding of the software development process because these platforms are tailor-made to the needs of a specific company. Perhaps most importantly, though, developing internal tools can give medium-sized companies a competitive edge, allowing for better efficiency in the software development process through the use of more effective and all-encompassing tools. 

“If you’re a software development company, chances are you’ve considered developing your own internal tools and platforms. And there’s a good reason for that; doing so can be game-changing”, says Luis Aburto, CEO, and Founder of Scio. “For starters, developing for self-service allows you to optimize specifically for your company’s needs, meaning they’ll be more efficient and effective than any off-the-shelf solution. And by controlling the development process from start to finish, you can ensure that your tools have the flexibility necessary for more and more complex operations. Having proprietary tools and platforms gives any company a competitive edge.” 

Coming back around, this is why platform engineering will be one of the most important trends of 2023. The process of creating an internal foundation upon which other applications can be built, is conceptualized as a sort of “glue” that binds every element of the development cycle. This can help many organizations to streamline their tools and frameworks, automatizing plenty of tasks that can increase the workload necessary to bring a SaaS application to life. This relatively new field is only now beginning to gain recognition, but it’s expected to become one of the most essential engineering disciplines in the years to come. 

And as the world becomes increasingly digital, the need for platform-based applications will only continue to grow, with internal tools and platforms enabling software development companies to boost their efficiency, saving time and money, and improving the quality of their products. However, to meet this demand, engineers will need to be familiar with platform engineering principles, and those who can master this discipline will be very valued members of a team in the years to come.

Building a platform with the best talent

With all of this in mind, why don’t more software development companies focus on internal tooling? There are a few reasons. First, it’s often seen as a low priority compared to client work, especially for medium or smaller-sized organizations with a more limited pool of resources. And second, it can be expensive and time-consuming to develop these tools, further straining a development team. But in 2023, overcoming these obstacles can be the difference between success and failure for a company.

The biggest challenge, then, is building a great platform engineering team that can bring these tools to reality. This year will not only see platform engineering as a critical approach for most software development companies, but the talent necessary to bring these kinds of applications will be in huge demand, with a strong engineering team becoming essential to develop high-quality products. However, it’s not always easy to find talented engineers who are also a good fit for your culture and values, which is why Nearshore augmentation holds an answer for a company wanting to remain competitive in the face of this new reality.

“More than ever, having developers at your disposal with a DevOps background will be critical to building a proper platform engineering team that could change the way your company approaches development”, continues Luis. “And Nearshore partnerships are a great way to access the kind of talent pool you need to bring this vision to life. Latin America has an amazing array of experienced and talented developers that companies of all sizes, or even a start-up, can harness to success.”

So, if you’re looking to build a platform engineering team, partnering with a Nearshore company is the best way to do it. With a Nearshore partner, you’ll get access to top talent, be able to scale quickly, and maintain the kind of communication necessary to bring these kinds of projects to fruition. Choosing a self-service approach is a choice that has virtually no downsides for a company looking to keep ahead of the curve in the current technology landscape and bringing developers with talent and communication skills to your team is always the smart path to follow. As a result, you’ll be able to build a world-class platform engineering team that can help take your business to the next level.

The Key Takeaways

  • The software industry is increasingly moving towards more complex development environments, thanks to the rise of technologies such as cloud platforms.
  • The number of resources needed to effectively work in this environment may not be too much for a big company, but for a smaller organization, it can be a challenge to overcome.
  • Among other things, this is why platform engineering and a self-service approach will keep growing in popularity in the coming year, popularizing the development of internal tools.
  • However, this will also increase the number of experienced developers needed to bring these platforms to fruition, and a Nearshore partnership can be the answer to reach these goals.

Scio is an established Nearshore software development company based in Mexico that specializes in providing high-quality, cost-effective technologies for pioneering tech companies. We have been building and mentoring teams of engineers since 2003 and our experience gives us access not only to the knowledge but also the expertise needed when tackling any project. Get started today by contacting us about your project needs – We have teams available to help you achieve your business goals. Get in contact today!

Passive Candidates: The biggest recruiting trend of 2023

Passive Candidates: The biggest recruiting trend of 2023

Software Development, Workspace

Curated by: Sergio A. Martínez

It’s no secret that the software industry is already very competitive in getting the best talent out there, which means employers have to work hard to attract the best and brightest. There’s no shortage of strategies to catch the attention of those developers and engineers looking for a new opportunity (from recruiting HR firms that specialize in the tech industry, to software events and meetups), but in 2023, the challenge of bringing the people you need for your company will probably be bigger than ever.

Passive-Candidates-The-biggest-recruiting-trend-of-2023-icono

But why is that? Well, for starters, the current tech job market is kind of a mess. The industry is plagued by some unprecedented instability thanks to several factors, ranging from the disruptions caused by the still ongoing pandemic to the geopolitical situation of many important regions of the world to bets in big technological projects, like cryptocurrencies and the Metaverse, not panning out as planned. The result is that the tech industry, as a whole, is currently going through a downturn that is causing layoffs, hiring freezes, and diminished budgets that create a climate of uncertainty among tech developers, and these challenges don’t seem to be going away soon. 

So, thanks to uncharacteristically tough times in the tech industry, and the current state of its job market, finding qualified talent can become harder than ever before. These conditions have marked the rise of a unique trend in talent recruitment that will pose a challenge for any tech organization down the line:  the passive candidate, or the people not looking for a new job but who would be willing to move elsewhere if it looks like the right opportunity.

The importance of this segment for the tech industry cannot be overstated. While many recruiters focus their efforts on active candidates, meaning those who are actively searching for new employment through the usual channels, passive candidates can often be a hidden talent pool encompassing over 79% of working professionals. And reaching them is no easy task, especially for medium-sized organizations that might have a harder time competing recruiting-wise. Sure, online tools such as LinkedIn and Google to search for qualified individuals who may not be actively seeking new opportunities can be a good start. Personal connections and networking can also be used to reach out to potential passive candidates, but it’s important to understand that the current job landscape means that it’s very unlikely for a candidate to consider leaving a position.

Today, the search for stability trumps any other consideration for a software developer. 2023 is not going to be about career growth, the opportunity to work in new and exciting tech, or whatever benefits and perks a company can offer, but rather keeping a job at all. From the passive candidate’s perspective, is easy to sum it up as “the devil you know is better than the devil you don’t”, and situations like Meta rescinding job offers, Twitter laying off 75% of its workforce after Musk’s buyout, the continued collapse of many cryptocurrency ventures, Oracle cutting jobs in their cloud division, and more, make it easy to see why changing jobs is not an attractive option right now. But what alternatives are there to successfully reach a pool of talent that could make a difference for any project?

The run for passive candidates

Passive Candidates The biggest recruiting trend of 2023 2

To reach these potential candidates, you need to think outside the box and use creative recruiting methods. The key is getting your message in front of as many qualified individuals as possible, including attending industry events, searching online for candidate profiles, or even reaching out to personal contacts. The challenge, however, is that you are not the only one running this race, so ensuring that your company is at the top of mind for the best and brightest in the software industry sometimes needs creativity to reach the people you want:

“Census data shows, for example, that the majority of people who took a new job last year weren’t searching for one: Somebody came and got them”, said the analysis by the Harvard Business Review. “Companies seek to fill their recruiting funnel with as many candidates as possible, especially ‘passive candidates’ who aren’t looking to move. Often employers advertise jobs that don’t exist, hoping to find people who might be useful later on or in a different context.”

After all, there’s a reason why the saying “the best software developers are already employed” is so popular. Those whose talents are critical to an organization are likely to already be comfortable in their positions, especially when the industry is not as stable as it used to be. Usually, these people tend to be open to opportunities, but that might not seem like the case anymore, especially if you are a start-up or a medium-sized company. So how can you find these hidden gems? The answer is simple: you need to go where they are.

And we don’t mean spending time on popular coding forums and websites, participating in online chatrooms, or attending industry events. It takes effort to find passive candidates, but this is true only if you look at your local prospects, which are often the hardest to convince, and the unstable tech market of 2023 will mean that the resources you can commit to this task might be too much. However, building a dream team of top-notch software developers is not out of reach for those medium-sized organizations that might not be interested in passive candidate competence, with a solution virtually next door.

Top talent in Nearshore

Passive Candidates The biggest recruiting trend of 2023 3

If passive candidates are proving elusive and hard to reach, what could be an alternative to it? Well, if you’re looking for top-notch development talent with a very specific set of skills and experiences, you might want to consider partnering with a Nearshore organization like Scio, that not only aims for the best software development in Mexico, but can help you close the gaps between the people you need, and the limited pool of talent you want. Here are a few reasons why:

  • You’ll have access to a larger pool of potential candidates. When you partner with a Nearshore software company, you’re not just limited to the talent in your immediate vicinity; you can tap into a much larger pool of qualified candidates, making it more likely that you’ll find the perfect fit for your needs.
  • You’ll save time and money on recruiting. If you try to recruit development talent on your own, you’ll likely have to invest a lot of time and money into the process and doubly so for passive candidates. When you partner with a Nearshore software company, they can handle the recruiting for you, making the process much more efficient and cost-effective.
  • You can take advantage of flexible staffing options. Nearshore software companies typically offer more flexible staffing options than their offshore counterparts, meaning that you can scale up or down as needed, without being locked into a long-term contract.

Overall, partnering with a Nearshore software company is an ideal way to find top-notch development talent. With access to a larger pool of candidates, lower recruiting costs, and flexible staffing options, it’s easy to see why more and more businesses are making the switch, so it may not make sense to spend valuable time and resources pursuing passive candidates who probably wouldn’t want to leave a job they’re content with. The top-notch talent that the rest of the industry is fighting to get is just there, your company might only need the right partner to enhance your team in just the right way.

The Key Takeaways

  • 2023 is going to be a tough year for the tech industry, and recruitment will become more and more competitive.
  • One of the biggest trends for 2023 is the rise of the “passive candidate”, who is not actively seeking a new job, but seems to be open to opportunities.
  • However, the unique situation of 2023 means that these candidates will be harder to reach and convince, as stability is a #1 concern, and changing jobs goes against that.
  • So, for a medium-sized company or a start-up, finding the right talent locally might be a big challenge to overcome.
  • This is why Nearshore talent recruitment can be such a good solution, offering a pool of talent that can go toe to toe with your local candidates, but with the cost-effectiveness and flexibility you want.

Scio is an established Nearshore software development company based in Mexico that specializes in providing high-quality, cost-effective technologies for pioneering tech companies. We have been building and mentoring teams of engineers since 2003 and our experience gives us access not only to the knowledge but also the expertise needed when tackling any project. Get started today by contacting us about your project needs – We have teams available to help you achieve your business goals. Get in contact today!

Working as intended vs. Working as expected: A critical difference in software development.

Working as intended vs. Working as expected: A critical difference in software development.

Software Development

Curated by: Sergio A. Martínez

“Never trust a system that seems to be working» – Foone Turing

Anyone who has ever tried to develop software knows that it can be a very complex task. There are many different types of programs you can create, ranging from simple applications to large and complex operating systems, and each has its own unique set of challenges. However, there are common trends no matter what you are developing: for one thing, software is built upon layers of code, meaning that any change to the codebase can potentially affect the entire program. Software typically works in tandem with other programs and systems, so a change to one piece of software can often ripple outwards and cause problems with other programs. Furthermore, many software applications are used by millions of people all over the world, so even a small bug can have major consequences. 

Superapps-A-trend-to-watch-closely-in-2021-icono

In other words, developing software requires a great deal of care and attention to detail to ensure that the final product is stable and usable, ready to do what you want it to do. Nothing beats the moment when you run a program for the first time, and it seems to work very well. But for a certain kind of developer, this is the point when the actual challenge starts: getting something to work is the first step to creating a truly wonderful piece of software but may not be the end of it.

So, this time, we want to discuss the subtle and crucial difference between “working as expected” and “working as intended”, how this can make or break an entire project, and how a smart developer can begin to understand why a system might fail even after it successfully seemed to work perfectly. Onwards!

Knowing and not knowing  

Superapps A trend to watch closely in 2023 2

Software is everywhere. It’s running our phones, our computers, and our cars. It’s become so integral to our lives that we often take it for granted, when in fact, achieving software that works at all is almost miraculous. We’re talking about lines of code, written by fallible human beings, that work together to design very complex systems with tons of moving parts that must work in very specific contexts. And yet, more often than not, they actually do what we want them to do. Sure, there are the occasional glitches and bugs, but overall, it’s amazing that software works as well as it does. However, how do developers achieve that? 

We can sum it up with this famous quote by Former Secretary of Defense Donald Rumsfeld: “There are known knowns, things we know that we know; and there are known unknowns, things that we know we don’t know. But there are also unknown unknowns, things we do not know we don’t know.” It might look like a mouthful, but it’s a great starting point for risk assessment and post-mortems of software issues. How many known and unknowns do you have about the system you build? How many things you don’t know you don’t know? Because the idea of working software is not as clear as you might think, and your approach to this is defined by your experience as a developer. In short…

  • When something works, a junior developer feels excited. They tend to focus on the known knowns; they know the system is working, they know how it’s working, and further considerations are secondary until an issue becomes apparent. These developers are still experimenting and learning new things as they go. 
  • When something works, a mid-level developer feels relieved. They tend to focus on the known unknowns; they know the system is working, and move on to the unknowns (bugs, compatibility problems, glitches, etc.) that cause immediate issues, but mostly as a means of ensuring stability and shipping the product. 
  • When something works, a senior developer feels concerned. They focus on the unknown unknowns, without assuming that the system working is enough to move on; having a complete understanding is a must to guarantee the quality and intended functionality of the program. Thus, when achieving a working system, their first question is always “why?” to make sure the stability of the program is unassailable. 

So, it all comes down to experience, giving you a nagging feeling at the back of your mind when the code runs: is it doing it as it should? This is the heart of the problem between systems working as intended and systems working as expected, which are not always the same thing. Understanding the difference between both is what separates a good program from a bad one, ensuring that the design of a system is the one responsible for it working, and not a series of coincidences that give the impression that it is. Otherwise, you are sitting on a time bomb, ready to go off when the correct circumstances align. In short, the development process, once you complete a version of the product, should look more or less like this:

Okay, we might be exaggerating a little, but in broad strokes, this is how you avoid being blindsided when something unexpectedly breaks in the long run. Taking the time to view the program holistically, where you can properly see how every individual element is interacting with everything else, is the ideal way to develop a good, stable application, and although it is possible to reach the point where you actually know exactly how a system works, it’s never going to be on the first try.  

This Twitter thread linked above gives a great example of this, in which assuming that a working system is a good system can have deep consequences (long story short, an undetected error in the certification software of a company that built servers was loading the wrong kinds of tests, giving false positives on the architecture of machines intended to handle a lot of data, which could be quite a problem if left unchecked), and being aware of the existence of unknown unknowns can save you from a bad headache in the future.

Knowing is half the battle

So, to recap, the success of any software development project depends on two things: a complete understanding of how the application works, and a detailed risk assessment. Here at Scio, where we always try to bring the best software development in Mexico, we came to understand that, without these two elements, it is impossible to produce a good outcome:

First, always assess the risks. This means identifying all of the potential problems that could occur during development and assessing the likelihood of each one occurring. Once the risks have been identified, they can be mitigated through planning and implementation. For example, if there is a risk that the application will not work as intended, then extra testing can be built into the development process to ensure that it does. And second, gain a complete understanding of how the application works. This includes understanding the code base, the architecture, and the dependencies. Without this knowledge, it is impossible to make informed decisions about the best way to develop the software. It also makes it more likely that errors will be made, which could lead to problems during development or after the application has been released. A complete understanding of how an application works will always be critical to achieve the best result.

The Key Takeaways

  • Software is a very complex field where the number of moving parts, requirements, and situations where it must work make it difficult to create flawless products.
  • One of the bigger challenges is understanding a system thoroughly, otherwise a software application can fail in unexpected and disastrous ways.
  • A key strategy is being aware of your known knowns, known unknowns, and unknown unknowns.
  • In other words, what separates novice developers from veteran ones is the understanding that a system working as intended is not the same as a system working as expected, and solving this difference can guarantee the best outcome.

Scio is an established Nearshore software development company based in Mexico that specializes in providing high-quality, cost-effective technologies for pioneering tech companies. We have been building and mentoring teams of engineers since 2003 and our experience gives us access not only to the knowledge but also the expertise needed when tackling any project. Get started today by contacting us about your project needs – We have teams available to help you achieve your business goals. Get in contact today!