Ukrainian Developers Rank #5 Technically – Skills and Values

Quick Summary - SkillValue, a leader in technical tests for recruiters in evaluating software developer skills ranks Ukrainian developers #5 globally.

Ukrainian Developers Rank #5 Technically - Skills and Values

SkillValue assessments of Ukrainian software developers

According to SkillValue, Ukrainian software developers ranked 5th globally with a score of 93.17% according to 550+ technical assessments. SkillValue specializes in full-stack technical assessments for everything from back-end and front-end to mobile and big data software development. SkillValue’s tests have been used to evaluate over 250,000 developers. By comparison, Ukrainian developers performed 8.58% and 13.62% better than their American and Israeli counterparts, respectively.

What do the skill assessments really mean?

Would you expect a junior developer to be equally productive as a mid-level developer? Might you expect that a mid-level developer can probably write more and better code than your new just-out-of-bootcamp new hire? If so, the skill evaluation serves as a sort of force multiplier. All else equal except their skills, a Ukrainian developer should be 8% more productive than their American counterpart.

To be sure, ethnicity has no direct correlation to skill. However, Ukraine’s educational system, government incentives (tax benefits), and job market create exceptional conditions for aspiring software developers. A good software developer in Ukraine will benefit financially at a much higher ratio than in the United States, Europe, and most everywhere else. Where a software developer in the United States earns basically 2x the per capita average; Ukrainian developers are earning 2.5 to 6x average wages.

Presumptively, high test scores should correlate to higher code quality and lower defect rates than lower test scores. Skeptics could argue that technical tests and coding are two separate things. Performing well on one doesn’t guarantee that you’ll perform well on the other. Of Israeli companies that outsource, some 45% source their software developers through Ukraine. But why?

Putting a dollar value to skill test ratings

This may be an oversimplification, but it is a useful starting point. According to CBI Insights the #2 reason why startups fail is that they simply run out of money. In software development, wages for software developers are your #1 expense. The equation’s simple, no money, no software development.

So, let’s pretend for a minute that you’re just hiring newly graduated high school students for your project. You have a choice between hiring one “Solid B” local student or three “A” foreign exchange students. Unless the local student is a close friend or relative, all else equal except wages, you’d probably want the three “A students” on your team – regardless where they’re from. Yes?


Relative Cost of each % Point of Technical Skill

This, of course, is not an “official metric” and in practice hiring decisions rarely come down to test scores. There are a lot of other factors to consider. But, we have a starting point for comparing Value – Quantity and Quality of software development.

What might skill ratings impact in software development?

Let’s get a little more technical with what our test scores represent. A lot of things factor into software development skill on a per programming language (Java, C#, C++, React Native, etc.) basis. There are hundreds of programming languages and variants, which break down into further specializations – backend, frontend, mobile, cloud, etc., and niches (FinTech, MedTech, VR, games, and so on).

It stands to reason that a developer who specializes in React Native will have a much higher performance coding for React Native than Java, C++, or even React. This itself is the basis for resource allocation and assembling development teams – to match project and task requirements.

Higher skill ratings apply to developers via:

  • Faster reading, understanding, and finding bugs in other developer’s code
  • Better able to write simple and highly modular code (lower code complexity)
  • Lower code complexity correlates to higher test coverage
  • Higher test coverage makes it easier to identify and increase scrutiny of high-risk untested code – and cases of low cognitive but high cyclomatic complexity code.
  • Higher test coverage correlates to lower defect rates
  • Lower defect rates factor into increased productivity (writing new code)
  • Higher productivity = Faster Cycle Time

More time is spent reading than writing code. Merely writing code that is easier and faster for everyone to read translates to a significant increase in efficiency, which could also improve productivity.

How much does it cost to build a remote team in Ukraine?

If you decided to hire a development team in Ukraine or even open an R&D center, this calculator helps you figure out how much it would cost.

Calculate now

The three most important software development metrics

There’s a butt-ton of software development metrics – and they’re all useful for helping to identify a wide range of problems and inefficiencies. From a non-technical perspective, speed of software development is the most important factor – because software must eventually be released or made available to end users. Quality is a close second, signified by a low defect rate. Generally speaking, it’s cost-prohibitive and takes too long to release software that is completely free of bugs.

Speed = Cycle Time = The #1 Metric

Cycle time measures how fast a unit of work (a story point) can be completed. For your own product, this determines how fast you can launch, produce patches and updates. If you’re a development agency, cycle time factors directly into your profitability. Cycle Time, however, is an aggregate of all (or nearly all) other software development metrics. An improvement in nearly any other metric, while maintaining the same standard of quality (defect rate), will improve your cycle time. It’s like a bird’s eye view of how your team is improving over time.

Quality = Defect Rate = The #2 Metric

Again, not all bugs or defects are equal in severity. Defect rates are ripe for extended discussion, suffice that bugs:

  • in most cases require rework – negatively impacting cycle time and productivity
  • in severe cases, defects can throw off an entire sprint or deadline
  • can anger end-users – deter them from using the software
  • angry end-users can write bad reviews which can have a huge negative viral impact
  • result in software that doesn’t get used or purchased, impacting profitability
  • result in secure vulnerabilities compromising end-user data and open the developer or their client vulnerable to fines, lawsuits, and ransomware
  • can ultimately lead to financial collapse, loss of clients, loss of jobs

It is, however, cost prohibitive to eliminate all bugs and defects and remain on schedule. So, it’s important for the project manager to evaluate and prioritize which bugs should be fixed immediately, those that can be fixed later, and which ones can be “safely” ignored.

Cost to fix a bug = Average Time to Fix a Bug * Average Hourly Wage of the Developer

The cost to fix a bug varies quite dramatically depending upon who catches it and when they catch it in the development cycle. A developer writing code can see and rapidly correct an error. In this case, the cost is a portion of the developer’s Code Churn. The more time that elapses after the code leaves the developer’s hands, more people and time are needed to find and fix the bug.

  • Fixing code while coding: 1x
  • Fixing code tangent to a pull request/code review: 6.5x
  • Code fixes tangent to testing in a production environment: 15x
  • Fixing bugs after it’s been released to end-users: 100x

Quality & Efficiency Indicator = Code Complexity = The #3 Metric

Code complexity is probably the main metric to watch and focus improvements upon as it’ll have the single greatest impact on code quality and defect rates. High code complexity typically means low test coverage and high defect rates.

Different systems – Cognitive, Halstead, and McCabe Complexity Metrics, can be used to help identify how code can be simplified. Simple code = high quality code. It’s more efficient for developers to read simple code than highly complex code – and easier to debug, too. There are four main sources of high code complexity:

  • Developer skill and experience accrues over time – and is facilitated by good code reviews especially with more experienced developers, standups, retrospectives, mentoring, and being provided high quality examples of the logic suited to their assigned tasks.
  • Inefficiency team composition as typical to early stage and high-growth startups can be mitigated by establishing coding standards early, proper growth planning, adhering to Agile’s principles for small, cross-functional teams. The goal is to cultivate “teams of teams” – each typically composed of 3 developers plus one team leader.
  • Truly complex tasks are sometimes unavoidable, but most 8+ story point tasks can be broken down to smaller stories. This may require an experienced developer to help your Scrum Master divide the tasks into smaller, but meaningful parts – and to master the Art of Story Splitting. This has the advantage of taking some weight off of senior developers (avoid burnout) while improving utilization for junior developers (easier tasks).
  • Poor code reviews – The baseline expectation is that code reviews should last no more than one hour and catch 70-90% of defects on ~400 lines of code. Complex code is harder for everyone to read, understand, and debug. There are times, when code review is unnecessarily complex but works that it is accepted because of deadlines. But, anyone performing a code review has the prerogative, even the responsibility, to say, “Hey, this code is too complex, here’s how it can be simplified.”

Compounded value of Ukrainian software developers

When hiring or outsourcing developers, you have the ability to interview them and even administer tests to qualify or vet their skills. The high skill evaluations of Ukrainian software developers is a direct result of good technical schools, a government that promotes the IT service industry, and a market where software developers are among the highest earners.

High technical skills =

  • Increased productivity
  • Higher-quality code / fewer defects
  • Lower code complexity = higher team efficiency

But, another factor that we explored previously is that Ukrainian developers change jobs less frequently. Ukrainian turnover runs less than 10%. In the United States, turnover among developers is typically 12.3%, but often over 25% for tech startups.

When outsourcing through an IT staffing agency like PerceptionBox, the agency is responsible for rapidly finding replacements. Companies insisting on hiring in-house developers bear the replacement costs, typically 25-30% of the developer’s wages. Loss of knowledge from outgoing developers and time for new developers to become acquainted with the project are hidden costs owing to reduced efficiency.

Ultimately, if you’re looking to develop software, wages for developers will be your largest expense. Success for your project is traditionally based upon the software being delivered on schedule, within your budget, and works as intended – time, cost, and quality. We can help you find the Ukrainian developers with the exact skills needed to build your project.

Run the numbers – and feel free to use our calculator! It’ll show you how much you can save by outsourcing compared to hiring locally (for Israeli clients).


Tell us about what you are trying to build

  • Hidden
  • This field is for validation purposes and should be left unchanged.

Subscribe to our newsletter

  • This field is for validation purposes and should be left unchanged.