The design and execution of testing scenarios without the use of automation tools, designed for web, mobile and desktop applications, as well as Business Intelligence and Big Data solutions.

These tests are performed using tools which run the appropriate test scripts. Automated tests are used to improve some areas covered by manual tests, ensuring repeatability and speed of execution. Performed in order to test web, mobile and desktop applications, as well as Business Intelligence and Big Data solutions (SQL procedures level).

A type of test that examines the behavior of the application under assumed conditions, performed in web applications, mobile applications, Business Intelligence and Big Data systems.

Our test process is based on ISO 29119.   

We’ve collected the most common myths associated with hiring software testers.

“Testing is a cost that I cannot afford”

It’s true that it is necessary to have a bigger budget to hire a tester, but this can be looked at as a type of investment in the project. Hiring a tester allows you to significantly reduce the cost of software development:

• Testers have extensive experience in analyzing project documentation, which allows you to eliminate bugs before the production process begins.
• Improving documentation costs several, or even several dozen, times less than repairing the production environment.

“Testers delay the process”

• The presence of a tester allows developers to focus on software development – without a tester, they have to do this work themselves, which significantly lengthens the development process and reduces its quality.
• Even if there is a situation in which testers block the release of a new version of the software, it is only if its introduction would cause critical errors in the production environment, which in turn could affect the confidence of customers and harm the company’s image.
• Testers have the right competences to determine what scenarios need to be carried out, which reduces the duration of the test process while maintaining its high quality.

“Why should I pay for your mistakes?”

Unfortunately, the software development process is very complicated and there is no way to completely avoid mistakes. Testers do not just test. Developers often only have knowledge of the modules they have created. The tester, on the other hand, has a knowledge of the entire application, which allows for proper integration and allows us to avoid errors resulting from it. Each person interprets the guidelines or requirements provided in their own way, which is why every element in the software development process must be verified by at least two people. For this reason, it is good for one of them to be a tester who, thanks to their knowledge and experience, is able to perform this task better than a developer. The developer would need to spend more time on it, and the end product could end up worse as a result.

“Are your developers so bad?”

The programmer’s experience and level of knowledge have a significant impact on the quality of the software they develop. Unfortunately, as humans, we cannot avoid certain aspects. This is why you should entrust software testing to qualified testers.

• Each person has their own unique way of thinking and analyzes the requirements in their own way. Even the best programmer can draw an incorrect conclusion based on the documentation – the tester can easily verify it.
• The rule is that you should not test your own code. The developer may have a tendency to prove that the software works properly. Such attachment to the results of one’s own work has an impact on the objectivity of tests. Since someone else should check the code anyway, it is worth having a person with specific knowledge in this area to take care of it.
• Thanks to the presence of the tester, developers can focus on their part of the project, which means they do it faster.
• In a situation where the developer tests the application themselves, the quality, security and performance of the application is in the hands of a person who does not have specific knowledge in this area. The hidden problems associated with this approach will show up in a production environment, where any change is associated with huge costs.

It depends on the number of projects that we are working on at that time, but we always try to address the urgent needs of our clients.

We have competences in managing the test environment.

We provide both entire teams and individual testers.

It always depends on the number of projects that we are currently working on and whether we have testers who are available immediately.

Yes, we have both competences and experience in mobile application testing.

Our testers speak the following languages:

• English
• Polish
• French
• German

We have two types of approach to BDD projects. The first of these are projects in which we use BDD elements, such as frameworks for test automation (e.g. Serenity BDD, Cucumber or Specflow). The second type are projects based on the BDD approach in a more complex way. In this case, we provide / supplement documentation for analyzing, developing and testing software based on BDD. In our view, the BDD approach should be combined with the TDD approach, where BDD provides functions described with use of natural language, and TDD, as the process, should cover them. For good cooperation, we use tools such as Hiptest, with dynamic documentation, or test frameworks such as SpecFlow.

Yes, we run tests using the agile methodologies. Projects:

• STANUSCH TECHNOLOGIES

Yes, it is possible. We provide testing services in a flexible “as a service” model, thanks to which the client has access to services regardless of the duration of the project and the number of specialists needed.

Yes, our testers are willing to travel abroad to visit clients, but the length of business trips is always agreed with both the client and the employee.

We have the necessary competences to conduct training for the client’s testers.

Yes, based on TPI NEXT (Test Process Improvement), we can analyze the areas which need improvement.

Yes, in some situations it is possible. In the case of international projects, this mainly relates to onboarding at the client’s site, the start of new projects or periodic organizational meetings.

We have experience in the following areas:

• Automated GUI end-to-end tests
• Automated API tests
• Manual tests
• Performance tests (at the basic level)

Costs and rates are tailored to the project requirements, the level of tester competence required to carry out the project, and the duration of the project.

We broaden our knowledge by participating in conferences, external and internal training. JCommerce also carries out many interesting dedicated projects for testers that allow them to share and obtain knowledge, such as the JTester Academy, “JStaż”, ShareIT, and BiteIT. All testers working at JCommerce also have access to the Pluralsight platform and the support of mentors.

Yes, we have the necessary competences to audit the testing process. JCommerce testers have the following certificates:

• ISTQB Advance – Test Manager
• ISTQB Advance – Test Analyst
• ISTQB Advance – Technical Test Analyst
• ITIL® Foundation Certificate in IT Service Management
• PSPO I (Professional Scrum Product Owner)

For project management, we use Gitlab, JIRA, Azure DevOps Server, X-Ray, TestRail, QATouch, and HipTest. We also use test automation tools. Of course, it all depends on the type of the project and the specific needs. We have experience in automation and the use of languages such as Java, Python, C#, and JavaScript, but we mostly use Java and C#.

Depending on the particular case, we use various frameworks. We have experience in automating tests for mobile, web, API and desktop applications for Windows software as well as macOS applications. In most – but not all – cases, these frameworks are based on Selenium. Our portfolio includes projects in which we use tools such as Selenium Webdriver, WebDriverIO, Serenity BDD, Serenity ScreenPlayPattern, Cucumber, Spock, Specflow, Selenide, Watir, Atata, PyTest, Appium, TestComplete, Postman, RestAssured, JUnit, TestNG, and BrowserStack.

To run performance tests, we use:

• JMeter
• Gatling
• BlazeMeter
• Flood.io
• LoudUI at the basic level

We carry out basic security tests in accordance with good practices provided, e.g. by OWASP. More complex tests are delegated to external contractors to increase test independence.  

We work based on ISO 29119 standards and create documentation accordingly. We mostly create:

• Testing process management documentation
  • Test plans (including strategy)
  • Test status reports
  • Test completion reports
• Dynamic documentation of the test process:
  • Test project specifications
  • Test case specifications
• Documentation of current test results
  • Test results
  • Tests performed
  • Test incident reports

Yes, JCommerce specialists have already implemented test processes for clients from scratch. In one software development project, the client needed support in implementing both tests and work methodology in Scrum. It was a challenge for both us and the client, but we managed to successfully implement new processes and introduce best practices. Currently, JCommerce’s team of testers successfully supports the client by implementing both automated and manual tests and introducing best project practices working in Scrum.

The most common problems we face are time pressure and high priority tasks.

To prevent issues with implementing projects on time, our testers react immediately when such a risk occurs. In such a situation, open communication with the rest of the team and supervisor, as well as with business representatives responsible for the project on the client side, is very important. It is also necessary to prioritize tasks in software development process in such a way as to prevent a situation in which there is no time for testing. If necessary, meetings between the development team and the client are also organized to discuss the problem and action plan. This allows the project to be implemented in such a way that the most important functionalities are delivered within the agreed time and with no impact on their quality.

The manual test is prepared by a quality engineer and the scenario is performed by an actual person.

Advantages:

• Performing the test once is quicker
• Hiring a manual tester is cheaper than hiring an automating tester
• Manual testing allows you to detect new bugs while performing the same actions – the tester can analyze the entire application

Disadvantages:

• Layering of functionalities – in the case of complex applications, it may turn out that there is no time to perform manual tests of all functionalities.
• Difficulties in checking a large amount of data at once (for example, a board of 50 rows with complex calculations)
• The need to manually prepare and complete reports

Carrying out only automated tests is a trap that many customers fall into. Automated tests check known paths and are focused on a specific result. In turn, manual tests check unknown paths, which is of great value in the project, regardless of whether there are automated tests or not. Without intuition and the manual tester’s ability to explore, as well as their experience and knowledge, it may turn out that the team does not catch the most costly mistakes.

Automated tests – advantages and disadvantages

The automated test is a scenario prepared by an automating engineer in the form of a script, which can be run in a given environment, so that it is performed without interference from the user.

Advantages:

• Properly prepared scripts allow you to quickly assess the quality of the entire application after implementing changes.
• Automated tests help to avoid the problem of layering of functionalities.
• They allow you to check a large amount of data at once, which would be labor-intensive or even impossible in the case of manual tests
• “Living” (dynamic) documentation – test scenarios must be updated as the application changes.
• Automatically generated test reports.
• Easier to combine tests at many levels (UI, API, database, etc.)
  

Disadvantages:

• The high initial cost of preparing automatic scripts.
• Automated tests only check what we want them to – there is a small chance of finding new bugs
• The need to maintain tests in the context of changes in the application
• The need to prepare the application infrastructure for automated tests (separate database, environment, user accounts)

Automated tests work best when regression is needed (re-testing the system after implementing changes) in maintenance projects. They also work well as regression tests in large complex projects, where regression takes so much time that it would simply be unprofitable.