🚀 NEW: Pop-up Windows Recording - [See how to test seamlessly OAuth integrations](https://docs.bugbug.io/recording-tests-steps/record-pop-up-window-actions)

Software Testing Knowledge

Software developer currently working as a tech writer and PM.  
[linkedin.com/in/marcin-%C5%82ojewski-a4191518/](https://www.linkedin.com/in/marcin-%C5%82ojewski-a4191518/)

Marcin Łojewski

[TABLE_OF_CONTENTS]


Testing software is really important during its development to ensure it works well and gives users a good experience. As software testing keeps changing, it's crucial for quality assurance professionals and [people who want to be testers](https://bugbug.io/blog/software-testing/how-to-become-automated-test-engineer/) to keep learning about the latest trends and the best ways to do their job. YouTube is a great place for learning and sharing knowledge, especially for those in software testing.

This article will introduce the best **Software Testing YouTube Channels in 2023**. These channels have much helpful information, tutorials, and insights to help software testers improve their skills, stay updated on the newest testing tools and techniques, and succeed in their testing careers. 

If you're interested in software testing, check out these channels and learn from them! You'll find valuable and practical content to grow in your testing journey.

In addition to YouTube, online forums and communities related to software testing are also excellent resources for gaining insights and sharing experiences. Engaging with these communities can provide a platform to ask questions, seek advice, and connect with fellow testers worldwide. The collective knowledge and support within these communities can be invaluable in navigating the ever-evolving software testing landscape. 

Embracing these diverse learning opportunities will empower testers to stay at the forefront of their field and continuously enhance their expertise. So, whether it's YouTube channels, forums, or other digital platforms, the key is to be proactive in seeking knowledge and being open to learning from others.

## 1. EvilTester

![EvilTester YouTube Channel](https://bugbug-homepage.s3.eu-central-1.amazonaws.com/Screenshot_2023_08_08_at_17_30_54_deb2f972e1.png)

**Alan Richardson**, the genius behind EvilTester, has more than 25 years of experience in software development. His channel is a valuable resource for software teams to test and improve their creations. EvilTester focuses on agile testing, Java, Selenium, and other important topics, providing useful tips for testers and developers.

Alan's tutorials and real-world examples are easy to follow and understand, even if you're new to testing or development. EvilTester's content equips you with the right tools and mindset to succeed in the ever-changing world of software testing and development. Besides, each video has an attention-grabbing and informative [YouTube thumbnail](https://www.adobe.com/express/create/thumbnail/youtube){rel="dofollow"} . 

Besides the tutorials, Alan's channel has a supportive community where people can discuss, share knowledge, and solve problems together. This community enriches the learning experience with diverse perspectives and experiences.

Overall, EvilTester is a must-visit for anyone who wants to improve their testing and development skills. Following Alan's advice will help you handle the complexities of software testing and create excellent solutions that meet users' needs.

YouTube Channel Link: [https://www.youtube.com/user/EviltesterVideos](https://www.youtube.com/user/EviltesterVideos)


## 2. SDET - QA Automation Techie

![SDET QA Automation Techie YouTube Channel](https://bugbug-homepage.s3.eu-central-1.amazonaws.com/Screenshot_2023_08_08_at_17_32_55_393759eb36.png)

**The SDET - Software Testing YouTube Channel** is like a treasure chest full of educational videos all about SDET and test automation. It's totally focused on providing tutorials and knowledge about different things, like Unix/Linux for testers, Apache POI, Java streams, Lambda Expressions, Selenium locators, Postman for beginners, and more.

Whether you're already a big fan of automation or just starting out, this channel has something helpful for you. The tutorials are made to be easy to understand, so even complicated ideas become simple. By watching these videos about SDET and test automation, you can improve your skills and keep up with the latest trends and techniques.

As you explore the SDET - QA Automation Techie channel, you'll better handle automation challenges and succeed in your testing career. With lots of tutorials to choose from, it's the best place to learn more about automation and become a tech-savvy tester. Remember to subscribe and find all the valuable tips and tricks waiting for you!

YouTube Channel Link: [https://www.youtube.com/user/pavanoltraining](https://www.youtube.com/user/pavanoltraining)

->[Automate your tests for free](https://app.bugbug.io/sign-up/){.markdown-cta}<-

## 3. Naveen AutomationLabs

![Naveen AtuomationLabs YouTube Channel](https://bugbug-homepage.s3.eu-central-1.amazonaws.com/Screenshot_2023_08_08_at_17_35_26_59f07993d4.png)

**Naveen**, an SDET/Automation Architect, really loves automating things in everyday life. His channel has many videos about different topics, like JVM technologies, JMeter, Selenium-WebDriver, QTP/UFT, Python, Protractor, Maven, GitHub, and even tips to prepare for interviews.

Whether you're already into automation or just curious about it, Naveen's channel has something interesting for you. He explains things in a simple way, so even if they seem hard, you can understand them easily.

Watching his videos will help you learn about JVM technologies, testing tools like JMeter and Selenium-WebDriver, and coding languages like Python. You'll also find useful information about Maven, GitHub, and even how to prepare for job interviews.

So, remember to check it out and explore all the exciting topics he covers!

YouTube Channel Link: [https://www.youtube.com/user/naveenanimation20](https://www.youtube.com/user/naveenanimation20)


## 4. Automation Testing with Joe Colantonio

![Joe Colantonio](https://bugbug-homepage.s3.eu-central-1.amazonaws.com/Screenshot_2023_08_25_at_11_30_24_cf56594a95.png)

**Automation Testing with Joe Colantonio** channel is a comprehensive resource for software testers and automation enthusiasts. You will find a wide range of tutorials, discussions and insights in Joe’s videos. The channel covers topics like test automation with popular tools such as Selenium, Appium, and TestNG, while also exploring emerging trends like AI in testing.

Adding “breaking news in testing” to the channel gives a certain level of confidence that the author keeps us (and himself) in the loop for the newest of testing technologies.  There are also separate series for beginners and for those who wish to learn new tools. 

This channel is definitely worth subscribing to.

YouTube Channel Link: [https://www.youtube.com/@JoeColantonio](https://www.youtube.com/@JoeColantonio)

## 5. Software Testing Mentor

![Software Testing Mentor YouTube Channel](https://bugbug-homepage.s3.eu-central-1.amazonaws.com/Screenshot_2023_08_08_at_17_37_04_650c6959e8.png)

**The Software Testing Mentor's channel** is like a goldmine of testing stuff! It has many videos about automation testing, performance testing, API testing, and other important topics. The best part is that they focus on showing you how to do things with your own hands and in real-life situations. This makes it easy for you to learn and practice practical testing skills.

Whether you're new to testing or already know a bit, this channel has something valuable for you. You'll watch and learn how to do automation testing, check software performance, and test APIs. The tutorials are simple to follow, and you can see how testing works in the real world.

YouTube Channel Link: [https://www.youtube.com/c/SoftwareTestingMentor](https://www.youtube.com/c/SoftwareTestingMentor)

## 6. Testing Mini Bytes

 
![Testing Mini Bytes YouTube Channel](https://bugbug-homepage.s3.eu-central-1.amazonaws.com/Screenshot_2023_08_08_at_17_38_03_40032bc986.png)


**Testing Mini Bytes** is a channel that provides small and easy-to-understand videos about testing. It covers different testing topics, like Selenium WebDriver, TestNG, Java, and other testing tools. The best part is that the tutorials are short and informative, making it simple for viewers to learn and use testing techniques quickly.

Whether you're just starting in testing or want to enhance your skills, this channel has something useful for you. You can watch and grasp how to use Selenium WebDriver, TestNG, and Java for testing. The videos are brief but packed with helpful information to help you learn and improve your testing abilities.

YouTube Channel Link: [https://www.youtube.com/c/TestingMiniBytes](https://www.youtube.com/c/TestingMiniBytes)

## 7. LetCode with Koushik

![LetCode with Koualik YouTube Channel](https://bugbug-homepage.s3.eu-central-1.amazonaws.com/Screenshot_2023_08_08_at_17_41_33_c6d0d5f686.png)

**LetCode with Koushik**, hosted by Koushik, is all about test automation using Selenium WebDriver with Java and C#. The channel offers practical examples and easy-to-follow tutorials to help viewers become masters of automation testing.

Whether you're new to test automation or want to improve your skills, LetCode with Koushik has something valuable for you. You can learn how to use Selenium WebDriver with Java and C# for automation testing. Koushik's practical examples make it simple to understand and apply to your own projects.

YouTube Channel Link: [https://www.youtube.com/@letcode](https://www.youtube.com/@letcode)

->[Automate your tests for free](https://app.bugbug.io/sign-up/){.markdown-cta}<-

## 8. Software Testing Help

![Software Testing Help YouTube Channel](https://bugbug-homepage.s3.eu-central-1.amazonaws.com/Screenshot_2023_08_08_at_17_42_41_5ccf15a6bf.png)

**Software Testing Help** is one of the oldest and most popular educational YouTube channels for software testing. It has many videos on software testing tutorials, methodologies, manual testing, automation testing tools, interview questions, and much more. This channel is a top-notch resource for testers looking to enhance their skills and knowledge.

Whether you're new to testing or an experienced tester, Software Testing Help has something valuable for you. You can find tutorials on different testing methods, learn about manual and automation testing, and prepare for job interviews. The videos are packed with helpful information to support your testing journey.

With Software Testing Help, you can become a better tester and stay updated with the latest testing trends and techniques. 

YouTube Channel Link: [https://www.youtube.com/user/shindevijaykr](https://www.youtube.com/user/shindevijaykr)

## 9. Execute Automation

![Execute Automation YouTube Channel](https://bugbug-homepage.s3.eu-central-1.amazonaws.com/Screenshot_2023_08_08_at_17_45_16_7dc8ed3133.png)

**Execute Automation** is dedicated to automation testing and offers tutorials on TestRigor, GraphQL, Jenkins, and other topics. As the subscriber base grows, this channel provides valuable insights for automation enthusiasts.

Whether you're new to automation testing or already passionate about it, Execute Automation has something beneficial for you. You can learn about TestRigor, GraphQL, Jenkins, and more through their tutorials. The content is designed to be helpful and informative, making it easy for you to grasp the concepts.

By following Execute Automation, you can expand your automation knowledge and keep up with the latest trends in the field. It's a fantastic resource for anyone interested in automation testing and seeking to enhance their skills. 


YouTube Channel Link: [https://www.youtube.com/c/ExecuteAutomation/videos](https://www.youtube.com/c/ExecuteAutomation/videos)

## 10. The Testing Academy

![The Testing Academy YouTube Channel](https://bugbug-homepage.s3.eu-central-1.amazonaws.com/Screenshot_2023_08_08_at_17_47_02_14f44297c0.png)

**The Testing Academy** provides detailed tutorials on software testing, including SDET tutorials, Selenium tutorials, API testing, Karate API Testing, Rest Assured tutorials, Protractor tutorials, and more. With almost 30k subscribers, this channel is a favorite among testers seeking to broaden their knowledge.

Whether you're new to testing or already have some experience, The Testing Academy has valuable content for you. You can explore tutorials on different testing topics like SDET, Selenium, API testing, and more. The tutorials are designed to be helpful and informative, making it easy for you to understand and apply the concepts in your work.

By following The Testing Academy, you can enhance your testing skills and stay updated with the latest trends in the testing world. It's a popular choice for testers looking to grow their knowledge and improve their testing abilities. Take advantage of the wealth of information this channel has to offer!

YouTube Channel Link: [https://www.youtube.com/channel/UC2TpiJFaC0f4_5GopyMkDdQ](https://www.youtube.com/channel/UC2TpiJFaC0f4_5GopyMkDdQ)

->[Automate your tests for free](https://app.bugbug.io/sign-up/){.markdown-cta}<-

## 11. Mukesh Otwani

![Mukesh Otwani YouTube Channel](https://bugbug-homepage.s3.eu-central-1.amazonaws.com/Screenshot_2023_08_08_at_17_48_43_73cde22491.png)

**Mukesh Otwani's channel** is a fantastic testing hub with a wide range of content on automation testing tools. It covers topics like Selenium WebDriver, TestNG, Maven, Appium, Sikuli, Git, GitHub, RPA, Java, SoapUI, API Testing, Protractor, Cucumber, and much more. With almost 100k subscribers, this channel is the go-to choice for those seeking automation expertise.

Whether you're new to automation testing or already have some knowledge, Mukesh Otwani's channel has something valuable for you.

You can explore tutorials on various automation testing tools and technologies like Selenium WebDriver, TestNG, Maven, and more.

The content is detailed and user-friendly, making it easy for you to grasp and apply in your testing projects.

By following Mukesh Otwani's channel, you can level up your automation skills. It's a top choice for anyone seeking to become an automation expert. 

YouTube Channel Link: [https://www.youtube.com/user/MrBantu50](https://www.youtube.com/user/MrBantu50)

## 12. G C Reddy Software Testing

![GC Reddy Software Testing YouTube Channel](https://bugbug-homepage.s3.eu-central-1.amazonaws.com/Screenshot_2023_08_08_at_17_50_54_4a94c96576.png)

**G C Reddy's channel** is a paradise for testers with a wealth of resources. It offers tutorials, interview preparation help, job postings, a software testing forum for discussion, quizzes, ISTQB certification guidance, and much more. With over 50k subscribers, this channel has become a valuable asset to the testing community.

Whether you're new to testing or an experienced tester, G C Reddy's channel has something beneficial for you. You can find tutorials on various testing topics, prepare for job interviews, and even join discussions in the testing forum. The quizzes and ISTQB certification guidance will help you test and improve your knowledge.

By being a part of G C Reddy's channel, you can connect with other testers, learn new skills, and stay updated with the latest in the testing world. It's a valuable resource for anyone in the testing community. 

YouTube Channel Link: [https://www.youtube.com/user/gcreddy7](https://www.youtube.com/user/gcreddy7)


## 13. Learn with RV

![ Learn with RV](https://bugbug-homepage.s3.eu-central-1.amazonaws.com/Screenshot_2023_08_25_at_11_34_31_a090e280e6.png)

**Razvan (RV)** hosts a channel dedicated to sharing knowledge on programming, automation testing, and software development. He covers test automation frameworks, programming languages and tools (Selenium and Cucumber for example). You will also find quite a few videos on topics related to devops and linux.

Less experienced testers may benefit from his approachable teaching style that simplifies complex concepts. RV's tutorials often provide a deep dive into hands-on coding and practical examples, making it easy for viewers to follow along and grasp key concepts. The channel also emphasizes real-world applications of automation testing, showcasing how to solve common testing challenges using various tools and frameworks. 

YouTube Channel Link:  [https://www.youtube.com/@LearnwithRV](https://www.youtube.com/@LearnwithRV)


## 14. Software Testing by Daniel Knott

![Software Testing by Daniel Knott](https://bugbug-homepage.s3.eu-central-1.amazonaws.com/Screenshot_2023_08_25_at_11_36_52_7f68eb1b46.png)

**Software Testing by Daniel Knott** is a relatively new (the oldest videos date to 2022) channel produced by an accomplished author of books and online courses on testing. The channel covers a wide range of topics including manual testing, test automation, testing methodologies, tools, and industry best practices. Viewers can gain practical knowledge, learn about different testing approaches, and understand how to ensure software quality. But he also covers “softer” skills like why go to testing conferences and how to perform on them.


The channel not only dives into automation testing but also provides comprehensive guidance on manual testing techniques. Moreover, the channel's emphasis on testing methodologies and industry insights helps viewers understand testing in a broader context. It gives a great perspective to both beginners and experienced testers, offering a good chunk of knowledge on software testing practices.


YouTube Channel Link: [https://youtube.com/@DanielKnott](https://youtube.com/@DanielKnott)

## 15. The Test Therapist

![the test therapist](https://bugbug-homepage.s3.eu-central-1.amazonaws.com/Screenshot_2023_08_25_at_11_40_18_37c857a0f3.png)

**The Test Therapist** is one of the most intriguing and emerging newcomers on YT. From exploratory testing to strategic test automation, viewers can uncover practical wisdom to elevate their testing skills and adopt a comprehensive approach to ensuring software quality. 

The owner is up to date with the market which he shows by using some early access features for his videos. 

YouTube Channel Link: [https://www.youtube.com/@thetesttherapist](https://www.youtube.com/@thetesttherapist)

## Conclusion

In conclusion, the **Software Testing YouTube Channels** listed above offer a vast array of resources and tutorials for quality assurance professionals and aspiring testers. Whether you're looking to master test automation, dive into performance testing, or improve your manual testing skills, these channels have something to offer. 

As the software testing field continues to evolve, leveraging online platforms like YouTube becomes increasingly crucial for continuous learning and professional development.

Remember that staying well-rounded in testing expertise is essential, and automation is just one piece of the puzzle. Manual testing, security testing, user testing, and other testing-related skills are equally valuable and deserve attention. 

Embrace the wealth of knowledge available through these YouTube channels and take your software testing career to new heights in 2023 and beyond. 

Also, check our list of [The Best Software Testing Podcasts](https://bugbug.io/blog/software-testing/best-software-testing-podcasts/).

Happy (automated) testing!




Best Software Testing YouTube Channels for QA in 2023

small_Test plan template (18).png

thumbnail_Test plan template (18).png

Test plan template (18).png

[TABLE_OF_CONTENTS]

Is there anything bugging you? Maybe those nasty little creatures creeping their way thru your beautiful code? Bugs, they call them, see? They are mean, hideous, odious and vile. (yes, we launched the synonym dictionary for that one). They live to damage your code, to make you lose time and effort and money. 

It is almost like playing hide and seek for money. 

Your money. It is time to take out the bug spray and go bug hunting. We bring you **10 tips how to discover bugs** in your app in a more effective and structured way.

## Navigation and links in your app

We start with one of the most annoying website bugs. From the perspective of the end-user that is. 

Picture this - you found an e-commerce store that sells those “stop bugging me” t-shirts you always wanted. You navigate to a button with a mailto link and you’d like to ask whether they can come in pink. You click the button and realize that it wants to send an e-mail to test@test.com. 

Your **navigation needs to be 100% functional.** Period. Whether we are talking about the menu, outgoing links, internal links or even anchor links, they all need to work. If not, why would you put it in the first place?

Luckily this is one of the most basic functionalities of test automation tools like [BugBug](https://bugbug.io/features/). You can put together a set of tests in a relatively short period of time. Run them whenever you like and react if the tests actually find a bug. 

## Is there a bug in my form?

Forms are tricky. In many cases they are a crucial piece of code and a common place where bugs in the code occur. From the software development perspective a form not only needs to send input values elsewhere. 

It also needs to be protected from sending unwanted content. And given the fact you can do that both from the front-end and the back-end point of view makes it a good place for a software bug to be. 

There is a wide range of use cases for a form. You want to login - a form, send something to the database - a form, create a user - a form. 

Forms are everywhere. 

It is crucial to find the bugs that might be located not only at the functionality layer but also in error message handling or the styling. That means that your form might have many types of software bugs at the same time.

**Debugging a form might be also handled with a test automation tool.** One of the most crucial things you need to prepare beforehand is a dataset. Dummy data of all sorts and sizes will allow you to thoroughly check both the functionality and security of your forms.

->[Automate your tests for free](https://app.bugbug.io/sign-up/){.markdown-cta}<-

## C is for Cookie

When we were kids, cookies were all positive. Chocolate chip cookies for desert and the blue guy from Sesame Street. Now the first thing that comes to mind are all the pop-ups, forms, checkboxes and legitimate interests. Adulthood sucks big time!

From the business and software engineering perspectives **cookie data and session data are rather important**.

Important enough to plan a specific testing phase just for them. You need to detect whether the cookie is deleted after the designated time or after clearing cache. 

Does the app stop the session when it needs to etc. This might not seem significant, but a buggy code might cause serious security risks for example if the logout process is handled incorrectly. 




## Find bugs in your HTML and CSS code

There are two entities in the Universe that go thru your HTML and CSS. First are developers, who laugh at the looks of your website's console. Others are search engine bots. The latter are rather significant since they detect incorrect code and can make your site difficult to find. We do not want that.

Although syntax errors in HTML and CSS rarely break the application, they may decrease the usability and accessibility. Make sure your code **complies with accessibility standards** (e.g., WCAG 2.0 or 2.1). Verify that all elements are keyboard-navigable and provide appropriate alt text for images.

Assess the performance impact of the HTML and CSS code on the web application's loading time. Optimize the code for faster rendering and minimize any unnecessary requests or redundant stylesheets.




## Business workflow - test if your software actually works

Remember our article on [test scenarios](https://bugbug.io/blog/software-testing/test-case-vs-test-scenario/)? Here is when it comes in handy. In order to find bugs in code you need to leave your software tester experience behind for a moment. 

You have to become the user and just try to break the thing - meaning you have to consider negative scenarios as well. Good example is trying to buy "%" or "G" products in an e-shop. 

Try to think of a simple thing the user would like to do, not something difficult to reproduce - purchase an item, download a file and draw a path which he or she would use. 

Each step on the path would be a separate test case within the scenario. It is the **most natural way to find bugs** in software applications.  Those tests are easy to automate. While creating scenarios you end up with a bunch of cases that you might reuse in different ways in your tool.

->[Automate your tests for free](https://app.bugbug.io/sign-up/){.markdown-cta}<-

## Does it work the same on all browsers and devices?

That's a big one. Cross-browser and cross-device compatibility testing is something that is often ignored by less experienced teams or freelancers. In the era of responsive web design and "mobile first" approach it is easy enough to emulate mobile devices during the development process. 

Also the most popular testing tools have this functionality. It is wise to use it, since recently clients tend not to understand the "it works for me" excuse many generations of developers used. 

The best coverage can be obtained by **emulating multiple combinations of environments**. For example - web browser A and operating system A, web browser B and operating system A (specific brands ignored on purpose). And so on. 

You have to make sure your application is compatible with the most popular environments. Not only with the one your development team has been using forever.

There can be some hardcore examples here as well. Many years ago, while doing one of the first commercial projects ever, I hardcoded a few width values inside a div. It looked smashing on my monitor. When I presented it to the client, it was 150% of his screen. 

**BaDumTss.** So yes - every now and then you have to even consider monitors. 



## Security tests

Things are getting serious. As they always do with security. First of all, whatever user data you store and use, you must protect them like your dearest treasure. We have news flashing that websites have leaked user's passwords or credit card numbers on an almost weekly basis. 

**Don't be that person.**

You have to encrypt your database records, and do some preventive measures that would limit the severity of a potential unauthorized access.

Security testing is not limited to the user data. Some of the parts of your app may be available for authorized users. The same might happen for downloadable files. You have to test such matters like if the session is automatically killed after some time of inactivity or whether an SSL certificate is in place.



## Use all available resources

There is more into testing than just automation tools. Two of the biggest and most powerful resources are always there for you and they are free. We are talking about developer tools and logs. 

The former are located in most of the current web browsers (try pushing F12 while reading this and let the magic unveil itself). 

**4 core functionalities are:**

- Inspecting HTML, CSS elements and DOM structure
- Checking the browsers' console for errors, warnings or JS issues
- Analyzing network requests for delays, API failures etc.
- Utilize performance profiling tools to assess the application's speed, identify bottlenecks, and optimize resource usage

The latter provide insights into exceptions, crashes, or unexpected behaviors occurring during application execution. You should **monitor the logs on a regular basis.** If you are not a fan of browsing thousands and thousands of records, worry not - there are tools that will help you with that task.




## Regression testing

[Regression testing](https://bugbug.io/blog/software-testing/everything-you-need-to-know-about-regression-testing/) is checking whether implementing changes to your software did not result in breaking something that worked before. They check whether your application regressed as you introduced new features, updates or patches. Assuming that a functionality that was created and tested will remain good forever is a common mistake. 

**Sometimes it might be a costly one as well.**

It is not that hard to execute regression testing. Especially with modern tools like BugBug. This type of testing is basically running the same tests on an iterative manner while adding some more after every new chunk of project's code is implemented.

It takes some effort to set it up, but it decreases with every iteration. 

->[Automate your tests for free](https://app.bugbug.io/sign-up/){.markdown-cta}<-

## We, the people!

Your team has been working on this app for what seems to be ages. Everybody claims to know it by heart already. You, as the QA, can foresee the outcome of every test case before it is written. Still - the app crashes every now and then. You ran out of ideas on how to test or break it, because your experience with the app limits your imagination. 

But there is the group of superheroes, who will always find a way - the users.

**Beta testing or crowdtesting** if you will, has been around for a while now. 99% of the apps in the world are created for a client. It does not need to be someone who will pay for it. But that client will have some needs and some requirements for the software. 

They are the most reliable source of test cases there is. 

Obviously a vast majority of them will follow the business scenarios as designed and will seldom find something not covered by tests. But there are these few. Every app has them - the seekers and the goofballs. 

The first will not go to sleep calmly unless they click every... single.. link... or button.. in your application. Those thorough ones will specify and describe the most deeply hidden bugs. 

**They are a gem!**

The second will cover bugs that you have never dreamt of testing. "Well I clicked here, disabled my microphone, a cat ran across my keyboard and I managed to buy minus three t-shirts". Sometimes it may be difficult to recreate such a test case, but do not underestimate the goofballs!


We hope you enjoyed our tips on how to find bugs in your code. Bug detection is elemental for your business. Every error in the software may cost you a lot of money, a lot of effort and a lot of image. 

Luckily you have at least 10 places where you can look for those mean beasts.


Happy (automated) testing!


small_Test plan template (13).png

thumbnail_Test plan template (13).png

Test plan template (13).png

10 Tips on Finding Bugs in Your Code

[TABLE_OF_CONTENTS]

## What is a regression test anyway?

Regression testing will show you if you broke something in your code while fixing or creating something else. Remember this meme? 

![regression testing meme](https://bugbug-homepage.s3.eu-central-1.amazonaws.com/e5cbcdbe_b3c8_45d9_9ca1_7aa277bebccf_69c3ee5cb1.jpeg)

That’s basically why regression testing is done within your web application or other piece of software. We believe there is a need for a professional explanation for this one. 

[Regression testing ](https://bugbug.io/blog/software-testing/everything-you-need-to-know-about-regression-testing/)is a software testing method that aims to investigate and locate any possible flaws or bugs in software that has completed a development cycle. Regression testing is performed to find out whether your software has regressed (surprise, surprise) as you continue introducing new updates and bug fixes. Whenever a piece of software is changed in any way, new bugs might emerge and some of the older ones re-emerge.

Most often, regression testing process is performed immediately after introducing a new update, but it isn’t the only factor that might call for the test. If any software or hardware-related factor has changed, regression testing should be committed to find out whether everything performs as it has before the change.

## When is regression testing done and what to consider?

There are multiple factors to consider when you are planning regression tests. The test scope and test coverage (what will be tested), the priorities (if you have to limit yourself) or test environment. But in order to answer the “when” question you have to start with getting one piece of information. Do you handle your project in an agile way or the waterfall?

There is one big difference in planning the test and the future regression test automation. If you are an agile team, you can do regression tests in an iterative way and basically you can do those every sprint just after a chunk of code was released. It will take a bit more test cases to create but with proper automation the test coverage might be enormous.

For waterfall teams - yes you guys have to wait until the patch or update is completed to do regression testing. The big advantage though would be that your regression test suite will surely take place in a separate cycle in the life of the software. All eyes will be on you there. You sure love the spotlight, don’t you waterfall people? 🙂

->[Automate your tests for free](https://app.bugbug.io/sign-up/){.markdown-cta}<-

## Why do teams perform regression testing?

It is more to that in this type of testing of web applications than detecting regression defects. Regression test cases are there to protect you from system instability. It helps to maintain the overall reliability and integrity of the software you have created. Regression testing of web applications is crucial to a good user experience. 

Regression testing ensures that your business runs smoothly, not only your code does. Detecting flaws before they reach the production environment is crucial to your image and incomes. Why would you create and promote an update or a patch that disables a different aspect of your software? You have to provide high quality products to the market. 

A proper testing team and the right regression testing tools are there to protect you. If your company creates games, or a simple CRUD app, the customer impact might be not that enormous. But trust us, within all organizations that develop software crucial to their users' existence or business (i.e. operating systems) there are dozens of hours used for regression testing.

->[Automate your tests for free](https://app.bugbug.io/sign-up/){.markdown-cta}<- 


## What to look for in an automated regression testing tools?

It is relatively easy to make a comparison article. 

The key to make it a good one is to give some reasoning behind your choices. We have prepared a few hints on what your checklist should include while browsing the web for an automated test tool for regression testing. 

One thing you need to understand beforehand - we stress it everywhere we can. Always think of your resources while preparing the checklist. We will not try to prove that a low-code tool is better than a full-code software. They are suitable for different teams and products. Let us actually start with that one.


### How much testing and coding experience does the automation testing tool require?

Nowadays you can fully complete test suites without writing a single line of code. Apart from reducing the time and money of the testing effort, that means that testing can be done by a member of non-technical personnel. 

Thanks to such solutions a Project Manager can test your software on a regular basis, provide feedback to the development team and launch bug fixing procedures. 

On the other hand you have the full-code tools that are perfect for bigger teams / products and more mature organizations. Those usually have a whole QA team whose job is to execute test cases. 

They have another important asset - such skilled engineers will already have their own favorite automation tool. It will make selection relatively easy - just check if it is able to perform necessary application testing in this case as well.




### Can you perform a manual test and an automated test by using the same tool?

Those fluent in the art of software testing already know that not all test cases can or should be automated. Those less fluent will get to know it eventually :) We discussed it many times before so trust our word on that one. 

If not all of your test cases will be automated, then you will need a tool for automated testing and for manual testing as well. Does it mean that you need to double your effort and search for two software testing tools? Luckily no. 

There are plenty of testing platforms on the market that will cover both bases for you at the same time. Why is it significant? Well… Money! You don’t have to spend twice as much time on looking for tools, your company saves 50% of the costs. Easy enough, isn’t it?




### Does the tool cover functional testing and the visual layer of your app?

From the business perspective the functionality is much more important than the way your software looks, right? Wrong!! Try telling the sentence above to the person in the UX department and watch his/her face change colors rapidly. Both aspects are equally important and there is more and more science in the design aspect nowadays. 

What does it mean to our testing tribe? Well in general it means doubling the testing effort. For such purposes we need tools for automated regression testing that will not only check whether the login form is still working after the latest update. We also need to verify if the blue “Submit” button is still blue. 

This is actually not that common in regression testing. People by rule assume that the visual layer remains intact after each iteration of updates. It means that regression testing is typically focused on the code or best case scenario on DOM operations. If you want to achieve better test coverage, you need to check the blueness of the blue button. Every time.

->[Automate your tests for free](https://app.bugbug.io/sign-up/){.markdown-cta}<-


### How does this testing solution handle test failures?

It does not matter what type of software testing you are performing. Whether it is web testing, API testing, end-to-end testing or what-have-you testing, the aim of testing is to fail. The question is, what happens after the test fails?

While browsing for a regression testing automation tool, always check the bug reporting feature. There are universal factors you have to consider - the speed, the efficiency, how easy it is to set up might be top 3. 

Others might be relevant to your needs - does that tool integrate with my communication? Can it send me an e-mail or a Slack message, when the bug occurs. Last but not least - is it readable for me? Can I easily track the malfunctioning code if I need to? All modern tools aim to satisfy the most demanding clients, but it will be your tool to use so it is your experience that matters. Not everyone else's.

We need to mention one last thing. What happens if the test fails, but it should not? The so-called “false failures” are a true pain. Back in the day dozens of hours were spent on looking for bugs that were not there. 

The tool of your choice will not be immune to that issue. No tool is. Some will give more false failures in the UI department, others will show them in the code. But while you are on your research quest, do verify what is the tool creators’ policy on tracking false failures.



### How flexible is that testing tool?

This is more a business aspect of test automation tool selection. You are looking for a perfect testing tool that will suit your needs and will enable you to pay only for what you actually use? We are sorry to say, but so is everyone else. The best way to have such a tool is to actually create one. 

Instead of looking for perfection, look for flexibility. First of all the quality and quantity of integrations you may perform. Does it fit your CI/CD process? If you need a test environment, does it have one? Does it allow changing the number of tests within a subscription? You can have a gazillion questions like that.

After you perform the “what?” analysis, you have to do the “how much?”. The most flexible ones can prepare a tailor made offer just for you. Such flexibility is only one question away from you.


->[Automate your tests for free](https://app.bugbug.io/sign-up/){.markdown-cta}<- 

## 5 best regression testing tools for a web application

Selecting a regression testing tool is not an easy feat. We assembled a list of 5 top regression testing tools for web applications.

### BugBug

BugBug is a testing tool that allows users to automate functional and regression testing (among others of course). Its very intuitive UI plus a broad scope of functionalities does lower the bar for end-to-end testers or tester wannabes. 

![bugbug test automation tool](https://bugbug-homepage.s3.eu-central-1.amazonaws.com/Screenshot_hero_6311352790.png)

From the business perspective, the low-code approach helps to create automated scripts in less time and effort than the competitors. On top of that we have the whole fully functional (for free if used locally!) recording interface that enables you to record new steps midway thru your testing suite.

It has all the bases covered by having the following functionalities:

- Test recording and replaying
- Intelligent autoscrolling and real clicks simulation
- Test monitoring
- Public API and CD/CI integration
- Plus many other tools to enable the users testing success and cost saving

Let’s come back to the checklist we put above. Does it require much technical skills to start? Not really. The pro-user approach lowers the barrier for team members who are not necessarily qualified testers, but are obliged to create and perform web application testing. It is perfect for companies where people like [Product Managers](https://bugbug.io/solutions/test-automation-for-product-managers/) are fulfilling tester roles. 

How little skills does it take to start? Do check out the test recording feature. Just install a Chrome plugin, click out a test case for your web app and let BugBug do the work for you.

![BugBug test recorder](https://bugbug-homepage.s3.eu-central-1.amazonaws.com/Screenshot_2023_07_07_at_12_48_35_9495620fef.png)

BugBug is a test automation tool by design. We encouraged you to look for a regression testing tool that will allow manual testing as well. This software does the next best thing. You can set up and run individual test cases, re-run and re-record tests as well. 

If your tests need full or almost full test automation - BugBug is perfect. If you need a more manual approach, then it is almost perfect. 🙂

Does it perform UI and functional regression testing? Yes it does. You can easily set up regression scenarios in order to check both functional and visual aspects of your web application. No more browsing the console for HEX codes. 

Also we asked you to check the error handling. Thanks to multiple integration possibilities you can set up the full scale bug reporting. BugBug can send you all kinds of messages, and can be integrated into your CI/CD pipeline. Heck, we can even send you a message via a pigeon if you’d like to. (joke - we can’t). 

Last but not least, the flexibility. Regarding the finances - unless you want to use our cloud solution, [BugBug is free](https://bugbug.io/pricing/). There is no bigger flexibility than that, right? Whereas while speaking of functional flexibility, this tool allows to test across different technologies. Also do check our [documentation](https://docs.bugbug.io/), and find out if we have the right features for you.

->[Automate your tests for free](https://app.bugbug.io/sign-up/){.markdown-cta}<-

### Selenium

For many years the synonym of web application testing. This open source tool is still widely used across the testing universe. It easily integrates with multiple testing frameworks (JUnit for example) providing advanced reporting, test management, and parallel execution capabilities. It is a very mature product full of features and functionalities supported by a vast community. 

But.

It has a huge learning curve. This is a tool for testing pros. Those who learned to code with a pencil and a piece of paper. Imagine a person, who last left home to watch The Beatles in a live concert. You get the picture? 

Also Selenium lacks native built-in reporting functionalities. While it integrates well with various test frameworks that offer reporting features, generating detailed and customized reports may require additional configuration or customization. Nevertheless - still one of the most popular regression testing tools for big organizations. 




### TestComplete

This is also a rather popular choice. One of the most popular no-code tools to be honest. The list of features that it has is simply astonishing. Another huge asset is the cross-platform support. Web app, mobile app, desktop app - you name it. TestComplete will handle it. 

The creators did not forget about a proper set of integration possibilities. It also provides support for custom scripting and extensions, allowing you to enhance and customize your regression tests.

On the other hand there is the pricing. The license costs quite a sum. If you own a startup, or even create a "shelf application", you will definitely be discouraged when you enter the "pricing" subpage on their site. Unfortunately it is also said to have some performance issues. 

### Watir

Another open source tool for regression testing. It is designed in Ruby which might be both in the pros and the cons section. Ruby by rule is a powerful language, but not the most popular. If you do not like it, you might not fancy Watir at all. 

Watir supports multiple browsers. You can create regression tests for Chrome, Firefox, Safari, and Edge. This enables comprehensive regression testing of software across various browser environments.

It is almost impossible to use Watir standalone. It relies on WebDriver, which requires the installation and configuration of appropriate browser drivers for each browser. Managing these dependencies can add some complexity to the setup process.

### Katalon Studio

Last but not least we have Katalon Studio. It is a complete regression testing package. Katalon Studio provides a comprehensive suite of tools for test automation, including test case design, test execution, and result analysis. 

It offers a unified platform that covers all aspects of regression testing. It comes with cross-browser and cross-platform compatibility. There is nothing to complain about the amount of integrations as well.

Even though you may start testing without too much knowledge with Katalon Studio, the more sophisticated features might be hard for a beginner. It is easy to use, but difficult to master. 

While Katalon Studio promotes script reusability, sharing and reusing test scripts across different projects can sometimes be challenging. 

## Top regression testing tools - summary

We hope we were able to provide you some content which will help you in your research and selection. Not only will you find our proposal on  regression testing tools, but we managed to prepare a checklist on what to look for in those tools.


Happy (automated) testing!

small_Test plan template (11).png

thumbnail_Test plan template (11).png

Test plan template (11).png

5 Best Regression Testing Tools 

[TABLE_OF_CONTENTS]

## Importance and benefits of test automation in software testing


Test automation is crucial both for testing and for the development process in general. It will allow you to execute test cases faster and with greater efficiency, which can save you a lot of time.


Properly automated tests can result in better test coverage and be conducted in a more accurate way. It means that test automation is not only useful for testers, but also for the entire development teams and companies. This is because such an efficient and automated testing process can save money and, eventually, result in the higher quality of software.


**The key benefits of test automation are:**

**- Enhanced productivity:** Test automation lets you execute tests in a faster and more effective manner. You don't have to manually repeat the same testing tasks. At the same time, the increased productivity of testers allows the development team to release software on time or even more quickly than planned.

**- Better coverage:** Thanks to automation, you can handle more test cases or deal with more difficult scenarios. It's often impossible to manage big volumes of tests manually.

**- Improved precision:** Manual testing, as any manual activity, is prone to human error. Once automated, tests are executed in a precise and accurate manner. This makes the testing process reliable and repeatable, so you can be sure that your software and all its areas are tested always in the same way.

->[Automate your tests for free](https://app.bugbug.io/sign-up/){.markdown-cta}<-

## 10 test automation best practices

Below, we're presenting 10 essential best practices that you can start using to enhance and speed up your test automation efforts. The discussed techniques have been successfully applied by testers and QA specialists in different organizations across the globe.


Some of them, like having a good test strategy, might seem obvious and easy until you realize how multifaceted such a strategy can be. On the other hand, other practices, for example, reviewing your test coverage, may appear tedious or even redundant, but we can promise you that in the long run, they'll be worth your time.


### 1. Make sure you need to automate testing

Test automation is a time and cost saver. We proved it already across multiple articles like [Automation Testing Guide for Startups - Level 1](https://bugbug.io/blog/guides/automation-testing-guide-for-startups-level-1/) and [Automation Testing Guide for Startups - Level 2](https://bugbug.io/blog/guides/automation-testing-guide-for-startups-level-2/). But it is also a buzzword. It is easy to guess that there are bosses out there who will tell you to automate because “everyone does that so will we”. 

We can’t stress enough the importance of proper resource analysis. You might have a project or a task within the project where setting up automation will just not make sense. For example a so-called corner-case.  You may skip for a moment to #5 within this article to check the part on prioritizing test cases. If you don’t see your cases as high priority, then maybe consider manual testing. 

Make sure you have a basic idea if you have enough time, money and the actual need for a test automation project. If you don’t, you may basically stop reading this article right now. Just kidding! You still have nine more best practices to follow. 

### 2. Prepare appropriate test environment and make sure your app is testable
Later in the article you will learn that you can start to test your application before it is complete. But it needs to be in a testable state. Imagine this - your boss spends lots of money to hire a skilled automation engineer. He or she launches the app first thing in the morning and sees "SYNTAX ERROR". We would love to see the look on your bosses face for this one :) 

Jokes aside, we know how unlikely it is, but you get the point. Make sure all the libraries, dependencies, frameworks, compilers or whatever your technology requires are in place and fully functional.

Proper environment is crucial to test the application. Whether or not you will have a separate server as a test environment, make sure that it is as similar to production as possible. A proper database, a proper network and a set of dummy data needs to be in place. If you are not preparing the data by hand, try creating a factory that covers edge cases. 


### 3. Prepare a plan for your testing efforts
If you came to a conclusion that the testing effort is worth automating, it is time to prepare a plan. There might be reasons why you would not create a full scale document (even though we really suggest it), but at least create something in writing. 


The crucial components of such a document would be the subject matter and the human resources. With a large variety of methodologies and techniques to choose from it is crucial to understand what we are actually testing. A whole software? One functionality? Or maybe how will our product comply with increased traffic?


After that you have to look around you. Recall the skillset of your team and your organizations’ stage of growth. Do you have a QA? Maybe a team of them? Or on the other hand nobody from the team has any testing experience whatsoever?
You need all the answers because…


### 4. Pick a proper test automation tool
We can easily write a book on that one. We could give you dozens of team size/ project size/ money / time combinations that would end up with different tool suggestions. But there is a theory - if you can not explain something clearly to a 5 year old, you are explaining it wrong. So let’s stick to a rule of thumb - smaller your team and project is, less code your testing tool should require. 


Remember that we can divide testing tools into three basic categories - full code, low code and no code. Those full code hardcore tools require vast technical skillset and at least some experience in using them. The latter two have their entry barrier significantly lower. Most of them, like BugBug, will allow you to set up a first test within a few minutes.


A tool (or tools depending on the scope of your automation testing) will probably stick around at least for the duration of the project. Make sure you do the proper research and experiment with a few before making a decision. Two good practices - engage your testing team to help you with the selection and choose a tool that will be resistant to any ui changes your app may face. 

->[Automate your tests for free](https://app.bugbug.io/sign-up/){.markdown-cta}<-

### 5. Prioritize Test Cases for Automation

Prioritizing test cases is one of the key automated testing best practices. It helps to streamline the software development and testing process. Setting priorities allows you to address new changes to the code. To successfully deal with your priorities, try to focus on the following aspects within your test automation strategy:

**- Impact:** Which test cases would have the biggest impact on your software and users in case they were unsuccessful? Can you afford not to create test cases for crucial functionalities? We believe you can't.

**- Risk:** You should prioritize high-risk test cases, namely, the ones that are likely to be unsuccessful (for example, test cases that deal with newly introduced features).

**- Doability:** It may not be possible to automate all of your test cases (for example, some test cases might need your interaction to be successfully conducted).

**- Recurrence:** You may need to execute some of your test cases on a regular basis. Automating them can save you a lot of time and effort. Especially if you are automating regression tests.


### 6. Create test scenarios for your test automation plan


If at this point you are asking yourself “what on Earth is a test scenario” please click here: [Test Case vs Test Scenario: Compare, Contrast and How to](https://bugbug.io/blog/software-testing/test-case-vs-test-scenario/). It shows the differences between test case, test script and test scenario. 


If you remember or just read it, we wrote that “test scenarios can not be automated”. Then why would we put it as a best practice? Well the idea behind creating test scenarios is to emphasise the end-users’ behaviour within our app. 

It is the base of end-to-end testing and a good place to start in order to set up specific test cases. It also increases the test coverage since we need to change our perspective as testing engineers. Test scenarios make us leave NerdVille and start looking at our software as the clients will. 


The other asset that test scenarios bring to the table is a sort of structure for your test automation process. It helps to divide and manage the workload. Going from the scenario to the specific cases makes you focus on positive and negative outcomes and provide proper testing data.


### 7. Shift left - have your automation engineers start testing early


Let's hope that SEO bots will not read the headline as a call to change your political views :) In the context of this article shift left refers to testing as early as possible. In this philosophy successful test automation can begin even during the design period. It is one of the best practices for automated testing. 


For a long long time the QAs used to test the software after the whole code was completed. Luckily that is not the case any more. The success of test automation starts earlier. Various testing may be done on an iterative basis which not only catches bugs but is able to prevent many of them.  You can write test cases almost immediately after creating the "hello world" within your app. 


If you are reading about shift left philosophy and three letters come to your mind - specifically TDD, you are right. Test Driven Development is the most known approach of shift left. Test Driven Development basically means that first you create a test and then you write code in a way that the test will pass. 


### 8. Incorporate Continuous Integration and Delivery (CI/CD) Practices


CI/CD is a highly useful practice for the software development process. It helps to build and deploy software in a quick, structured, and efficient manner. Using it for your testing needs can be beneficial, too.


Having an efficient CI/CD pipeline for testing will help you close bug issues earlier as well as conduct tests parallely. They will also let you set up and manage automated tests in an easier and more effortless way.


Moreover, properly structured CI/CD pipelines allow people with limited technical knowledge to execute automated test cases. The bottom line is, a CI/CD pipeline is a great method to make your testing process faster, easier, and more reliable.


### 9. Review and optimize your testing works


Practice makes perfect. It’s also true for testing. By reviewing and optimizing test coverage, you can smooth out the testing process and contribute to the quality of the final product.


Such reviews of test results and optimization efforts may help you to find cracks and gaps in your test coverage so that you can make sure that all the vital areas of your software are tested. The reviewing process can also ensure continuous enhancement of the overall testing process.


It may seem like a tedious task, but reviewing the coverage after some time can help you find gaps and flaws in your process that you couldn't see before. Revisions are important for many activities, be it writing documentation or crafting a test strategy.

->[Automate your tests for free](https://app.bugbug.io/sign-up/){.markdown-cta}<-

### 10. Stay updated with the latest testing tools and trends in test automation

A proactive attitude is always beneficial, also when we talk about test automation. New trends and tools allow you to apply the latest and most efficient methods for finding bugs.


Modern approaches and tools for test automation will also save you time and reduce the costs required to conduct the testing process. It goes without saying, that the quality of your software will also be positively impacted if you keep on staying ahead of the game.


In our professional lives, continuous learning is essential for our overall success and the success of the product we're working with. Also, challenging yourself with checking out new possibilities, solutions, and tools can be incredibly refreshing if you've been in your role for a long time.


## Conclusion


The presented best practices can help you make the test automation processes more failproof and allow you to scale them better. Applying the best practices will lead to a more comprehensive test coverage and improved test automation efficiency. 


In the end, you, your team, and your product will benefit from your decision to add good practices and techniques to the development process as, eventually, they can improve both the quality of your work and the quality of your product.


Happy (automated) testing!

small_Test plan template (10).png

thumbnail_Test plan template (10).png

Test plan template (10).png

Test Automation Best Practices. What and How to Automate

[TABLE_OF_CONTENTS]

## How to write test cases to make testing easy to automate?


Software developers are lazy, and it is a good thing!!  This sentence is commonly used to shock or wake up the audience of many conferences and events. And it is actually true - both parts. If it wasn’t for this laziness, or stating it more professionally - eagerness for optimization, the progress within the IT world would have been much slower.


The will and ability of automating repeatable tasks is one of the cores of programming. If you are to create a hundred of the same objects or entities in your app, would you do it by hand? Or would you rather create a script that will do it for you? It is the same with creating tests and test cases. And this is where test automation comes in. 


**Test automation is a practice of using specific tools and scripts to automate the executing the testing process for a given application.** This rather self explanatory definition gives us one piece of information that will be significant in this article. 

“Specific tools and scripts” are the words. Creating proper scripts and cases is crucial to make test automation happen. 
Before we do that, let’s focus for a moment on why we would actually automate our tests. 


- It saves you time and money - you can execute and re-execute the test script at any time, basically with a click of a button and it reduces the man hours needed for the testing effort.


- Makes your team members happy - since they are not redoing the same tasks over and over again.


- It provides security - automated tests are less prone to error than the manual tests.


- Increases the test coverage - if you are able to automate the biggest number of test scenarios, you can test manually the less common ones. 


->[Automate your tests for free](https://app.bugbug.io/sign-up/){.markdown-cta}<-

## Things to do before you write automated test cases

As you already know from our other articles, test cases are not just there floating around in the testing universe. They come out from a test scenario or a test suite.  It means that while deciding what you actually want to test, you need to create a high level plan first. 

Test scenario is a description of a user behaviour pattern. Usually such actions touch multiple functionalities at a time. From a test management perspective it means that one test scenario will make you test several parts of your software.


After you identify the test scenarios you need to actually decide on how many tests should be automated. Why “how many” and not “whether all”? Well even though automating all tests sounds efficient and smart, it is quite the opposite. Writing an automation test case for something that will occur only once per testing process is a waste of time. Here are a few pointers on how to decide **if automation is the best way:**
- If a functionality covered by the given test is crucial from the business perspective


- If a functionality covered by the given test is used with high frequency


- If a test needs multiple data sets 


- If a test that have the tendency to be influenced by human error


- If a test is undoable manually or takes a lot of effort to cover it manually


- If a test is highly repeatable and runs on multiple builds



Another aspect that you need to consider is the **test automation tool** itself. It is significant to understand its pros and cons as well as the limitations. It is rather safe to assume that you will be using the same tool during the whole testing process. Therefore you are preparing the cases for that specific software. 


## How to create a test case for automation testing?


It is a slightly different job to create an automated test case if you compare it to the manual one. The key being the actual tester. A manual test case is created by a human for a human. Every manual test case needs some elements that we would use to report or maintain order in test execution. For example the title or the description. On the other hand if you want to create automated tests, the best practices suggest to follow those guidelines while writing automated tests:


- **Preconditions:** you need to describe what are the entry requirements or the entry state of the application that would allow you to run the test. For example if and which browser you use, do you need to log in or enter a specific subpage.


- **Test steps:** the instruction on what actions are required to reach the desired state of the app as well as the necessary test data.


- **Sync and wait statements:** this one has a little asterisk on it. In the “good ol’ days” you needed to define when and how much time is necessary for the application to do its job before running each stage of the test. If your tests were faster than your app was, the results got highly inaccurate. Right now, modern automation tools like BugBug rather than sync and wait, they react to what is actually happening in the app. You define what elements should be visible, and if they occur, the test proceeds. 


- **Comments:** they enable understanding and knowledge transfer by describing the approach of the current software test.


- **Debugging statements:** They are used to aid in identifying and troubleshooting issues or errors that occur during the execution of automated tests. They might be log entries or warnings in your test automation tool. Try to be as thorough here as you can since it will help the devs to debug the issue.


- **Output statements:** They are used to report the outcome of each test case. Here you can place the mythical “test failed successfully” message for a negative test. 


Do note the important difference between the last two bullets. The debugging statements are invoked **during** the test runs - if a bug occurs. The output ones are logged **after** every completed test. 


![Test steps - part of an automated test case, created in BugBug testing tool.](https://bugbug-homepage.s3.eu-central-1.amazonaws.com/88bc1d9e_16f8_4e1a_b33d_15e2a8d17cdf_1ba13763a8.webp)

*Above: Test steps - part of an automated test case, created in BugBug testing tool.*

->[Automate your tests for free](https://app.bugbug.io/sign-up/){.markdown-cta}<-

## Best practices in creating test cases to automate the process
We have a few best practices for you. The Fab Five of test automation.


1. **KISS them!** The "keep it simple, stupid" rule is in place here as well. Create your test cases in a way that everyone involved will understand them. You need to be sure that what you write and how you write is clear for the test team. If you have the time and resources to do so, it would be wise to create a manual or a guide that will keep everyone on the same page. What would you put there? A glossary or a list of abbreviations you will use in your cases. 
2.**Start with the scenario.** We mentioned this one many times in our articles. A good [test scenario](https://bugbug.io/blog/software-testing/test-case-vs-test-scenario/) will help you to create good test cases. You will be able to select the right functionalities, the right order etc. A good test automation ROI starts with the scenario. If you do not put much effort into it, you will have a tough time making the right test cases.
3. **General and precise - tightrope and feather.** This one comes with experience. Achieving perfect balance between being general and detailed is like walking a tightrope with a feather. As a creator of the test case you need to feel and understand how much information allows you to test a functionality and how much will be well... too much. There is no point in limiting your testers' flexibility. Also limiting the information is the best way to increase the adaptability to the software change. For example if you write "hover mouse to upper right corner over the login button" and in the future the login button will be moved to the left, the test case will need to be changed. Whereas "hover mouse over the login button" is much more universal. 

4. **Encourage exploration.** We start with a shocker - nobody is perfect! Teams usually create test cases in a quick manner and have the tendency to work by following patterns and experiences. This way the test coverage of an app never reaches 100%. And it never will. The thing is - assume that you have some test cases missing and start exploring. Test cases serve to verify the bugs you have thought might occur. What about those that slipped your mind while developing? Make sure your scenario and your automation plan has the flexibility to add / change test cases. Create a culture of test case development if you will. 

5. **Independence!** This is our good practice, that we teach to all BugBug clients. It is significant that you design your test cases in a way that they are independent from each other. If your test A needs a test B to run properly, the risk of false results increases. That way you can also unnecessarily enlarge the testing time, since linking tests together prevents them from working parallelly. 


**Example cases for test automation**
The following phrase is best read using your best “shopping channel impersonation”. Give it a shot!

*We have an exclusive offer for our most dedicated readers! We will give you example test cases for not one, not two, but three, yes you read it right THREE! types of testing.*

Fun wasn’t it? 🙂

Coming back to being test automation pros. We actually did prepare three test cases for you.

- Functional testing. As you remember, functional testing checks if a specific functionality works correctly. 


Preconditions: The user is not logged in. The app is on its home page


Test steps: Click the login button. Wait for the form to appear. Enter “test_user” as the username and “test_pa$$word” as the password. Click  the “Login” button. 


Comments: This is the base test for user authentication. 


Debugging statements: If the user was not logged correctly, log “user authentication failed” and if there were any prompts at the login form, copy them to the log.


Output statements: For passed test log “User authentication successful”.  


![n example of a passed test with a proper output statement.](https://bugbug-homepage.s3.eu-central-1.amazonaws.com/88bc1d9e_16f8_4e1a_b33d_15e2a8d17cdf_cdfc84abfc.webp)

*An example of a passed test with a proper output statement.* 


->[Automate your tests for free](https://app.bugbug.io/sign-up/){.markdown-cta}<-

- Integration testing. Keeping it short - integration testing aims to verify if different parts of the software or any connection to an external service is able to communicate and cooperate properly.

Preconditions: The user is not logged in. The app is on its home page.


Test steps: Click the login button. After the form appears, click the “Login via social media” button. Check the URL for /profile and check the content for “Hello test_user”.


Comments: Verify if the user is on the proper URL post social login authentication. 


Debugging statements: Log proper information if any of the two conditions occur. “Wrong URL” if the user is not on “/profile” and “Wrong greeting” if the “Welcome test_user” is not visible. 


Output statements: For passed test log “Transfer to profile successful”.  

![An example of a failed test with proper debugging statements. ](https://bugbug-homepage.s3.eu-central-1.amazonaws.com/image_2_2780b9c057.png)

*An example of a failed test with proper debugging statements.*


- [Regression testing](https://bugbug.io/blog/software-testing/everything-you-need-to-know-about-regression-testing/). Remember? The one you perform to check if new functionalities are not interfering with the old ones.


Preconditions: The user is not logged in. The app is on its home page


Test steps: Click the login button. Wait for the form to appear. Enter “test_user” as the username and “test_pa$$word” as the password. Click the “Login” button. If the welcome animation is launched and then the user is on the “/profile” URL


Comments: Verify if the user sees the animation and then is directed to the profile. The profile should not have the greeting anymore.  


Debugging statements: Log proper information if any of the failure conditions occur: “no animation visible” for no animation, “wrong URL” if the user is not logged to “/profile” URL, “greeting visible” if the “welcome test_user” greeting is visible.


Output statements: For passed test log “Transfer to profile successful”. 

->[Automate your tests for free](https://app.bugbug.io/sign-up/){.markdown-cta}<-

## Summary - creating cases for automated testing process


Automated test cases require a specific tool that is functional for any programming language. They allow you to quickly run tests over and over again for example after every build or sprint your team completes. They reduce testing time. Time that you can spend writing code and completing your product in a more efficient way. 


Manual and automated test cases have some common elements, but there are 6 key elements that should be included if you are using the automation. Those are: preconditions, test steps, sync and wait, comments, debugging statements and output statements. Make sure you check our best practices and examples above (mostly speaking to those readers who tend to start the article from the summary).

Running automated tests instead of the manual ones is the more efficient way most of the time. There are some tests that need the manual approach, but this would be a topic for a completely different article.

small_Test plan template (9).png

thumbnail_Test plan template (9).png

Test plan template (9).png

How to Write Automation Test Cases? 

[TABLE_OF_CONTENTS]


Recently we have created a few articles on test planning and test management. The core of this content was the test plan - a document that defines and outlines the testing effort of a web application. 

You may check our articles here:

[Test Case vs Test Scenario ](https://bugbug.io/blog/software-testing/test-case-vs-test-scenario/)


[Test Plan Template](https://bugbug.io/blog/software-testing/test-plan-template/)

You can download and use the test plan templates we have included there. 

One of the crucial points in high-level testing management is to understand the difference between test plan and test strategy. The test strategy term is often used in different contexts. This might be quite confusing for a test team that is slightly less experienced. Let’s grab a flashlight then and shed some light on the topic.

## The differences between Test plan and Test strategy

If we want to understand the topic we need to create some sort of brief definitions of the test plan and test strategy. 

**Test strategy** is an extensive and high level document that presents the overall approach to the testing process. It usually guides on all repeatable decisions that need to be made when on software testing. 

**Test plan** is an operational document describing the testing process of a specific application. It is an instruction for the testing effort of this particular software.

On the first sight, the test strategy is a high-level document, whereas test plan is operational. The goals of each documents are different. Test plan document describes what to test in one specific app and will include the list of specific testing activities. Test strategy document shows the test manager and each test engineer how to perform testing and what is the general test approach. You will find the detailed comparison below. 

For your comfort we have compared both documents in a table below.

| Test Plan                                                                                    | Test Strategy                                                                                                                  |
|----------------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------|
| A project based instruction on how to test the software in hand                              | A document that describes a company wide approach to test design                                                               |
| Test plan is a dynamic document in which may change in each testing cycle                    | An effective test strategy rarely changes                                                                                      |
| Will include the test environment, list of features to be tested and specific test scenarios | Will include test objectives, test conditions, decision on test automation and bug reporting pathway                           |
| Highly detailed information specific do the project                                          | General information based on company situation, experience and general approach                                                |
| Test plan document guides the testers through the bug finding process                        | Test strategy describes how testing is being performed not only to the manager or test lead but to non technical personnel too |
| Is fitted with test cases and test schedule relevant to the software development process     | Is created once and significant for each type of testing or the subject matter                                                 |

For now let's skip to a different question. Which is...

## Test strategy and Test plan - why the confusion?

One of the reasons both terms might get switched and confused is the fact that the test strategy might actually occur in two different contexts. In both of them test strategy defines how the tests will be performed. 

First, we have already described above - test strategy is a set of rules relevant to all testing efforts held by the company. 

Second, as you might remember from our articles, it may become a part of the test plan. Every reasonable person should now ask “why would that be?”. The answer is relatively easy and lies one level above the test planning - within the company, that wants to test a product in the first place.

Let’s compare two business entities. One - a startup that does its first software development process. Two - a well established company that develops and supports multiple applications. 

Company one is doing many things for the first time and testing process is definitely one of those firsts. That means that (in 99% cases) they do not have a high-level testing strategy in place yet. Nevertheless they prepare an approach or a strategy if you will, that is relevant to their single product.

Company two on the other hand is not the new kid on the block anymore. They are well established in their market and have performed many iterations and life cycles. Creating separate strategies per each product is not feasible for them anymore, since they were basically rewriting the same stuff over and over again. They have reached a point where creating a company-wide test strategy would cost less man hours than redoing single strategies per software testing process. 

**The former approach to test strategy should be considered as temporary whereas the latter, as the optimal.**

->[Automate your tests for free](https://app.bugbug.io/sign-up/){.markdown-cta}<-


## Test plan vs Test strategy - what should come first?

Let us give you the bad answer first - well.. it depends. In fact we are not too far away from the proper answer anyway. It really does depend if your strategy is a high level document or a part of the test plan. 

Considering the natural way of business development it would be natural to create a few test plans for different products and then draw the similarities into a separate document. That way we can come into the conclusion that a test plan will come first. But that is not the case actually.

Even if you are a startup and are in the process of creating the first master test plan, you should start it by creating the strategy chapter. Try to place all information, that might be reused in future projects. Those components of test strategy chapter might be as follows:

- test deliverables
- industry standards you want to follow
- high level test objectives
- releasing process
- bug reporting

If we are talking about a more mature business the order should be the same. Strategize first, plan second. The test plan and all its individual aspects should be created with the company test strategy in mind.

If for example the strategy foresees a bug reporting track, you do not put bug reporting into the plan at all. What you do put into the plan are all project related deviations from the strategy and individual decisions such as a specific test technique. Remember to put the root cause of the change there as well. 

## BugBug hints on how to plan and strategize testing

We understand that we are deep into the theory of test management. But we can not stress this enough in our content. Test your software! Even without automation it will save you money. When you add test automation to the equation, it will immediately save you time, money and image. 

Coming back to the topic in hand. In our opinion a good test strategy is developed by repetition of test planning. If your startup will move to later development stages, each product will require a separate test plan. This will obviously result in a company-wide experience increase but also will give you some material to compare, contrast and have some self feedback. If your products "forced" you to create different types of test plans, it's even better. 

When you have the resources that you can invest into creating a separate strategy, just browse to those components of test plans, which occurred in all of them.

All of the test strategy elements, that you will find in our and different articles, are just a suggestion. Make sure it is relevant for your company and your overall business strategy. 

One hint we might give you here - even though you have had the same environment set up for all previous testing efforts, try not to put it into the strategy. There are two reasons for that. First - always make sure that the test plan includes environment and data relevant to this specific project. Second - by putting specific testing software into the strategy you discourage yourself and the team from being open to new solutions. 

->[Automate your tests for free](https://app.bugbug.io/sign-up/){.markdown-cta}<-

## Test strategy vs Test plan - summary

Hopefully we were able to set test plan and test strategy apart for you. Remember test plan is a document created per project whereas a test strategy is created per company. There is an exception for startups, which can place a "microstrategy" so to speak as a chapter of the plan. 

Happy (automated) testing!

small_Test plan template (6).png

thumbnail_Test plan template (6).png

Test plan template (6).png

Test Plan vs Test Strategy: Goals & Differences

Reliable, modern end-to-end test automation tool that improves testers’ and developers’ work.


Before you release your product into the market, it is extremely important to properly test whether it’s functioning as intended. To do that, software developers utilize a variety of testing techniques that verify the software’s integrity. To thoroughly check their software from start to finish, developers implement **End-to-End testing**, often simply called **E2E** testing – an elaborate technique that mimics end user experience. 

There are many layers to End to End testing, as it is one of the most complex testing methods. This type of testing involves testing every part of your software that the end-user interacts with in any imaginable way.

With this guide, we want to show you the importance of E2E tests, as well as tell you precisely what they are, including a few specific examples.

**Also see:** if you're new to software automation, take a look at this [beginner's guide to automation with step-by-step screenshots](https://docs.bugbug.io/in-depth-guides/beginners-tutorial-to-automation-testing).

[TABLE_OF_CONTENTS]

## What exactly is End-to-End testing?

**End-to-End testing** is one of the most useful and informative techniques for software testing, providing valuable data about the inner workings of the program from the end-user perspective. With E2E testing, developers can thoroughly verify the behaviour of their software. During the test, you will be trying to replicate key user behaviour scenarios when using your software. The actual list of things to do varies, depending on the type of software you’re testing – but in all cases, it is rather extensive.

When performing a software testing method, like an End-to-End test on a web application, you would start with opening your browser and navigating to the proper URL, and then proceeding to use the software as intended for the end-user.

Similarly, in the case of a regular desktop application or mobile application, you would open the app just like a user would, checking out every bit of functionality that is intended for the users to work with. Keep in mind that during E2E testing you won’t need to check developer-specific aspects of the software, only the end-user perspective if it is important to you.

## End-to-End test goals

During an E2E test, your goal is to verify all of the dependencies and data integrity that directly or indirectly influence the reception of the software by the end-user. This usually includes any external services, as well as databases used by the software and metrics, as well as any other system dependencies. 

E2E tests will ideally be performed in the production environment, but this isn’t always possible. The tests can, of course, be performed in an independent End-to-End testing environment, but you should make sure it is as close to the production environment as possible.

Within the SDLC process, E2E tests are performed in the Testing phase, which is situated after Coding and before Deployment. 
->[Automate your tests for free](https://app.bugbug.io/sign-up/){.markdown-cta}<-


## Why is End-to-End testing important?

Is End-to-End testing necessary? It is true that more and more developers make sure to implement an E2E testing phase before the final deployment of their software. There are many benefits to E2E tests, but the most crucial ones are:

- The ability to verify software performance from the end-user perspective
- Testing verifies not only the software itself but also any interrelated sub systems, increasing test coverage
- Validation of back-end systems
- Immediate end-user-like feedback on test failing

While tests such as unit testing or integration testing are very useful (functional testing), allowing you to verify the working of each component and providing quick results, they don’t give you the whole picture. By not performing E2E tests, you won’t know how the experience of using your software will look like from the end-user perspective.

For example, individual component testing (integration tests) might show promising results and full functionality. However, when combined, something goes wrong and produces a bug. By only checking individual components, you wouldn’t be able to find out about the bug. 

With a proper End-to-End test, you can verify whether everything works correctly together as it should. Even integration testing doesn’t cover all of the system components of your software, and you might never know whether every aspect of your app clicks together.

E2E testing doesn’t necessarily have to discover bugs – it can also give you useful insight into the user scenario of your product. Overall, all types of tests play their respective roles in the whole vertical end-to-end testing process (differently to horizontal end-to-end tests). Just because E2E tests give you a more complex understanding of your software as a whole doesn’t mean that other test types are less valuable. 

Before releasing your app, always make sure to proceed with a thought-through testing strategy. However, while they’re certainly extremely useful, keep in mind that E2E tests occupy the top of the testing pyramid, making them the most expensive and most difficult to perform.

End-to-End testing is also one of the few functional types of tests that can be performed manually, as well as automated - which is done especially often in Continuous Integration. In such a scenario, a chosen set of tests can be run automatically each time a new iteration is uploaded to the testing server.

->[Automate your tests for free](https://app.bugbug.io/sign-up/){.markdown-cta}<-

## Benefits of end-to-end testing

One of the goals of this software testing technique is to simulate the end-user's perspective. This means that this type of testing helps to verify not only the security or performance, but the business aspect as well. It will check whether the software collects and processes data as it was designed to do. End-to-end testing is essential for a comprehensive validation of your product. This testing ensures that all integrated parts of the application work together as expected.

Another purpose of E2E testing is to mitigate risks. E2E testing verifies if the software is ready for deployment. The confidence in stability is a crucial factor which the stakeholders consider while approving the next release. 

There are obviously much more obvious benefits of this form of testing (like bug fixing or testing across different user scenarios), but we described them already in this article.

## End-to-End Testing Framework

Alright, so now you know what End-to-End testing is – but how to exactly implement it? There is a wide variety of checks and individual tests that must be covered by your end-to-end testing plan, some of which include:

- Establishing test requirements in the preparation phase (including software and hardware requirements)
- Creating proper documentation
- Deciding what type of test environment will be used (production environment or independent test environment)
- Preparation of test cases and general E2E design
- Tracking of data input and output
- Test execution and evaluation

When executing E2E testing methods, developers usually follow an established E2E testing framework that guides you throughout the process, enumerating various tasks and responsibilities. The framework is relatively simple and consists of only three elements:

### Establish user functions

The User Functions relates to listing the features of your software, as well as all of its interconnected software systems. To properly measure and test software functionality, you need to first think about what you’re going to test. After you’re finished with listing user functions, remember to record everything relevant to each of them, including both the input and output data. Since E2E testing can be considered holistic, you also need to pay attention to all of the relations between every individual function – how they work together and whether there are any clashes.

### Come up with specific conditions

Now that you have established the user functions you’re going to test, you need to think about the testing conditions. Try to come up with as many quantifiable indicators that can be measured for each of the functions. These can range from response time to consistency of data flow, to simple convenience of use. Remember – you’re trying to imagine yourself as an end-user, so try to keep track of anything that might be an issue for a non-developer.

### Create individual test cases

Finally, before the E2E testing can commence, you need to prepare specific test cases for each of the conditions. At this point, you have prepared a list of user functions to test, as well as data conditions that will be measured during the test. Now, you need to create at least one test case for each of the conditions. By test cases, we mean user scenarios during which specific indicators will be able to be measured.

And by test case preparation status, we mean the precise location of the test instances being developed, as compared to intended test cases.

->[Automate your tests for free](https://app.bugbug.io/sign-up/){.markdown-cta}<-

## End-to-end test cases for your testing process

Congratulations, you’ve almost reached the end! At this point, you should pretty much be a walking fountain of knowledge about End-to-End tests. However, the raw theory is one thing, and implementing those types of tests for system testing in reality is another. To make the process a bit more digestible, consider this End-to-End testing example for a website with shopping functionality:

- Go to the specified URL
- Open a list of products
- Check whether the information on the list correlates with specific product pages
- Try to add the product to the cart and look for visible confirmation
- Navigate to the cart and check whether the product has been successfully added
- Double-check all of the relevant information (price, product info, etc.)
- Proceed with the check-out and verify payment options integration

See how simple it is in the end? Now you can implement E2E testing methodology in your software to ensure better end-user reception, increase your product quality, and build a positive brand image.

This is just a high level example. If you would like to learn how to create a proper test case from start to end, please check out our article on [test case creation](https://bugbug.io/blog/software-testing/how-to-write-automation-test-cases/). You will have a better understanding on how to design test cases for manual and automatic testing. Also check out our other topics in our testing guide. 

## End to End testing tools

Proper tools may play a crucial role in reducing your effort by automating your end-to-end tests. These tools provide a range of features and capabilities to support horizontal testing and vertical testing of the entire system. They allow testers to perform comprehensive testing processes. Choosing a proper tool for testing is typically a long-term investment. If you research and choose a tool that will enable you to execute and record complex user scenarios and allow testing across multiple technologies, your job will be way easier. 

One of the tools that meet such requirements is BugBug. This automated testing tool proved its efficiency for many clients. On the picture below you might see how many steps might an end-to-end scenario actually have.

![n example of a passed test with a proper output statement.](https://bugbug-homepage.s3.eu-central-1.amazonaws.com/88bc1d9e_16f8_4e1a_b33d_15e2a8d17cdf_cdfc84abfc.webp)

## Summary

End-to-end testing is a type of testing that focuses on validating the whole system from start to finish rather then testing individual functionalities. It is often seen as a software testing methodology, but it is not the case. It may be a part of a methodology (i.e. Agile testing) but it is by definition a type of software testing. 

Performing end-to-end testing covers an important task of checking data flows and focuses on testing if any functional gaps occur. This type of testing is necessary to verify if the software is ready for the next release cycle.

## Frequently Asked Questions

1. **What is automated testing?** \
Automated testing in software development is a form of software testing that uses the execution of predefined sets of operations to probe and validate the software system. The fundamental purpose of automation testing in software development is to generate objective feedback about the quality of the product. One such testing tool is Selenium. It can run UI tests. The ideal situation is to run E2E tests with both manual testing and automated testing approaches. If your application has a lot of complicated user interfaces, you'll need more end-to-end testing.

2. **What is software development lifecycle?** \
Software development lifecycle (SDLC) is the process used by developers to create, deploy and maintain software. This process includes several steps that are all closely connected with one another. These steps include requirements gathering, analysis and design, coding and testing.

3. **What is a testing pyramid?** \
In software development projects, we have limited time and resources. This is why it's important to consider our test efforts carefully and find the right balance between different types of testing. Basically, there are 3 layers in the testing pyramid: Unit Tests, Integration Tests, and E2E Tests.

3. **What is a selector?** \
A selector is a small piece of code that describes a specific button in your app. It allows you to clearly define what should be clicked in automated end-to-end tests. You can learn more about selectors using [this interactive XPath learning tool](https://bugbug.io/xpath-selector-builder/?ref=blogarticle)



Happy (automated) testing!


large_testowanie_end_to_end_98e59a7257_deae9fab1e.png

medium_testowanie_end_to_end_98e59a7257_deae9fab1e.png

small_testowanie_end_to_end_98e59a7257_deae9fab1e.png

thumbnail_testowanie_end_to_end_98e59a7257_deae9fab1e.png

testowanie_end_to_end_98e59a7257_deae9fab1e.png

What is End-to-End (E2E) Testing?

Professional Quality Evangelist, experienced in testing web and mobile applications.  
[linkedin.com/in/kinga-witko-b5bba659/](https://linkedin.com/in/kinga-witko-b5bba659/)

Kinga Witko

[TABLE_OF_CONTENTS]

The term “shift left” expresses movement. It can describe the movement of an entire team or individuals.
What does it do in a project or an entire development lifecycle? Putting it simply,  it reflects the position of testing on a timeline. 

**Shift Left means testing earlier in the development process.** It also means repositioning the engagement, development, and testing efforts towards the customer.


Typically, in a traditional (waterfall) model of software making, testing lands at the end of the pipeline or is one of the last phases of the process. Bringing testing at the very last stage usually causes many problems such as:

- delays in the deployment
- a lot of bugs at the end of the development lifecycle
- bugs discovered just before or after the release to production
- lack of collaboration between developers and testers through the entire process.

Poor software quality is one of the most harmful consequences of all of these pains listed above.

At first, the team members do not communicate with each other and they fail to communicate the problems early. 

It must not necessarily be a bug; sometimes there is some issue with the application setup, there is no testing environment, access to certain resources (such as specific tooling or external software providers), the task description is vague, or the team setup is incorrect. 

If communicated and fixed earlier, the entire process can be smoother and cause less frustration in the team. It also encourages people to focus more on the code quality and to deliver earlier and faster.

Most of those issues can be avoided by changing the style of working and shifting testing efforts at the beginning of the process.
->[Automate your tests for free](https://app.bugbug.io/sign-up/){.markdown-cta}<-


## Agile way of working

If you care about the quality of your product, your mindset has probably shifted left already.

This approach is strongly connected with the agile way of thinking and using agile work methods in software projects.


In this setup, testing is an integrated part of the team and accelerates software development at higher quality. As a result, testers can identify bugs sooner, saving time and effort. Notably, the earlier you test, the less expensive bugs are to fix.


[T The Seven Testing Principles (ISTQB)](https://www.istqb.org/downloads/syllabi/foundation-level-syllabus.html) tell that testing everything is not possible unless a system or functionality is very simple. In practice, however,  the testing efforts should be targeted appropriately at the risk analysis, techniques, and bugs prioritization rather than be attempted thorough testing. 


One of the good methods of approaching testing strategy for a specific application can be the guideline from [Agile Testing Quadrants](https://bugbug.io/blog/software-testing/agile-testing-quadrants/). The quadrants are a taxonomy to help teams plan the testing process and testing activities and make sure they have all the resources they need to accomplish it.


## Shift Left approach and DevOps and agile background

With the rise of the DevOps movement, there is an increased focus on delivering automated, continuous improvement. It holds true for development and testing alike.

What is more, Continuous Integration (CI) and Continuous Delivery (CD) are core software development disciplines integrated into the agile software development cycle. The point is to release fully-tested and stable builds early and as often as possible. Development, delivery, and test automation are crucial components of this process. 

## What it means to “Shift Left”

As mentioned at the beginning, Shift Left testing pushes testing to the “left”, to the earlier stages in the pipeline. This improves software quality and reduces time spent on resolving issues later in the pipeline.

Introducing testing early on the “left-side” of the development process, starting with unit tests and complementing with functional and integration tests is fundamental to making CI/CD happen. But that may not be enough.

The team can go even further: to eliminate unclear and contradicting requirements and improve the end-user experience, it is best to involve test engineers in the clarifying and prioritising application requirements. Test engineers can check the available or newly created requirements or user stories for clarity, consistency, testability, and traceability.

This also improves the shift towards client happiness. An early review of the requirements and spotting the flaws marks an early start of the communication with the end-user. 

The Shift Left approach introduces more care and thought exchange concerning the client. The team can be perceived as more proactive and more dedicated to the best quality standards of a project.
->[Automate your tests for free](https://app.bugbug.io/sign-up/){.markdown-cta}<-


## Benefits of Shift Left Testing for Agile and Devops teams

Agile teams benefit most from Shift Left Testing in terms of clearer specifications, smoother implementations, earlier testing, and reduced costs. However, Shift Right Testing has more benefits like the ability to incorporate user and system feedback based on real usage scenarios. 

In opposition to testing early, Shift Right can provide an additional context to the testing scenarios. Shifting right means testing at the end of the process, typically when the software is deployed to production (the post-production environment). 

It is performed by a group of experts or selected end-users. It can utilize testing methods such as API Monitoring, using Feature Toggles, or measuring the performance of a live application. 

This helps to understand the application better and discover some other flaws that could have been omitted earlier.

Nevertheless, when quality comes first:

- developers spend more time on coding because they discuss potentially good solutions - they do not investigate who pushes the code first into production without testing

- there are Unit Tests beside the application code, available and maintainable

- there is an infrastructure that allows testing before pushing to production, usually the entire team is responsible for the process health

- there is room for improvement and mistakes

- developers pair up to catch obvious errors on the fly and learn from one another

- teams estimate tasks together, taking quality and risks into account

- potential risks in the systems are spotted and minimized rather than left alone

And finally - the application is tested - not only by one automated or manual test  but by a set of different functional and non-functional scenarios. 

The tests are regularly reviewed, adjusted, and observed. This approach introduces a new way of working and highlights the value of testing.


## Benefits of the Shift-Left Testing approach

The idea of shift left testing is simple to understand but hard to implement in the development cycle. It is worth the effort though, especially when the team and the entire organization understands the main benefits of this approach, such as:

- Lower costs - as explained above, bugs detected earlier are less expensive to fix.

- Increased efficiency in the software development process.

- Improved product quality and reliability because more bugs are detected at earlier stages.

- Reduced time to market since the QA process covers the entire development cycle, not only its’ last phase.

- A competitive advantage gained by letting development teams move fast, build and defend their credibility by innovating in iterations.
->[Automate your tests for free](https://app.bugbug.io/sign-up/){.markdown-cta}<-


## Get started with “Shift Left” Testing in Agile

How to approach the change and switch to early software testing? Here is the basic list: 


1. **Plan**

Shape development in a way that is friendly to Shift Left testing. Once the requirements have been established, developers and testers should ideate how to shape the coding and software testing as early as possible. 


Depending on the product expectations as well as the limitations of the team, specific strategies, such as involving testers in the project since the planning phase or using the TDD approach, might have to be crafted to accommodate the Shift Left way of working.


2.** Review the requirements**

It is best to verify not only the existing code but also all the requirements necessary for the code to be written. Early verification can spot obvious mistakes.


3. **Use Static Code Analysis**

Static code analysis is the practice of checking the code without executing it. It runs through the basic code structure and ensures that the code is aligned with many standards and guidelines. By following the approach the team can early detect:

- Programming errors

- Violations of commonly followed coding standards

- Syntax anomalies

- Security issues

A static code analysis is best done via automation. The software should scan all untested codes in a project before it moves to the test phase.

4. **Collaborate**

As in any other [agile testing](https://bugbug.io/blog/software-testing/agile-testing-organized-chaos-or-a-planned-way-of-improving-your-software/) technique - early software testing requires a lot of collaboration with the team: Developers, Product Managers, Business Analysts, and other stakeholders responsible for the overall product. 

Everybody needs to understand the value of the Shift Left approach and spot the difference after some time of the new process introduction because as a result, the client benefits from better software quality and receives a lovable product.

## Conclusion for Left Shift Testing in test automation

There are a number of benefits to left shift testing in test automation. One of the primary benefits is that it helps to identify defects earlier in the development cycle. This means that defects can be caught and addressed before they become more complex and costly to fix. In addition, left shift testing can help to reduce the overall time and effort required for testing by identifying and addressing issues earlier in the process.

Another benefit of left shift testing in test automation is that it can help to improve the quality of the software being developed. By identifying and addressing defects earlier in the process, developers can ensure that the software they are creating is of higher quality and meets the requirements of the end-users.
->[Automate your tests for free](https://app.bugbug.io/sign-up/){.markdown-cta}<-


One of the keys to successful left shift testing in test automation is to incorporate testing into the development process **from the very beginning**. This means that testing is not an afterthought or an additional step at the end of the development process, but rather an integral part of the development process itself. Test automation tools and frameworks can be used to automate testing activities and make it easier to incorporate testing into the development process.

It is also important to involve testers in the development process as early as possible. This allows them to provide feedback and identify potential issues before they become more complex and difficult to fix. Testers can also work with developers to ensure that the code being developed is testable, and that the testing process is efficient and effective.

Overall, **left shift testing is an important approach in test automation that can help to improve the quality of software, reduce testing time and effort, and identify defects earlier in the development process**. By incorporating testing into the development process from the very beginning, developers and testers can work together to create software that is of higher quality and meets the needs of the end-users.

Happy (automated) testing!

large_pexels-pixabay-40716.jpg

medium_pexels-pixabay-40716.jpg

small_pexels-pixabay-40716.jpg

thumbnail_pexels-pixabay-40716.jpg

pexels-pixabay-40716.jpg

Shift Left Testing Explained

Guides to Test Automation

small_Testing Tools for Web Application.png

thumbnail_Testing Tools for Web Application.png

Testing Tools for Web Application.png

Testing Tools for Web Application - The Ultimate Guide 2023

Testing is an ever-present part of a software developer’s job, performed at every stage of the production process. There is a wide range of test types used for software testing, some performed at various points during production, and some performed after production to confirm that the software functions as intended.

Regression testing is performed on a product that has already been finished and released. How exactly is it performed? What are the objectives and how does the procedure look? If you’re keen to find out, keep on reading as we explain everything you should know about regression testing.

[TABLE_OF_CONTENTS]

## The definition of Regression Testing

**Regression testing** is a software testing method that aims to investigate and locate any possible flaws or bugs in software that has already been fully developed. Regression Testing is performed to find out whether your software has regressed (surprise, surprise) as you continue introducing new updates and bug fixes. Whenever a piece of software is changed in any way, new bugs might emerge and some of the older ones re-emerge.

Most often, regression testing is performed immediately after introducing a new update, but it isn’t the only factor that might call for the test. If any software or hardware-related factor has changed, regression testing should be committed to find out whether everything performs as it has before the change. 

This can include any sort of bug fixes and software changes, but regression might also be caused by hardware configuration changes and electronic component degradation over time. Regression testing isn’t easy – it requires cooperation and diligence out of all of the team members, which makes it perfect for agile software development practices.

->[Automate your tests for free](https://app.bugbug.io/sign-up/){.markdown-cta}<-

## Regression Testing process

As with most testing efforts regression testing is an art rather than science. Let us describe the regression testing process that our development team uses. You may then use and adapt it to your existing test strategy. As regression testing is a type of testing that occurs whenever any change in your software occurs, the smartest way to start is to..

### Identify code changes

This will allow you to asses the number of test cases for regression testing that will need to be created. The testing team will need information on the impact that the current changes may have on the whole application. This is done also during this step.

### Prioritize changes

You finished step one with a list. Now you need to create a queue out of it. By proper prioritizing the changes in your software application you reduce the amount of time you will use on 

### Select for re-run

This is the part where the selection of test cases is performed. After the first test is done, test cases are categorized into reusable and obsolete ones. The reusable ones create a regression test suite. The others are will not be used for regression. 

### Categorize manual and automated regression test cases

Here is where the test automation actually begins. Test cases that occur more often within one process are perfect candidates to for the automation tool to do the work for you. If you want to automate tests in a fast and efficient way, try BugBug as your tool for regression testing. You will soon find out that it is great to reduce regression testing costs.

### Prioritize test cases

Here is where regression testing becomes a tad tricky. One would think, that the most often occurring test cases should have the biggest priority, right? Well the theory on that one is a tad different. The need for regression testing, therefor the priority, is the highest for those cases, that cover all essential features. The lowest on the other hand are stated as "technical complexities". 

### Plan and execute

This one is rather obvious, but we have to put it here. After doing all the analysis, you have to plan when regression testing is done and "push the execute button". 

## Regression Testing techniques

Regression testing can include various functional and non-functional tests in its process to thoroughly investigate the software in search of flaws. There are also many techniques with which developers and QA specialists perform regression testing, including:

- Retest All
- Regression Test Selection
- Test Case Prioritization
- Hybrid approach

### Retest All – an accurate yet expensive solution

**The Retest All ** technique is the most accurate and all-around method of regression testing, but it is also the most expensive one. In Retest All, every test case is checked again on the software to confirm if all of its parts are working as intended. That’s all there is to Retest All – it might be simple in definition, but it is definitely the hardest and most costly technique to actually perform.

### Regression Test Selection – when you realize you might not have enough for a Retest All

**Regression Test Selection** has been designed as a solution to the expensive nature of the Retest All technique. In RTS we don’t run all of the tests in our test suite, but instead we divide all of the tests into three categories – reusable test cases, retestable test cases, and obsolete test cases. In addition, RTS might actually create new test cases that haven’t been in the suite before, but might be relevant for regression tests.

If you’re interested in finding out more about regression testing examples, we recommend taking a look at Understanding Regression Testing Techniques by Gaurav Duggal and Bharti Suri. The authors further divide RTS techniques, naming two most important categories – coverage techniques and minimization techniques, and explain what are safe techniques.

**Coverage techniques** feature specific coverage criteria, often provided by the client who wants their software regression tested. These techniques sift through all test cases, selecting only the ones that are relevant for the covered parts of your software. **Minimization techniques** work in a way similar to coverage techniques, but instead of selecting cases based on set criteria, you select a minimum set of cases that you think will do the job.

->[Automate your tests for free](https://app.bugbug.io/sign-up/){.markdown-cta}<-

### Test Case Prioritization – a rational approach

**Test Case Prioritization** aims to maximize the rate of fault detection, creating the most thorough regression test for the lowest cost. First you prioritize the test cases one by one. Then all of them are performed in order, starting from the most important one and finishing on the least important one. Thanks to that, even if your resources aren’t enough to perform all of the tests in your suite, you will still perform the ones that should detect the most flaws.

**TSP** might be performed in two ways – the first one, called **General Prioritization**, selects test cases that should be effective (on average) on all versions of the software you’re working with. The other way, called Version Specific **Prioritization**, only takes into account a specific version of the software, without considering other existing or potential future versions.

### Hybrid approach – the best of both worlds

When choosing one technique of regression testing is impossible – why not combine the best features of Regression Test Selection and Test Case Prioritization? 

The hybrid approach is still being developed, and every researcher gives a personal spin on the idea. Since there isn’t an exact definition of what a hybrid approach actually is, there are tons of versions available – each one with its own upsides and downsides.

## Regression Testing tools

Regression testing ensures that each version of your software runs smoothly. We have described various regression testing techniques, but our article would not be complete without a few hints of what tool to use for proper test execution. 

Regression testing is used on an incremented basis. Each release of your software means building another layer of an already high pile of multiple regression test cases. A good tool will allow you to perform regression tests without writing a single line of code. 

If you want a specific list of tools, please redirect to our article [HERE](https://bugbug.io/blog/guides/testing-tools-for-web-application/).

->[Automate your tests for free](https://app.bugbug.io/sign-up/){.markdown-cta}<-

## Disadvantages of regression testing

Well now that's a shocker isn't it? We have many articles on testing in the BugBug blog, and never have I ever wrote anything negative about testing. Until now. We found four "buts" on regression testing and we tried to tackle them immediately.

- "but regression testing is time consuming" - yes, but only if you only perform a manual test, this is why selecting a good testing tool is essential
- "but you have to do it after even the smallest patch" - yes, but this is why you build a good regression cycle. You store all the recurring tests and only build a few on top of them for that given patch. It is like CI/CD for your testing process
- "but that process might interfere with the sprint planning" - only if you do regression tests without automation. Think of it from a business perspective - would you have a task that goes cross-sprint or a large bug in the production environment?
- "but it is difficult, to write those test cases" - ah, an oldie but a goodie. There are great no-code regression testing tools. Those might be used not only by QA or other technical personnel but by a PM. Such a person would be even able to automate the test or record and recreate it. 

Regression testing is one of the key ways to have your code thoroughly checked and ready to start earning you money!

## Conclusion – is Regression Testing necessary?

As you have already learned, regression testing plays a key role in keeping the quality of your software as high as possible for as long as possible. Updates and changes to your software might introduce new problems, which is exactly why regression testing is so important – to keep user experience high throughout all iterations of your program.

Not all projects require regression testing, of course. In projects that are already finished and won’t be further updated, regression testing is mostly irrelevant. However, if you are planning to continue development further – never forget to properly regression test your software before releasing an update.


Happy (automated) testing!

large_regression_tests_blog_07c72a81f5.jpg

medium_regression_tests_blog_07c72a81f5.jpg

small_regression_tests_blog_07c72a81f5.jpg

thumbnail_regression_tests_blog_07c72a81f5.jpg

regression_tests_blog_07c72a81f5.jpg

What is Regression Testing? Everything You Need To Know

Product Updates

New Feature: Pop-Up Window Recording

Testing Tools Comparisons

Top Cypress Alternatives in 2023

Uncategorized

No-code Testing Automation: Guide to Codeless Testing and Automation Tools

Get more tips and product related content. Zero spam.

Don't miss any updates

Automate web app testing easier than ever. Without excessive costs. Faster than coding. Free forever.

End-to-end testing made simple! BugBug is a new, more intuitive tool for test automation of web apps. Get all the benefits of test automation without hiring new people or infrastructure changes.

BugBug.io | Intuitive and reliable test automation for startups

large_opengraph_image.png

medium_opengraph_image.png

small_opengraph_image.png

thumbnail_opengraph_image.png

opengraph_image.png

Features

Why Choose Us

Integrations

Book a demo

Customer Success Stories

Case studies

Create tests in your browser for free. Run the tests in the cloud for 14 days at no charge. No credit card required. 

Effortless cloud testing that fits your budget

Discover the differences of each plan and choose the offer that fits your testing needs

Industry leaders automate tests with BugBug

Frequently Asked Questions

Contact our Support Team.
They’ll give you all the information you need.

Free trial of premium features for 14 days

Automate web app testing easier than ever. Without excessive costs. Faster than coding. 

Pricing

Blog about test automation

About us

Contact

Everything you need for the entire test automation workflow

Record new tests simply by clicking in your browser. Automatically capture every click or text input. Add assertions directly while recording. Forget about writing selectors by hand; BugBug will do it for you.

Create tests without coding

Enjoy excellent performance when you run tests locally, allowing you to work more efficiently. Run tests in the cloud to regularly monitor your web application and catch bugs earlier.

Run tests in your own browser or in the cloud

Now you don't need to record your test from scratch every time you want to change it! Record new steps right in the middle of your test, just where you need it. Spend less time on manual writing of CSS or XPath Selectors.

Fix tests by re-recording

Run cloud tests every day and monitor if your app works properly. Get comprehensive notifications when a test fails. You will receive notifications with scheduled test results directly to your inbox.

Schedule test automation

Use BugBug API and Command Line Interface to run regression tests along with your CI/CD build pipelines, such as Github, Gitlab, Travis, Jenkins, or Bitbucket. Integrate with Zapier to get notifications on Slack when a test fails.

Integrate with your CI/CD pipelines

Invite your teammates to work together on test automation without time-consuming training and debates. You can involve software developers or product owners in testing within minutes.

Collaborate with your team

Unparalleled simplicity powered by unique features

Powerful features for advanced testing

You can turn test steps into "Components" that are shared across multiple tests. Maintain hundreds of tests without worrying that you will have to spend half a day fixing them. 

Edit multiple tests at once

Work in multiple environments. Create random numbers. Register users with unique email addresses. 

Use variables to handle complex tasks

You have full control over the test steps. You can update selectors, manually add advanced step types or assertions, and even custom JavaScript code.

Customise test steps with JavaScript

Need to show the results to your stakeholders? You can download a PDF report for each suite run in your project.

Generate PDF reports

Record automated tests easily for both desktop and mobile resolutions.

Build tests for mobile resolutions

See what our clients are saying

Start testing for free! No credit card required.

Test automation is too complicated. BugBug is here to make end-to-end testing ultra simple and effective. Limit your testing workload and focus on delivering great features. Without straining your budget.

Because we want you to catch bugs easier than before

Join hundreds of happy software testers that automated testing process with BugBug

We solve many problems of the test automation world

**TRULY NO-CODE SOLUTION**  
Not a tester? No problem. Our no-code BugBug test recorder will make you feel like a pro QA engineer.

**CLEAN INTERFACE**  
We are fed up with complicated testing tools. That's why we created BugBug. Our software is simple and very intuitive. No matter if you are a QA testing beginner or an experienced engineer.

Built to empower non-technical testers

**UNLIMITED FREE USERS**  
Collaborate with others when creating your test suites. Finally you can invite as many teammates as you want for free.

**UNLIMITED LOCAL TESTS**  
With BugBug you can run unlimited tests in your browser with the Free Forever Plan. Also you may run tests in the cloud without additional infrastructure or DevOps costs. Fun right?

Test automation tool that suits every pocket

**BUILT-IN AND CUSTOM VARIABLES**  
Anytime you need, you can run tests with our built-in variables that we prepared for you. If you need something more specific, you can also create your own custom variables.

**POWERFUL FEATURES**  
Run custom JavaScript, use automatic selectors, create profiles as presets for different variable values, and work with different development environments - BugBug offers advanced features for you to use when you need it.



Advanced features to boost your testing

Integrate with anything via BugBug API. Run cloud tests in your CI/CD pipelines such as Github, Travis, Jenkins, Bitbucket, or GitLab. The setup is easy thanks to BugBug's streamlined Command Line Interface and built-in Zapier support.

Are you fresh in the test automation world? We’ve got your back - read our comprehensive tutorial for beginners and see how easy it is to automate your first test.

Easy to learn testing

Read about best practices from the test automation world. Get practical tips, valuable insights, and improve your QA process.

Role of The Tester in The IT Project

Automation Tester: The Most Important Skills in 2023

Best Software Testing Podcasts to Follow in 2023

The Best Software Testing Newsletters in 2023

Ice Cream Cone Anti-Pattern: A Deep Dive

Test Automation Experts to Follow on LinkedIn

Smoke Testing vs Regression Testing: Guide for QA

How to Create a Test Plan? Steps and Examples for Software Testing

Test Plan Template For Test Automation Process

Test Case vs Test Scenario: Compare, Contrast and How to 

Untitled design (24).png

Best Chrome Extensions for Software Testers

Scrum Testing: QA on an Agile Team 

Why is Software Testing Important?

I write about technology and help people who use it. I've always been fascinated by the details of things - how they work and what makes them tick. That's why I love writing about tech!  
[linkedin.com/in/aleksandra-spilkowska](https://linkedin.com/in/aleksandra-spilkowska)

large_a_spilkowska_cropped_c38f3487ad.jpg

medium_a_spilkowska_cropped_c38f3487ad.jpg

small_a_spilkowska_cropped_c38f3487ad.jpg

thumbnail_a_spilkowska_cropped_c38f3487ad.jpg

a_spilkowska_cropped_c38f3487ad.jpg

Aleksandra Spilkowska

Specflow: 8 Steps to Use Behavior-Driven Development To Improve Team Performance

[linkedin.com/in/darekkacban](https://linkedin.com/in/darekkacban)

thumbnail_dariusz_kacban.jpeg

dariusz_kacban.jpeg

Dariusz Kacban

Doan Nguyen - Operto - Quality Assurance Specialist

Doan Nguyen, Quality Assurance Specialist

thumbnail_Authors (1).png

Authors (1).png

Doan Nguyen

A self-taught software QA Engineer, Dominika has experience in web testing. Currently, she is focusing on developing her test automation skills with Cypress. Apart from programming, she likes to make pottery and cook vegetarian delicacies.  
[linkedin.com/in/dominikanykiel](https://linkedin.com/in/dominikanykiel)

medium_1637439945009_e_1646265600_and_v_beta_and_t_Iw_Bm_GA_Wm_Nd_Xvpr_R_Nzs_LB_Pbwu_PFXBTK_Ff_TLP_612y_Eu_A_4d4900e8b2.jpg

small_1637439945009_e_1646265600_and_v_beta_and_t_Iw_Bm_GA_Wm_Nd_Xvpr_R_Nzs_LB_Pbwu_PFXBTK_Ff_TLP_612y_Eu_A_4d4900e8b2.jpg

thumbnail_1637439945009_e_1646265600_and_v_beta_and_t_Iw_Bm_GA_Wm_Nd_Xvpr_R_Nzs_LB_Pbwu_PFXBTK_Ff_TLP_612y_Eu_A_4d4900e8b2.jpg

1637439945009_e_1646265600_and_v_beta_and_t_Iw_Bm_GA_Wm_Nd_Xvpr_R_Nzs_LB_Pbwu_PFXBTK_Ff_TLP_612y_Eu_A_4d4900e8b2.jpg

Dominika Nykiel

Unit Testing vs End-to-End Testing: Key Differences

How to Become Automated Test Engineer? 

Atomic Test Cases - the Ultimate Guide

Parallel Testing: A Guide for Software Testers

Benefits of CI/CD Pipeline Implementation

Quality Engineering vs Quality Assurance: Goals & Differences

SaaS Testing Guide: All You Need to Know

Best Selenium Practice Websites in 2023

Chaos Testing: Everything You Need To Know

Top Rainforest QA Alternatives in 2023

Top Ghost Inspector Alternatives in 2023

What is User Journey Testing? Guide for Software Testers

The Ultimate XPath Cheat Sheet

CI/CD Interview Questions and Answers

Cypress Best Practices: Test Automation Guide

Top Autify Alternatives in 2023

Top Reflect.run Alternatives in 2023

What is Performance Testing in Software Testing?

Smoke Testing vs Sanity Testing: All You Need To Know

Best Practices of Test Maintenance in Software Testing

Best Websites with Bugs for Testing

Top 15 Codeless Automation Testing Tools for QA

"What Does QA Testing Do?" in Software Development

The Landscape of Front End Testing Tools in 2023

The Ultimate Guide to Codeless Automation Testing

Best QA Conferences: Curated List for 2023 and 2024

Application Consultant working as a Tech Writer


[https://www.linkedin.com/in/dominikdurejko/](https://www.linkedin.com/in/dominikdurejko/)