Software Testing
& Quality Assurance

Don’t use up chunks of your budget fixing errors in production that could have been avoided. Give your users software they can rely on.

Add manual and automated testing specialists to your project to improve your product’s quality, catch issues faster, and save your developers’ time. When you hire us for development, our QA processes ensure you get world-class code, every time.

Examples of our projects
contact us

Don’t use up chunks of your budget fixing errors in production that could have been avoided. Give your users software they can rely on.

Add manual and automated testing specialists to your project to improve your product’s quality, catch issues faster, and save your developers’ time. When you hire us for development, our QA processes ensure you get world-class code, every time.

MICHAŁ KWIATKOWSKI
Service Delivery Director

Why is software
testing important?

icon-testing-2
photo-devops-3

You can’t have great software without extensive testing. Well-tested code will save you from frustrated end users, swamped tech support lines and one-star app reviews.

Investing early in thorough testing also helps you save money. Detecting and fixing a code issue during development may take our professionals an hour—instead of costing you thousands of dollars spent on fixing a bug in live production.

Adding specialized manual testers and test automation engineers to your team not only improves the quality of your code, but also decreases your development costs. With professional testers on board, the developers can spend their work hours on what they do best: shipping code.

All in all, testing is the secret ingredient that transforms your application from potentially frustrating to a reliable tool with a delightful user experience.

Our testing roles

icon-everybody-else
Manual testers

Manual testers go through your software by hand, simulating the end user and all the ways they might break the flow of your application. They detect such issues and signal them to the team, so the problems in your code get fixed long before any user can see it.

Each of our projects receives manual testing support by default. We employ manual testing from the first day of the project and each team has at least one manual tester.

All of our testers fit a strict competence profile. You’ll be working with professionals with strong soft and technical skills, knowledge of testing environments, CI tools, bug tracking tools and Agile development.

icon-test-automation
Test automation engineers

Adding automated tests is all about optimizing your development budget even further and maximizing test coverage. Instead of testing the code by hand, our QA specialists write automated tests running around the clock with no risk of human error.

This allows you to catch many more potential issues by testing faster than humanly possible—literally. Additionally, because automated QA drastically reduces the need for manual testing, even more of your investment can go towards effective application development.

Well-written automated tests are highly reusable, making it easy to test your application in different browsers and environments at scale, and to perform tests at various stages of development. They allow us to not only verify the functionality of your app on the user interface level, but also to test every feature, microservice, and API integration.

icon-everybody-else
Everybody else

Testing may be the domain of specialists, but true quality assurance is everyone’s responsibility. That’s why we’ve implemented QA processes across the entire development process.

By following our processes such as code review and unit testing, our developers often catch issues before they even make it to the testing stage.

Our QA processes didn’t take shape overnight; they’re the result of continuous improvement and an attention to craftsmanship.

Since 2005, we’ve shipped our fair share of software, and we know what it takes to produce an app your company can be proud of.

Software testing services we’ve provided

to our clients
black-box-testing Black box
testing
regression-testing Regression
testing
non-functional-testing Non-functional
testing
functional-testing Functional
testing
white-bog-testing White box
testing
stress-testing Stress testing
performance-testing Performance
testing
testing-for-memory-leaks Testing for
memory leaks
penetration-testing Penetration
testing
mutation-testing Mutation testing
unit-tests Unit tests
api-testing API testing
integration-testing Integration
testing
sanity-testing Sanity testing
smoke-testing Smoke testing
usability-testing Usability testing
branch-testing Usability testing
accessibility-testing Accessibility
testing
end-to-end-testing End-to-end
testing
exploratory-testing Exploratory
testing
gui-testing Graphical User
Interface (GUI) testing
monkey-testing Monkey
testing
negative-testing Negative
testing

Our quality
assurance processes

70% of our revenue comes from clients we have worked with for more than one year—because we know you expect consistent quality, and that’s what we deliver.

By combining code review standards, the work of testers, and tests written by automation engineers and the developers themselves, we can minimize the development-to-market cycle while maintaining a world-class level of software quality.

Below, you’ll find a sample of QA processes from one of our projects. The requirements of every project are unique, so we will adapt our workflows to fit the situation.

photos-10
  • icon-unit-tests Unit tests
  • icon-integration-tests Integration tests
  • icon-postgre-1 Branch tests
  • icon-code-review Code review
  • icon-manual-tests-on-the-testing Manual tests on the testing environment
  • icon-end-to-end-automated-gui End-to-end automated GUI tests
  • icon-po-signoff PO signoff
  • icon-our-qa-process-workflow Our QA process workflow

Our developers always create unit tests as they work on new features. Unit tests focus on testing the smallest possible unit of code, such as a single class or function.

They are crucial for more complex projects, allowing the team to instantaneously detect changes that impact other parts of the system, greatly increasing the maintainability and flexibility of the application.

We don’t ship code without unit tests; they are a must-have in our QA process. Where applicable, we aim for 100% unit test coverage, meaning that the unit tests should cover every line of code.

Our coverage standard includes branching; if the code has an “if” statement, one test should go into it and the other shouldn’t. This ensures that no issues slip through the cracks at the unit level.

It’s not enough to test if parts of the software work in isolation; you also need to verify that they can work with each other.

Integration tests are implemented by our developers as they work on new functionality. The tests check the application as a whole with minimal mocking of dependencies to make sure the code doesn’t cause errors at the interface between modules.

Implementing integration tests early gives the team confidence that newly introduced changes won’t break the flow of the application, but it’s hardly the end of the QA process for a new piece of code.

Before features can be merged into an application, a tester must verify them on the developer’s branch.

Branch tests are very detailed. The tester not only makes sure that the functionality was implemented correctly, but also checks if it didn’t break anything in other parts of the application.

A lot of data and different cases are tested at this stage, so the team can be sure that nothing inappropriate will be merged into the master branch.

Knowledge of Git basics is standard among our testers because every tester has their own local environment where they can build and run the application, just like a developer, on any branch.

Every piece of source code we write is reviewed and approved by at least 2 other developers.

This allows us to catch non-trivial logical errors and edge cases. It also helps maintain the same consistent code style among all team members, making the whole source code easy to read and understand.

After features are merged into the application, we test them again on a deployed testing environment.

The role of this stage of testing is primarily to check if the feature was merged correctly, nothing was overwritten and deployment went well.

Where possible, we recommend to include at least two testers in a team. In such situations, manual tests on the testing environment can (and should) be performed by a different tester than the one doing branch testing.

A different person can spot different issues, and both testers become familiar with the functionality as an added benefit.

The final batch of testing includes automated GUI tests which ensure the app works and performs correctly in production-like scenarios.

We run two batches of automated end-to-end tests.

The first are smoke tests, which are run on every pull request to make sure the most important functions of the software work and the build is stable enough to proceed with further testing.

The second batch is longer, includes all automated tests, and is run every night. At this stage, the application is tested on all levels and across all subsystems.

Our teams choose the automated testing technology (such as Cypress or Selenium) to best fit the needs of the project.

Even if a feature has been 100% covered by unit tests, has gone through code review and undergone branch, manual and automated testing, we don’t consider it done unless a Product Owner accepts it.

Their job is to verify whether the shiny new feature meets their expectations both in terms of delighting users and satisfying the needs of your business.

As our client, the PO signoff makes the process of accepting changes faster for you—before features finally make their way to you for final acceptance, they have already been checked by a professional who knows your business context.

It’s not enough to test if parts of the software work in isolation; you also need to verify that they can work with each other.

Integration tests are implemented by our developers as they work on new functionality. The tests check the application as a whole with minimal mocking of dependencies to make sure the code doesn’t cause errors at the interface between modules.

Implementing integration tests early gives the team confidence that newly introduced changes won’t break the flow of the application, but it’s hardly the end of the QA process for a new piece of code.

photos-8
icon-unit-tests Unit tests

Our developers always create unit tests as they work on new features. Unit tests focus on testing the smallest possible unit of code, such as a single class or function.

They are crucial for more complex projects, allowing the team to instantaneously detect changes that impact other parts of the system, greatly increasing the maintainability and flexibility of the application.

We don’t ship code without unit tests; they are a must-have in our QA process. Where applicable, we aim for 100% unit test coverage, meaning that the unit tests should cover every line of code.

Our coverage standard includes branching; if the code has an “if” statement, one test should go into it and the other shouldn’t. This ensures that no issues slip through the cracks at the unit level.

icon-integration-tests Integration tests

It’s not enough to test if parts of the software work in isolation; you also need to verify that they can work with each other.

Integration tests are implemented by our developers as they work on new functionality. The tests check the application as a whole with minimal mocking of dependencies to make sure the code doesn’t cause errors at the interface between modules.

Implementing integration tests early gives the team confidence that newly introduced changes won’t break the flow of the application, but it’s hardly the end of the QA process for a new piece of code.

icon-postgre-1 Branch tests

Before features can be merged into an application, a tester must verify them on the developer’s branch.

Branch tests are very detailed. The tester not only makes sure that the functionality was implemented correctly, but also checks if it didn’t break anything in other parts of the application.

A lot of data and different cases are tested at this stage, so the team can be sure that nothing inappropriate will be merged into the master branch.

Knowledge of Git basics is standard among our testers because every tester has their own local environment where they can build and run the application, just like a developer, on any branch.

icon-code-review Code review

Every piece of source code we write is reviewed and approved by at least 2 other developers.

This allows us to catch non-trivial logical errors and edge cases. It also helps maintain the same consistent code style among all team members, making the whole source code easy to read and understand.

icon-manual-tests-on-the-testing Manual tests on the testing environment

After features are merged into the application, we test them again on a deployed testing environment.

The role of this stage of testing is primarily to check if the feature was merged correctly, nothing was overwritten and deployment went well.

Where possible, we recommend to include at least two testers in a team. In such situations, manual tests on the testing environment can (and should) be performed by a different tester than the one doing branch testing.

A different person can spot different issues, and both testers become familiar with the functionality as an added benefit.

icon-end-to-end-automated-gui End-to-end automated GUI tests

The final batch of testing includes automated GUI tests which ensure the app works and performs correctly in production-like scenarios.

We run two batches of automated end-to-end tests.

The first are smoke tests, which are run on every pull request to make sure the most important functions of the software work and the build is stable enough to proceed with further testing.

The second batch is longer, includes all automated tests, and is run every night. At this stage, the application is tested on all levels and across all subsystems.

Our teams choose the automated testing technology (such as Cypress or Selenium) to best fit the needs of the project.

icon-po-signoff PO signoff

Even if a feature has been 100% covered by unit tests, has gone through code review and undergone branch, manual and automated testing, we don’t consider it done unless a Product Owner accepts it.

Their job is to verify whether the shiny new feature meets their expectations both in terms of delighting users and satisfying the needs of your business.

As our client, the PO signoff makes the process of accepting changes faster for you—before features finally make their way to you for final acceptance, they have already been checked by a professional who knows your business context.

icon-our-qa-process-workflow Our QA process workflow

It’s not enough to test if parts of the software work in isolation; you also need to verify that they can work with each other.

Integration tests are implemented by our developers as they work on new functionality. The tests check the application as a whole with minimal mocking of dependencies to make sure the code doesn’t cause errors at the interface between modules.

Implementing integration tests early gives the team confidence that newly introduced changes won’t break the flow of the application, but it’s hardly the end of the QA process for a new piece of code.

photos-8

Our testing
tech stack

Git
GitHub
Celery
Selenium
Cypress
TestRail
Behave
Seerene
SonarQube
Protractor
Cucumber
Postman
Gherkin
Jest
CodeceptJS
Detox
RobotFramework
Zephyr
GitLab
Tavern
Jenkins
Bamboo
SQL
Linux

Definition of Done

A clear Definition of Done ensures that nothing slips through the cracks. To meet our standards, a task is done only when the following conditions are met:
The implementation is completed according to the acceptance criteria
The implementation is covered by unit tests
All unit tests pass on CI build
Testing scenarios are prepared and documented
All tasks are tested and pass all testing scenarios and acceptance criteria
The code is reviewed and accepted by at least two other developers, who leave a “+1” when all comments have been actioned
Code is merged into the main development branch
The story is done when the PO has signed it off
The implementation works on all the supported browsers
photo-promise
graph
graph-1

Constant
communication

Quality code is not just code that works
flawlessly—it also fits your business needs perfectly.

To ensure this, we employ a framework of touchpoints to help you stay in control of the project and have plenty of opportunities to give relevant input and feedback.

Daily communication is our preferred mode of cooperation. When feedback flows, business value tends to follow.

But staying in touch on Slack can’t cover all situations. To take a deeper dive into your product, we also hold regular sprint review sessions, calls with your assigned Service Delivery Manager, and roadmap review workshops.

What our clients say

C-level executives, product managers, tech leads, and founders from around the world have appreciated our help in delivering world-class products under strict deadlines.

The feedback we get from our clients is consistent. We take real ownership. We happily serve as mentors in tech and Agile. We listen to real business needs instead of just shipping features.

The project team demonstrated efficiency by streamlining processes and supplying frequent performance metrics. Resources always communicated effectively, and the deliverables were almost completely bug-free.

Leigh Simpson
CTO @ FusePump
Featured in gamespot-logo

It was a pleasure working with the team at STX Next. Collaboration and communication worked like a charm and made our first foray into hiring outside help a big success. The developed tool included technology we were able to extract as a library and made the effort even more worthwhile. Looking forward to our next endeavor.

Sebastian Kral
Global Head of Pipeline @ Pixomondo

We really appreciate working with STX Next, because of their dedication to quality as well as their effort to meet always the deadline - even in a very challenging project phase.

Dr. Holger de Bie
Innovation Manager @ finstreet
Featured in logo-techcrunch-1

The STX Next team has proven itself to be a solid and reliable partner in software development for the Tiqets platform. Although Tiqets’ main development team is located in the Amsterdam office, having dedicated development teams in Poland gives the company the flexibility it requires in the rapidly growing market that Tiqets operates in.

Sietse van der Laan
Tech Team Manager @ Tiqets

The team is very product oriented - they try to understand the product and its end users. This means that there are more sets of eyes looking after potential User Experience issues, which results in a better product.

Ron Shteinberg
Head of Product and Operations @ Newable
Featured in logo-techcrunch-1

STX Next have been working really well with my engineering team. They’re demonstrating great skill, craft, and agile thinking in the way they go about their work, and they’re great people to boot.

Bradley Wright
CTO @ Verve

Working with STX Next felt like a strategic partnership rather than outsourcing. From consultation through to development and delivery, the STX Next team integrated seamlessly within our own team, in a challenging technical area, and delivered to the same standards we expect from our internal developers.

Michael Stone
Chief Technology Officer @ Enroly

We came to STXnext looking for a partner to join our developers in putting together a site for Buddhist texts. It's a complex project, involving tens of thousands of texts and relations, and dealing with nearly forty languages. We've been more than happy with the process. The STXnext team has shown initiative and interest, and has been quick to adapt to working with our developers.

Bhante Sujato
Director @ SuttaCentral

Assuring quality and business value with Scrum

Scrum allows us to create great software with ease and respond quickly to an ever-changing market.
Agile Design

It keeps us honest about how much we can do during each sprint—giving you clarity and predictability of when work will be delivered.

We develop software through an iterative process; each iteration we focus on providing more and more value to your end users and your business.

Scrum rituals also help us prioritize the tasks that are most important to you as well as constantly optimize the internal team processes unique to each project for maximum velocity and quality.

group-3

Cooperation models

icon-team-extension (3)
Team
Extension

Add testers to your in-house
or outsourced team.

Detect issues faster and help your developers focus on coding.

icon-end-to-end-2
End-to-End Product Development

When we build a product for you, testers are a natural part of our team composition.

Additionally, our battle-tested QA processes apply to the entire process of design and development, giving you a quality product, every time.

icon-consulting-expertise-2
Consulting
& Expertise

Testing expertise
you can rely on.

If you’re looking to optimize your infrastructure or processes, we can review your current solutions and provide you with recommendations of the best technology choice for optimal results.

Outsourcing is a big leap for your software projects

On your path to greater velocity and flexibility, we’ve got you covered every step of the way.

photos-7
1
What if I want to keep testing in-house?

Excellent idea. Your testers can enhance the QA work on our side, resulting in an application that meets all user expectations. Bear in mind that your testers need to be available to support us; otherwise the development velocity might change.

2
Why can’t the developers do the testing?

Technically, they can. However, dedicated testers will give you more thorough testing at a lower cost. The testers specialize in finding potentially dangerous issues and ensuring the quality of your entire application, not just individual features. In our experience, developers prefer to stick to coding and when they have to test, they are tempted to cut corners.

3
How do you ensure
the code is secure?

Among many other considerations, we follow the recommendations of the OWASP Foundation. For example, we check our applications for vulnerabilities in authentication or access control, we take precautions to protect sensitive data, and we don’t use components with known vulnerabilities.

4
What ISO standards do you comply with?

We can follow any ISO standard upon request. We ask that you provide this information before we estimate your project, however. This is because ISO standards require specific documentation and/or other artifacts that have to be taken into consideration while estimating the project.

Why work with STX Next?

15 years

of market experience

350+

projects delivered

3+ years

average partnership

130+

clients served

350+

professionals on board

6.5 years

average experience of our testers
Examples of Python

projects we’ve delivered

project-tiles-2-1
Industry: Blockchain & Crypto

Blocktrade

Blocktrade is a state-of-the-art crypto trading platform that prioritizes speed, reliability, and safety.

It allows retail users, brokers, professional traders as well as institutional money managers
to trade with crypto assets and indices in a fully audited and highly secure way.

featured in
logo-forbes-1
read the portfolio entry
project-tiles-2
Industry: Fintech

Vyze

Acquired by MasterCard in 2019, Vyze is a leading fintech company for manufacturers and retailers.

Bringing together a comprehensive lending supply, technology, and support, Vyze helps businesses provide simpler, more satisfying financing experiences to their customers, wherever and whenever they shop.

acquired by
logo-mastercard-1
read the portfolio entry

All of our case studies

During our 15+ years on the market, we have delivered 350+ projects for 130+ clients in several dozen industries, ranging from fintech and big data to education and advertising.

browse all

What other services
do we offer?

Web

DEVELOPMENT SERVICES

Mobile

DEVELOPMENT SERVICES

DevOps

SERVICES
Tell us about your project

Speed up work on your software projects and outpace the competition.

Hire Us
photo-matt
Matthew Harris
Director of Business Dev
photo-marta
Marta Błażejewska
New Business Manager