large_main_screenshot.png

medium_main_screenshot.png

small_main_screenshot.png

thumbnail_main_screenshot.png

main_screenshot.png

Automate your web app testing without slowing you down, without hiring new staff, without complexity. 

Intuitive and reliable test automation for startups

BugBug Video 18 May v3 1080p_1_1.mp4

b24-logo-1.png

bugbug_logo_1.png

bugbug_logo_5.png

bugbug_logo_4.png

bugbug_logo_3.png

Stay confident that your web app works as it should

Create stable tests through an intuitive recording interface. No coding is required unless you want to do it. Automate regression tests in minutes.

whitePanel.svg

Automate tests faster than coding

Run tests in the cloud without additional infrastructure or DevOps costs. No expertise is required to set up scheduled tests.

whiteMoney.svg

Reduce testing costs

Automate repetitive and tedious regression tests. BugBug is made for testing web applications, so it performs faster and smoother than competing cross-platform solutions.

whiteBolt.svg

Enjoy testing

Set a schedule and regularly check that your application is working as expected. Receive notifications when a problem occurs.

whitePulse.svg

Monitor key features

Keep the testing process simple, without slowing you down. Maintain regression tests via BugBug's intuitive, easy-to-learn interface.

whiteHeart.svg

Avoid complexity

Invite your entire development team to participate in test automation. For free. No additional charges per seat.

whiteUser.svg

Work in a team

End-to-end testing made simple!

small_bugbug-screenshot-tests-create-record-2.png

thumbnail_bugbug-screenshot-tests-create-record-2.png

bugbug-screenshot-tests-create-record-2.png

Create automated tests by recording how you click in your browser. BugBug is able to reliably "play" all your actions thanks to a unique record & playback technology that just works.

Create tests in minutes

small_bugbug-screenshot-schedule-notifications (1).png

thumbnail_bugbug-screenshot-schedule-notifications (1).png

bugbug-screenshot-schedule-notifications (1).png

Monitor your website every hour. Stay confident that everything works as it should. Receive detailed notifications when a test fails.

Run tests on schedule

small_image-600-integrations-6.png

thumbnail_image-600-integrations-6.png

image-600-integrations-6.png

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.

Integrate with your favourite tools

Trusted by startups & software agencies all around the world

<div class="cms-section">
      <div class="cms-wrapper">
        <div class="cms-testimonials-row">
          <div class="cms-testimonials-item">
            <div class="cms-testimonials-item__icon"><img src="https://assets.website-files.com/62826448121477c0eb54a773/633456764c0c618517865056_bugbug-quote-icon.png" loading="lazy" alt="" class="cms-testimonials-item__icon-img"></div>
            <div class="cms-testimonials-item__texts">
              <div class="cms-testimonials-item__main-text">“Recording tests in BugBug works surprisingly well. I've tested various competing solutions, but none did as smoothly as BugBug.”</div>
              <div class="cms-testimonials-item__author">— Krzysztof Studniarek, Product Manager, BRAND24</div>
            </div>
          </div>
          <div class="cms-testimonials-item">
            <div class="cms-testimonials-item__icon"><img src="https://assets.website-files.com/62826448121477c0eb54a773/633456764c0c618517865056_bugbug-quote-icon.png" loading="lazy" alt="" class="cms-testimonials-item__icon-img"></div>
            <div class="cms-testimonials-item__texts">
              <div class="cms-testimonials-item__main-text">“In two days we managed to automate test cases that took us weeks to write up and execute using other software. It is easy to use, yet can still perform advanced testing should the tester want to.”</div>
              <div class="cms-testimonials-item__author">— Panayiotis, Software Tester, ATM Marketing</div>
            </div>
          </div>
          <div class="cms-testimonials-item">
            <div class="cms-testimonials-item__icon"><img src="https://assets.website-files.com/62826448121477c0eb54a773/633456764c0c618517865056_bugbug-quote-icon.png" loading="lazy" alt="" class="cms-testimonials-item__icon-img"></div>
            <div class="cms-testimonials-item__texts">
              <div class="cms-testimonials-item__main-text">“A very interesting software testing tool that allows you to run automated tests without any programming knowledge.”</div>
              <div class="cms-testimonials-item__author">— Michał, QA Engineer</div>
            </div>
          </div>
        </div>
        <div class="cms-testimonials-row">
          <div class="cms-testimonials-item">
            <div class="cms-testimonials-item__icon"><img src="https://assets.website-files.com/62826448121477c0eb54a773/633456764c0c618517865056_bugbug-quote-icon.png" loading="lazy" alt="" class="cms-testimonials-item__icon-img"></div>
            <div class="cms-testimonials-item__texts">
              <div class="cms-testimonials-item__main-text">"BugBug is super intuitive and lowers the barrier of becoming an end-to-end tester. It reduces development time and significantly lowers the cost of software testing. "</div>
              <div class="cms-testimonials-item__author">— Wojciech, CEO Davinci-Studio.com</div>
            </div>
          </div>
          <div class="cms-testimonials-item">
            <div class="cms-testimonials-item__icon"><img src="https://assets.website-files.com/62826448121477c0eb54a773/633456764c0c618517865056_bugbug-quote-icon.png" loading="lazy" alt="" class="cms-testimonials-item__icon-img"></div>
            <div class="cms-testimonials-item__texts">
              <div class="cms-testimonials-item__main-text">"We always wanted to automate, but didn't have resources. BugBug empowered us to do so. Very simple, quick to use, and looks really cool!"</div>
              <div class="cms-testimonials-item__author">— Kris, CEO, Innential</div>
            </div>
          </div>
          <div class="cms-testimonials-item">
            <div class="cms-testimonials-item__icon"><img src="https://assets.website-files.com/62826448121477c0eb54a773/633456764c0c618517865056_bugbug-quote-icon.png" loading="lazy" alt="" class="cms-testimonials-item__icon-img"></div>
            <div class="cms-testimonials-item__texts">
              <div class="cms-testimonials-item__main-text">"It works great! BugBug saves me hours of monotonous work writing and maintaining tests."</div>
              <div class="cms-testimonials-item__author">— Martin, Python developer</div>
            </div>
          </div>
        </div>
      </div>
    </div>

<style>

.cms-testimonials-row {
  display: -webkit-box;
  display: -webkit-flex;
  display: -ms-flexbox;
  display: flex;
  padding-bottom: 32px;
  grid-column-gap: 32px;
  grid-row-gap: 32px;
}

.cms-testimonials-item {
  display: -webkit-box;
  display: -webkit-flex;
  display: -ms-flexbox;
  display: flex;
  -webkit-box-align: start;
  -webkit-align-items: flex-start;
  -ms-flex-align: start;
  align-items: flex-start;
  -webkit-box-flex: 0;
  -webkit-flex: 0 33.33%;
  -ms-flex: 0 33.33%;
  flex: 0 33.33%;
  grid-column-gap: 16px;
}

.cms-testimonials-item__main-text {
  min-height: 100px;
  padding-bottom: 16px;
  color: #666;
  font-size: 18px;
  line-height: 1.6em;
  font-style: italic;
  letter-spacing: 0em;
}

.cms-testimonials-item__icon {
  width: 64px;
  height: 64px;
  -webkit-box-flex: 0;
  -webkit-flex: 0 0 auto;
  -ms-flex: 0 0 auto;
  flex: 0 0 auto;
}

.cms-testimonials-item__author {
  min-height: 100px;
  color: #666;
  font-size: 16px;
  line-height: 1.6em;
  text-align: right;
  letter-spacing: 0em;
}

@media screen and (max-width: 991px) {
  .cms-testimonials-row {
    -webkit-flex-wrap: wrap;
    -ms-flex-wrap: wrap;
    flex-wrap: wrap;
  }

  .cms-testimonials-item {
    -webkit-flex-basis: 100%;
    -ms-flex-preferred-size: 100%;
    flex-basis: 100%;
  }
}


@media screen and (max-width: 479px) {
  .cms-testimonials-item__main-text {
    min-height: 0px;
    font-size: 18px;
  }

  .cms-testimonials-item__author {
    min-height: 0px;
    font-size: 13px;
  }
}
</style>


Features

Pricing

Roadmap

Case studies

Privacy policy

Terms of service

About us

Book a demo

Contact

Get more tips and product related content. Zero spam.

Don't miss any updates

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_Open Graph 1200x630 3.png

medium_Open Graph 1200x630 3.png

small_Open Graph 1200x630 3.png

thumbnail_Open Graph 1200x630 3.png

Open Graph 1200x630 3.png

Blog about test automation

Software Testing

small_pawel-about-512.png

thumbnail_pawel-about-512.png

pawel-about-512.png

Paweł Bylina

We’ve prepared a short guide with essential recommendations on test automation that we created specifically for startups. We divided the guide into 3 levels:

[★☆☆ Level 1: get the most out of basic automation](https://bugbug.io/blog/software-testing/automation-testing-guide-for-startups-level-1/)

[★★☆ Level 2: automate hundreds of regression tests](https://bugbug.io/blog/software-testing/automation-testing-guide-for-startups-level-2/)

[★★★ Level 3: integrate with CI/CD builds](https://bugbug.io/blog/software-testing/automation-testing-guide-for-startups-level-3/)
  
Here comes the first part!
 
### What will you achieve on Level 1?
After finishing this level you will run 5-10 automated tests every hour and check if your core features are working properly. You will detect production bugs with big impact on users sooner than before.

### TLDR:
-   Start with short and simple tests that check your core features
-   Remember about recording “hover”
-   Create special test user accounts dedicated to automation
-   Schedule the tests to run every hour
-   Incrementally add more tests

### Focus on the most important features

![80-20 rule (1).png](https://bugbug-homepage.s3.eu-central-1.amazonaws.com/80_20_rule_1_c2126d9815.png)

Many companies spend endless hours on a neverending pursuit to automate everything. This leads to very costly automation that requires a whole team to create and maintain. Don’t be like these companies and keep it simple. Agile startups should start with automated testing of the most essential functionality. 

> 👍 **Rule of thumb:**
> Usually, it just takes 5 to 10 automated tests to be sure that most users are able to achieve their goals.

What should you test? Think of your features. What percentage of users are using a particular feature? If the answer is higher than 80%, then this is a core feature. The goal of automating tests of such important features is to make sure that you can detect bugs that have a huge impact on your business as soon as possible (new user registration is for sure a core feature, but it’s a little bit more tricky to automate, which we will cover in the next episode)






### Start with short & atomic tests

When you [record your first tests](https://docs.bugbug.io/creating-tests/recording-the-tests) start with something very simple and atomic. Atomic means that the test is small, independent and checks just one thing.

A good idea is to start with testing the basic navigation of your landing page. Click “record” and create a test that just clicks one item of your navigation link in the menu. Add [assertion](https://docs.bugbug.io/recording-tests-steps/recording-assertions) for some text in a heading. Finish the test and run it. Awesome! You’ve created your first automated test that touches the most essential area of your business!

![Screenshot 2022-07-25 at 13.44.12 (1).png](https://bugbug-homepage.s3.eu-central-1.amazonaws.com/Screenshot_2022_07_25_at_13_44_12_1_0ebde0ddbb.png)

Now create a separate test for each navigation link. Here are screenshots of how BugBug team set up their landing page tests.

![Screenshot 2022-07-25 at 13.44.15 (1).png](https://bugbug-homepage.s3.eu-central-1.amazonaws.com/Screenshot_2022_07_25_at_13_44_15_1_74fb39e9de.png)


### Don’t forget about recording hovers

If your website navigation appears on hover, you need to tell BugBug that you want to record a mouse moving to a specific element. To do this you need to click “Hover” during the recording and then click an element. When running the test, BugBug will move the mouse cursor to this element.

![bugbug record hovers.png](https://bugbug-homepage.s3.eu-central-1.amazonaws.com/bugbug_record_hovers_81639fbd30.png)


### Create special test users

Another idea is to test if login works. Create a separate test that only checks that one thing.

To achieve that you need to prepare a “test user” - a user account that is dedicated only to testing if login works properly

-   Manually register a new user with a new unique email, for example with john.smith+testautomation@email.com (you can use [disposable mail](https://www.google.com/search?q=disposable+mail) or [plus aliasing)](https://support.google.com/a/users/answer/9308648?hl=en)
-   Go to BugBug and record a test that clicks the login button, enters the user login and password and submits the form
-   Add an assertion for some text that confirms that the login was successful
-   Finish your test
    

  

You might be tempted to test other features in the same test, but don’t do this now. We want to be sure that the login test is atomic and independent from other features.

  

Remember that you can create as many test users as needed. For example, if your product offers multiple combinations of preferences, you can create a separate user for each combination.

  

> 👍 **Rule of thumb:**
> Always create new test users if this leads to less test steps

  

### Schedule all tests to run every hour

With BugBug you just need a couple of clicks to start running the tests every hour. Just go to “Schedules”, select the “Hourly” one and add “All tests”.

![hourly schedule (1).png](https://bugbug-homepage.s3.eu-central-1.amazonaws.com/hourly_schedule_1_445d7fe266.png)


  

That’s it, now you will start getting emails every hour with the results of your test automation. Tip: create a filter on your email account so that you avoid inbox clutter or [configure notifications to only get an email on failures.](https://docs.bugbug.io/running-tests/schedules#configure-email-notifications)

![email notifications (1) (1).png](https://bugbug-homepage.s3.eu-central-1.amazonaws.com/email_notifications_1_1_a23f96ba47.png)


  

### Incrementally add more tests

You’ve successfully created test automation that monitors your production! Now keep adding more short tests one by one. Don’t forget to focus on being cost-effective - if you have trouble automating a use case, skip it and go to the next one or find a different way of checking if it works. And remember: you can always [ask BugBug support to help you with any troubles](https://bugbug.io/contact).

Read next: [next level guide on how to easily maintain hundreds of automated tests ](https://bugbug.io/blog/software-testing/automation-testing-guide-for-startups-level-2/)
  
  

medium_illustration - guide - level1.png

small_illustration - guide - level1.png

thumbnail_illustration - guide - level1.png

illustration - guide - level1.png

Automation testing guide for startups - Level 1: get the most out of basic automation

automation-testing-guide-for-startups-level-1

In the [first episode](https://bugbug.io/blog/software-testing/automation-testing-guide-for-startups-level-1/) of our 3-part guide, we covered the basics and described how to get the most business value from simple test automation. Now it’s time to learn some more advanced concepts and increase coverage of your automated tests. Here we go!
 
  
### What will you achieve on this level?

Once you finished this level you will:
-   have 100+ nicely structured tests
-   be able to update multiple tests at once when needed
-   run tests on different environments
-   automate testing of new user registration
    

  

### TLDR:

-   Organize your test steps in groups
-   Convert some groups into shared components
-   Duplicate tests efficiently with “new test from here”
-   Set up a URL variable to quickly swap between environments
-   Set up a testing email inbox to automate tests of new user registration
-   Use [built-in variables](https://docs.bugbug.io/editing-tests/variables#use-built-in-variables-for-dynamic-or-random-values) to generate random user email aliases
    
### Scaling the test automation

![illustration-number-of-tests.png](https://bugbug-homepage.s3.eu-central-1.amazonaws.com/illustration_number_of_tests_7ee4d49d68.png)


In this episode, we will focus on scaling your test automation to a larger number of test cases so that your regression tests also cover corner cases and niche features. This is “Level 2” so things will get more complicated, but BugBug makes everything easy to achieve.

Example: in [the episode 1 of this guide](https://bugbug.io/blog/software-testing/automation-testing-guide-for-startups-level-1/) we’ve created just one test that checks if log-in works. Now we want to create several tests that check different outcomes of logging in, for example:

-   Log in - success
-   Log in - incorrect password
-   Log in - account blocked
-   Log in - password reset required
-   Log in - account doesn’t exist
    
You can see that we aim to increase the test coverage dramatically. Instead of 5-10 tests, we’re going to have hundreds of them.

### Keep tests nice and tidy

If you want to have more than 10 tests, you should start organizing the test steps and keep them in order. Why is it important? Imagine that you’ve created 100 tests, but later you changed something in the UI. All of your tests started to fail. If you haven’t organized test steps, you will need to go to each test individually, see what’s wrong and re-record the failed steps 100 times. Fortunately, BugBug allows you to easily avoid such situations.

### Group your test steps

Keep your steps tidy by grouping them. Give a clear name to each group, which will help you to navigate through long test cases. Move your cursor in between the steps to see a plus icon, then click “[split group here](https://docs.bugbug.io/editing-tests/grouping-steps)”.

![split-group-here.png](https://bugbug-homepage.s3.eu-central-1.amazonaws.com/split_group_here_fce12649d5.png)


  

### Convert groups to shared components

Once you start grouping your test steps, soon you will realize that some groups are exactly the same in multiple tests. This makes them a perfect candidate for [components](https://docs.bugbug.io/editing-tests/wip-make-component). Components are magic groups: if you change it in one test, it will change in all other tests that have it.

![component-made (1).png](https://bugbug-homepage.s3.eu-central-1.amazonaws.com/component_made_1_afa56da91d.png)
  

Start with creating a component for the first step that goes to your starting URL. Then go to each test and replace the normal group with the component by using “Insert existing component”.

![insert-existing (1).png](https://bugbug-homepage.s3.eu-central-1.amazonaws.com/insert_existing_1_985f99b0c0.png)


  

### Duplicate the tests rather than create new ones

Since you already have components, you may not want to record each test case from scratch. A lot of your tests will start with the same components (for example: go to homepage, log in, enter a password, etc.). You can quickly create a new test “in the middle” of a different test. When you click “[new test from here](https://docs.bugbug.io/creating-tests/new-test-from-here)” you will create a duplicate of the test that keeps all the preceding test steps.
 
![new-test-from-here.png](https://bugbug-homepage.s3.eu-central-1.amazonaws.com/new_test_from_here_5d79377e02.png)


  

If you use components in a smart way, you will be able to fix hundreds of tests with just one [re-recording](https://docs.bugbug.io/recording-tests-steps/re-recording-steps).

### Use data-testid attributes as selectors

Automated tests are most reliable if your [selectors](https://docs.bugbug.io/preventing-failed-tests/selectors) are clearly identifying an element. The best way is to clearly annotate such elements in your HTML structure. Ask your frontend developer to add `data-testid` HTML attributes to elements that you click in your automated tests. 

Why is it better? Let’s see an example. If you don’t use a dedicated attribute, your login button selector might look like `//SPAN[normalize-space(text())="Log in"]`. This selector points to any element with text "Log in". If you change the text in the button, such a selector will stop working and your test would fail. 

If you used an attribute, for example `[data-testid=”login-submit”]` your tests will be more resilient to changes. Even if you change the text in the button, you will not need to edit your automated test. What’s more, the developers will see this attribute in the code so they will be aware that this specific item is a subject of test automation. Once you have such attributes in your HTML, BugBug will automatically create selectors based on “data-testid” attributes during the recording. 

![data-testid.png](https://bugbug-homepage.s3.eu-central-1.amazonaws.com/data_testid_669fc25baa.png)


### Work with different environments

If you are fully committed to testing automation, chances are you will need to run tests on different environments. Each environment can be accessed with different URLs, for example:

-   Production - acme.com
-   Staging - stage.acme-test.com
-   Local - localhost:3000

You should store these URLs in a variable with 3 [profiles](https://docs.bugbug.io/editing-tests/variables#profiles). After you set up more than one profile, a new dropdown menu will appear in each test, that lets you run tests with different environments. Learn more in our [detailed guide](https://docs.bugbug.io/editing-tests/variables#work-with-different-development-environments).

![profiles (1).png](https://bugbug-homepage.s3.eu-central-1.amazonaws.com/profiles_1_e2d0e47b36.png)


  

### Automate tests for new user registration

To reliably automate user registration you need to use a combination of several advanced features

-   Third-party inbox that supports [plus-addressing](https://www.msoutlook.info/question/886#:~:text=Exchange%20Online%20(Microsoft%20365)%2C,also%20known%20as%20%E2%80%9Csubaddressing.%E2%80%9D) (for example Outlook.com)
    
-   Built-in “testRunId” variable for generating random e-mail address alias
    

  

Learn more in our separate step-by-step [guide on testing sign-up.](https://docs.bugbug.io/editing-tests/variables#test-user-registration-and-login-using-variables)

### Keep it simple

Don’t try to overcomplicate your test steps. Use components and variables only when it will actually save time for you in case of product changes. Remember that re-recording is a really fast way of fixing existing tests - sometimes it’s just faster to re-record steps in 5 tests than debugging a complex net of variables and dependencies. Keep it simple and if you have any problems feel free to [talk to our friendly customer support](https://bugbug.io/contact).  😊

[Read next: advanced guide with tips on CI/CD integration](https://bugbug.io/blog/software-testing/automation-testing-guide-for-startups-level-3/)

medium_illustration - guide level2.png

small_illustration - guide level2.png

thumbnail_illustration - guide level2.png

illustration - guide level2.png

Automation testing guide for startups - Level 2: automate hundreds of regression tests

automation-testing-guide-for-startups-level-2

If you followed our [level 1](https://bugbug.io/blog/software-testing/automation-testing-guide-for-startups-level-1/) and [level 2](https://bugbug.io/blog/software-testing/automation-testing-guide-for-startups-level-2/) of this startup guide, you already know how to create and maintain hundreds of automated tests for your web app. In this episode, we will show you how to introduce automated regression testing into your software development process. Integration with CI/CD is a professional way to achieve high-quality code and prevent bugs before they are released to customers

  

### What will you achieve on this level?

Once you finished this level you will:
-   collaborate with all team members on test automation
-   run automated regression tests with every build
-   see test results directly in your CI/CD tool

<br/>

--------------------

⚠️ **Technical skills required!**

To achieve this level you need to have software engineering knowledge and experience with development tools. If you’re not a technical person, ask your developers for help.

  --------------

### TLDR:

-   Use [BugBug CLI tool](https://docs.bugbug.io/integrations/api) to integrate with your CI/CD tool
-   Run tests every time an environment is deployed
-   Invite all your team members to BugBug, so that anyone can view test results
-   Copy & paste links to test results and share them with colleagues
    

### Run tests with every deployment

Your goal is to make sure that every time someone makes changes to the code, this new code is automatically checked against bugs before releasing to clients. If you use Github, Gitlab, Bitbucket or similar, you can configure these tools to run a “build” every time someone merges new code to a specific git branch. Our goal is to make sure that every time the build is run it will also trigger an automated regression tests suite. If the suite fails, the build also fails. If the build failed, you should not merge the code to master. This approach lowers the risk of introducing bugs to production.

### Check the ID of test suites

Simply go to “Suites”, and select “Run via CLI”. You will see terminal commands that you can copy and paste into your CI/CD scripts.

  

![pasted image 0 (2) (1).png](https://bugbug-homepage.s3.eu-central-1.amazonaws.com/pasted_image_0_2_1_c03d47d839.png)


![pasted image 0 (3) (1).png](https://bugbug-homepage.s3.eu-central-1.amazonaws.com/pasted_image_0_3_1_f5a9ebf1e6.png)


### Integrate test suites with your existing CI/CD pipeline

You probably already have a build script. It’s very easy to initiate BugBug tests from it. You just need to add a couple of lines of code that will trigger the tests and wait for the results. Learn more in the documentation of [BugBug CLI](https://docs.bugbug.io/integrations/api) and ask your DevOps for help if needed.

![api-example-script-safe.png](https://bugbug-homepage.s3.eu-central-1.amazonaws.com/api_example_script_safe_cbb33eeae4.png)



  

Once you successfully integrate your build scripts with BugBug, you are able to see the tests results directly in your build status.

![pipeline-example-safe.png](https://bugbug-homepage.s3.eu-central-1.amazonaws.com/pipeline_example_safe_88bb40c38a.png)



  

### Share links to test results

You noticed that a test failed and you wonder how can you send the report to your colleague? The easiest way is to simply copy the URL and send it via chat. Each item from the “Runs history” has a unique URL address.

![Screenshot 2022-07-26 at 15.37.47 (1).png](https://bugbug-homepage.s3.eu-central-1.amazonaws.com/Screenshot_2022_07_26_at_15_37_47_1_b21615dcd5.png)


  

To access it the recipient needs to be invited to your [organization](https://docs.bugbug.io/collaboration/organization-settings). BugBug allows you to invite an unlimited number of people to your organization free of charge. Testing automation is more powerful if you make it available to the whole team!


### Don’t forget about "Level 2" recommendations

CI/CD integration doesn’t make sense if your tests are not resilient to changes and easy to maintain. See our previous tips in [the level 2 test automation guide, where we covered topics such as custom attributes, reusable components and variables.](https://bugbug.io/blog/software-testing/automation-testing-guide-for-startups-level-2/) 