Maestro & Expo: Crafting the Future of Efficient e2e Testing

This ad is not shown to multipass and full ticket holders
JSNation US
JSNation US 2025
November 17 - 20, 2025
New York, US & Online
See JS stars in the US biggest planetarium
Learn More
In partnership with Focus Reactive
Upcoming event
JSNation US 2025
JSNation US 2025
November 17 - 20, 2025. New York, US & Online
Learn more
Bookmark
Rate this content

If you’ve never heard of Maestro, I will show you why I think it's the best e2e testing tool.

And if you have, I will share some tips for an effective integration into your workflow.

This is an educational talk on Maestro where I’ll cover when, what & how to test. I often see people re-building for each run. So I’ll also dig into some Expo specificities (such as eas update & build:list) that will enable you to optimize time and cost and achieve a state-of-the-art CI/CD with Maestro.

This talk has been presented at React Advanced 2024, check out the latest edition of this React Conference.

FAQ

End-to-end testing examines an app in its entirety, similar to a test drive of a high-performance sports car, to catch bugs that unit or interaction tests might miss.

The tools mentioned are Appium, Detox, and Maestro. Appium is powerful but complex, Detox is simpler but less powerful, and Maestro offers a balance with ease of use and community support.

Maestro is simple to install, has a supportive community, and provides tools like Maestro Studio for building tests and Maestro Cloud for running tests on cloud servers.

Maestro Cloud allows you to run tests on their servers, managing simulators and builds for you, and provides auto-retry and video recordings of failed tests.

Expo is a set of tools that helps iterate quicker by using custom development builds and EAS (Expo Application Services), allowing for efficient building and sharing of apps without rebuilding on each CI/CD pipeline.

EAS allows the creation and sharing of builds without rebuilding the app for each pipeline, making the process faster, cheaper, and simpler.

Maestro does not support iOS devices yet, only simulators, and there is no device farm support. Tests are written in YAML, which is not type-safe or standard, and there's a limit of 100 free tests per month.

Tests in Maestro can be tagged to run based on specific triggers, such as every pull request, weekly, or before deploying an update, allowing for a tailored testing strategy.

After the 100 free tests per month, the cost is 10 cents per test. There is also an option to self-host to reduce costs.

End-to-end tests are complex to set up and can be unreliable. They require building the app, starting simulators, ensuring the right environment, and can be slow and expensive to run regularly.

Mathieu Fedrigo
Mathieu Fedrigo
20 min
28 Oct, 2024

Comments

Sign in or register to post your comment.
Video Summary and Transcription
End-to-end testing is important for catching hard-to-find bugs, but it can be complex and time-consuming. The speaker shares their journey at YOLO apps and how they addressed these issues using Maestro, a newer testing tool. Maestro allows interaction with all aspects of the app and offers a web interface for building tests. It also provides features like auto retry and test videos for troubleshooting. The speaker also discusses automating CI/CD using Expo and EAS, which simplified the app build and distribution process. They demonstrate how EAS and MySQL Cloud can be used for reporting and investigation. The power of end-to-end testing is showcased, with a fast CI/CD time and free tests and EAS updates. Maestro has some limitations, but it offers easy test writing and 100 free tests per month, with additional tests available at a cost.

1. Introduction to End-to-End Testing

Short description:

End-to-end testing is like a test drive for your app, examining it in its entirety and catching hard-to-find bugs. However, setting up and using end-to-end tests can be complex, unreliable, and time-consuming. My talk today will share my journey at YOLO apps and how I addressed these issues to achieve the perfect end-to-end setup.

Hey, I hope you're doing well. I'm Mathieu and it's nice to be here today. I'm going to talk about end-to-end testing. So think of your app as a high-performance sports car. You wouldn't just test the engine or the brakes or the steering in isolation. You would want to take it out for a spin, see how it performs on tracks in real-world conditions. Well, that's the essence of end-to-end testing. It's like your test drive. It examines your app in its entirety, catching those hard-to-find bugs, especially in native code, that unit or interaction tests might miss.

Maybe you've heard about the testing pyramid or testing trophy. They always mention end-to-end testing but the reality is that I've worked with different clients at YOLO apps and I rarely saw a good end-to-end testing setup. And most of the time there are no end-to-end tests at all. And I believe that's because there are a lot of pain points.

So, first of all, the end-to-end tests for me are still complex to set up and use. I took more than a week to set it up with some tools. The tests can be unreliable and it's going to be annoying to set it up on CI-CD properly because you have to build the app, start the simulators, have the right environment. And last but not least, it's almost always slow and expensive to run them regularly. So, my talk today is about my journey at YOLO apps and how I tried to fix all of those issues to have the perfect end-to-end setup.

2. Exploring Appium, Detox, and Maestro

Short description:

I tried Appium, a powerful black-box end-to-end testing tool. However, it has complex documentation, a steep learning curve, and no CI-CD support. Then, I explored Detox, a simpler but less powerful React Native testing tool. Neither of these tools addressed the pain points I mentioned earlier. Finally, I discovered Maestro, a newer tool with a cool community and helpful documentation. I'm going to demonstrate how Maestro works using a simple app and Maestro Studio, a web interface for building tests.

First of all, I tried Appium. It's a black-box end-to-end testing tool. There's no need to bundle or to install anything inside your app. You just give it the app, the APK. And I think it's the most established tool and also the most powerful one. Appium can replicate almost anything a real user can do.

But for me there are also a lot of drawbacks. It's really complex to understand the documentation, to set it up properly. I spent a lot of time to have my first test running. There's a huge learning curve and there's also no CI-CD support. So, you're going to have to handle the simulators, the build, and so on.

Then I tried Detox, which is a React Native end-to-end testing tool. I personally believe that they are pretty similar. I mean Detox is a bit simpler and easier to use overall but on the other hand it's less powerful. And after using those two tools, I realized it's still not something I would see my team and I use every day. They don't address the pain point I mentioned earlier. So, I had to continue digging and finally I discovered Maestro. Maestro is a newer tool. It works on React Native and every other mobile platforms. I think there's a really cool community around it. They have a Slack where they answer questions very quickly, for example. But the documentation is very cool and instead of talking about it, I'm going to show you how it works.

So, I've got here a simple app. I have an info button that opens the modal and I can swipe this modal back down and this is the test I'm going to try to do with Maestro. These kinds of tests is really hard to do without an end-to-end testing tool. With a regular integration testing tool like React Native Testing Library, you usually have to log the navigation. But you will see how I do it. The first thing we're going to do is use Maestro Studio. It's a tool that comes bundled in with Maestro and it's basically a web interface where your simulator is embedded and I can hover over my simulator and some zones and some text will be highlighted. This tool is here to help me construct, to help me build my tests.

3. Constructing Tests with Maestro

Short description:

I can interact with everything in my app, including tapping buttons, test IDs, texts, and specific screen points. Let's construct a test by clicking the info button and selecting recommendations for actions and assertions. If there are no suitable recommendations, I can refer to the documentation for various actions, including swiping. After selecting the desired actions, I can execute the test and export it to create within my codebase.

So, if I click on something, you will see that I have some recommendations. I can tap on this button, I can tap on a test ID, I can tap on a text, I can even tap on some specific points on the screen. I think it's a bit less recommended but you still can auto-type your test quickly, even if you haven't set up your test IDs properly. And I can interact with everything in my app. I can also do some assertions if I want.

But let's try to construct the test. So, I'm going to click on my info button. The first recommendation seems pretty nice. So, I can simply select it and it will run this action and you should see the result of my simulator. Yeah, the model just opened. Now, maybe I can check that the text is visible. So, I'm going on the assertion recommendation and this one seems exactly like I wanted. So, I can select it and it's passing, as you can see with the green tick mark. Next thing to do is close the model back down. And when I click on info, you can see that I don't really have any good recommendation. I want to swipe it, not type it, not tap it. So, I can simply open the docs. You will see that there are a lot of actions you can do with Maestro. I can assert something is visible, not visible, I can input some text easily, I can scroll inside my app, and I can also swipe. So, we'll have a look at the swipe documentation.

Here, I want to scroll down. So, this example seems pretty nice. And when I found something I want, I can copy it, come back to Maestro Studio, and I can just input anything I want here. So, I'll paste this stuff, modify it so that I can add my test IDs and change the direction. And when I'm done, I can execute this part, and you will see that my model slides back down. The last thing we can do is assert that the model text isn't visible anymore. Do that with assert not visible. And when I'm done, I can simply select everything and export it so that I can just create this test inside my codebase. So, I'll just copy this and come back to my app. I have made a test template that I will come back to later on.

4. Running Tests with Maestro

Short description:

I'm just pasting my test here and running it on Maestro Studio. Additionally, Maestro offers Maestro Cloud, a tool that allows tests to run on their servers. They provide auto retry and videos of failing tests, making it easy to troubleshoot. Maestro has been a solution to many pain points and is simple to use. However, CI/CD integration is still a work in progress.

You'll see there is a tag here. I'll explain this later, but basically, I'm just pasting my test here. And yeah, the test is opening the app. We're clicking on info, asserting something is visible, and swiping back down. So, I run the test on Maestro Studio, but I can also run it with Maestro only. So, you can see what happens when I just run my test. The video is not sped up. So, that's the real time of Maestro test. And as you can see, the app should close and open back up. And it's very quick. You can see it happen on the side. The test passed. I'm good.

Last thing I want to show you is another tool from Maestro, which is Maestro Cloud. And with one simple command, I can, instead of running the tests on my machine, I can send the tests and my Apica to the Maestro Cloud servers. It's their cloud services. And the tests will then run on their servers, on their simulator. I don't have to manage anything. And I can just go to their web interface and have a look at the different executions. So, that's very cool, because they take care of everything. They have auto retry if the test fails. If it fails, you can have a look at what step failed. And there are even some videos of the failing part of the test that helps you understand what went wrong.

And, well, that's it for the Maestro demo. I mean, Maestro for me was something that really solved a lot of my pain points. The install is super quick and it's very simple to use. It's never perfect, but Maestro helped us a lot about flakiness. And then, well, running it locally is great, but CI CD is still partly addressed. You saw I can start the test on Maestro Cloud from my machine, but not from the CI yet. I still need to build my app first on the CI.

5. Automating CI/CD with Expo

Short description:

I wanted an automated solution for my team, without the need for manual app builds during CI/CD. After exploring Expo, a set of tools that allows for quicker iteration, I discovered that I could use Expo's custom development builds and EAS cloud services to build and distribute the app. By injecting the update layer into the native layer, we can easily share and test the latest updates on different branches. Expo has helped address our CI/CD challenges.

I still believe I needed something fully automated to really get my team on board. For example, I want something that can be done automatically on a pull request or when you merge to master, for example. So I tried to have a look at the documentation, at the articles online, and I saw that they recommend you rebuild the app for each test. And for me, that's a bit annoying. I don't want to have to build my app during the CI CD. I will have to manage the cache, the environments. It's going to be slow and expensive, too. So I dug deeper and finally I realized that at Theodore Apps, we also use Expo a lot and it can help us here. So let's see how.

Quick recap on Expo. It's a set of tools that allows you to iterate quicker. It's even recommended by Meta now. Maybe some of you used Expo Go before. It's good for prototyping, but it's not recommended in production. So here we use the custom development builds. It's like my custom build. Custom development build is the native layer with the native code and the libraries you need plus some useful Expo stuff on the side. And this native layer is like a shell inside of which you inject your update layer. So you can build this shell locally with Expo, which is going to use Xcode or Gradle and other hood. But you can also use EAS, which are Expo cloud services. And with only one command, the build will be made on EAS servers, which will probably be quicker than my machine.

And once you build on EAS servers, the build stays available for everyone on your team. And that's really helpful because you only have to build once and then everybody on your team can just simply download it. So that's the native layer. And so inside this native layer, you can inject the update layer, which basically is the JavaScript layer. It's like the JavaScript bundle you have when you run start. But you can also use EAS to create some update layers and store them on EAS servers. Here you can see that I can easily inject the latest layer that has been done on the develop branch inside my native layer. And it means that if my colleague has the native layer on his phone, he can quickly download the latest update and see what the app looks like on develop currently. So that's what we use to address my CICD issues with Expo.

6. Using EAS and MySQL Cloud

Short description:

We don't need to build on each pipeline, and this will make it fast, cheap, and much simpler. Here is what happens when I open a pull request on my project. The first step is to create and publish the update to EAS. Instead of building the app here, we can also use EAS and download the latest build. By running tests and using the MySQL Cloud hook, we can get reporting back to the pull request. If the CI fails, we can investigate the details and watch the video recording of the app.

We don't need to build on each pipeline, and this will make it fast, cheap, and much simpler. Let's see what the solution looks like.

Here is what happens when I open a pull request on my project. I'm using GitHub actions, but you can use whatever you want. The first step is to create and publish the update to EAS. It means that I'm bundling the JavaScript code and sending it to EAS. When it's done, and when the update is created, we show a QR code that you can scan if you have the native layer to see the state of my app as it is on my pull request branch, which is very useful for even the PR.

And next, instead of building the app here, we can also use EAS. Then I simply download the latest build I made on EAS. And this is where we go much quicker than having to rebuild the app. Because now we have everything we need. We have the APK and we can just send things to MySQL Cloud.

The next command is the MySQL Cloud command I showed you earlier. I give it the path to my APK or app file for iOS, and also a parameter which is the ID of the update we made earlier. Which means that now when the app opens on MySQL Cloud servers, it opens with a deep link pointing to the right EAS update. It will then fetch this update from EAS. And when it's done, now the app has the same state as it is on my pull request branch.

So the last thing we can do is run the tests and get the reporting back to my pull request. I'm using the MySQL Cloud hook here to have a nice reporting. And you can see here that my full CI took only less than five minutes. So I think that's very cool. I can also show you what happens when the CI fails. So I can get more details here. As you can see, my own test passed, but model one failed. Let's have a look at why. It will bring me back to the MySQL Cloud interface. I can see that this assertion here is the one that failed. It was swiping down, apparently. So to get more info, I can just simply start the video. I should see the app that opens.

7. End-to-End Testing with Maestro

Short description:

On Android, the model is not a nice model that pops from the bottom, but it shows us a page. This example showcases the power of end-to-end testing, which regular integration testing may miss. With this solution, we have a CICD time of four minutes, free tests and EIS updates. Maestro, although new, has limitations such as no iOS device support, only simulators, and no device found support. The tests are written in YAML, which is not type-safe or standard. However, it is easy to write tests, and the tool offers 100 free tests per month. You can choose your testing strategy and run tests weekly or when publishing updates. If you need more tests, pricing is 10 cents per test. Thank you for joining and don't hesitate to ask any questions.

I click on the info button, the model opens. And yeah, it's failing. For some strange reason on Android, the model is not a nice model that pops from the bottom, but it shows us a page here, which is strange. But that's why I showed you this example, because that's really the power of end-to-end testing. That's something that you could easily miss if you only test on your simulator. And that's also something that you would never have coped with the regular integration testing.

So to sum up with this solution, we have a CICD time of four minutes. The tests are free and the EIS updates are free. Whereas if you were to build yourself on the CICD, it would take much more time. Maybe you would have to pay the production plan of EIS so that you can build a lot, or maybe if you want to build yourself you would have to deal with the caching and maintenance of the CICD. So with that, we fixed every pain point.

On the last slide of this presentation, there will be a QR code where you can find my example repository. And please feel free to use it to copy it for your apps. You can see there how I set up my CICD. It's very simple. Before I finish, let's talk about some pain points. Maestro is a new tool. It doesn't have iOS device support yet, only simulators. There's no device found support yet either. The tests are written in YAML, which is annoying because it's not type-safe and not standard. But it also means that writing the test is easy and maybe your product owners can do it, or maybe your designers can do it too.

And the 100 free tests per month limit, maybe it doesn't seem like much, but my advice is you should totally try it on your project. 100 tests per month is enough for you to get an idea of whether or not Maestro helps you. And you don't have to run the test on each pull request. You can run them weekly or maybe only when you publish an update to your app, for example. If you remember earlier, I showed you that you can add tags for the test. So a test with this tag will mean it will only run on every pull request or it will only run weekly or only run before we deploy an update. You can see how it works on my example repository, but this means that you can choose your own testing strategy. Maybe if you have a critical feature of your app, you want to test it on each pull request, but the other features that are less important, maybe you can only test them before you deploy an update. And if you want to do more than 100 tests per month, the pricing is 10 cents per test and you can always safe host down the line if you want. Well, that's it for me. Thank you very much. If you scan this QR code, you can see the example repository and also the slides. You can find it in my GitHub. Please don't hesitate to ask any questions in the chat or on my Twitter. And you can also come take a look at what we do at Theodore Ops. Thank you very much. Bye.

Check out more articles and videos

We constantly think of articles and videos that might spark Git people interest / skill us up or help building a stellar career

Network Requests with Cypress
TestJS Summit 2021TestJS Summit 2021
33 min
Network Requests with Cypress
Top Content
Cecilia Martinez, a technical account manager at Cypress, discusses network requests in Cypress and demonstrates commands like cydot request and SCI.INTERCEPT. She also explains dynamic matching and aliasing, network stubbing, and the pros and cons of using real server responses versus stubbing. The talk covers logging request responses, testing front-end and backend API, handling list length and DOM traversal, lazy loading, and provides resources for beginners to learn Cypress.
Testing Pyramid Makes Little Sense, What We Can Use Instead
TestJS Summit 2021TestJS Summit 2021
38 min
Testing Pyramid Makes Little Sense, What We Can Use Instead
Top Content
Featured Video
Gleb Bahmutov
Roman Sandler
2 authors
The testing pyramid - the canonical shape of tests that defined what types of tests we need to write to make sure the app works - is ... obsolete. In this presentation, Roman Sandler and Gleb Bahmutov argue what the testing shape works better for today's web applications.
Full-Circle Testing With Cypress
TestJS Summit 2022TestJS Summit 2022
27 min
Full-Circle Testing With Cypress
Top Content
Cypress is a powerful tool for end-to-end testing and API testing. It provides instant feedback on test errors and allows tests to be run inside the browser. Cypress enables testing at both the application and network layers, making it easier to reach different edge cases. With features like AppActions and component testing, Cypress allows for comprehensive testing of individual components and the entire application. Join the workshops to learn more about full circle testing with Cypress.
Test Effective Development
TestJS Summit 2021TestJS Summit 2021
31 min
Test Effective Development
Top Content
This Talk introduces Test Effective Development, a new approach to testing that aims to make companies more cost-effective. The speaker shares their personal journey of improving code quality and reducing bugs through smarter testing strategies. They discuss the importance of finding a balance between testing confidence and efficiency and introduce the concepts of isolated and integrated testing. The speaker also suggests different testing strategies based on the size of the application and emphasizes the need to choose cost-effective testing approaches based on the specific project requirements.
Playwright Test Runner
TestJS Summit 2021TestJS Summit 2021
25 min
Playwright Test Runner
Top Content
The Playwright Test Runner is a cross-browser web testing framework that allows you to write tests using just a few lines of code. It supports features like parallel test execution, device emulation, and different reporters for customized output. Code-Gen is a new feature that generates code to interact with web pages. Playwright Tracing provides a powerful tool for debugging and analyzing test actions, with the ability to explore trace files using TraceViewer. Overall, Playwright Test offers installation, test authoring, debugging, and post-mortem debugging capabilities.
Everyone Can Easily Write Tests
TestJS Summit 2023TestJS Summit 2023
21 min
Everyone Can Easily Write Tests
Playwright is a reliable end-to-end testing tool for modern web apps that provides one API, full isolation, fast execution, and supports multiple languages. It offers features like auto-weighting, retrying assertions, seamless testing of iframes and shadow DOM, test isolation, parallelism, and scalability. Playwright provides tools like VS Code extension, UiMode, and Trace Viewer for writing, debugging, and running tests. Effective tests prioritize user-facing attributes, use playwright locators and assertions, and avoid testing third-party dependencies. Playwright simplifies testing by generating tests, providing code generation and UI mode, and allows for easy running and debugging of tests. It helps in fixing failed tests and analyzing DOM changes, fixing locator mismatches, and scaling tests. Playwright is open source, free, and continuously growing.

Workshops on related topic

Introducing FlashList: Let's build a performant React Native list all together
React Advanced 2022React Advanced 2022
81 min
Introducing FlashList: Let's build a performant React Native list all together
Top Content
Featured Workshop
David Cortés Fulla
Marek Fořt
Talha Naqvi
3 authors
In this workshop you’ll learn why we created FlashList at Shopify and how you can use it in your code today. We will show you how to take a list that is not performant in FlatList and make it performant using FlashList with minimum effort. We will use tools like Flipper, our own benchmarking code, and teach you how the FlashList API can cover more complex use cases and still keep a top-notch performance.You will know:- Quick presentation about what FlashList, why we built, etc.- Migrating from FlatList to FlashList- Teaching how to write a performant list- Utilizing the tools provided by FlashList library (mainly the useBenchmark hook)- Using the Flipper plugins (flame graph, our lists profiler, UI & JS FPS profiler, etc.)- Optimizing performance of FlashList by using more advanced props like `getType`- 5-6 sample tasks where we’ll uncover and fix issues together- Q&A with Shopify team
Designing Effective Tests With React Testing Library
React Summit 2023React Summit 2023
151 min
Designing Effective Tests With React Testing Library
Top Content
Featured Workshop
Josh Justice
Josh Justice
React Testing Library is a great framework for React component tests because there are a lot of questions it answers for you, so you don’t need to worry about those questions. But that doesn’t mean testing is easy. There are still a lot of questions you have to figure out for yourself: How many component tests should you write vs end-to-end tests or lower-level unit tests? How can you test a certain line of code that is tricky to test? And what in the world are you supposed to do about that persistent act() warning?
In this three-hour workshop we’ll introduce React Testing Library along with a mental model for how to think about designing your component tests. This mental model will help you see how to test each bit of logic, whether or not to mock dependencies, and will help improve the design of your components. You’ll walk away with the tools, techniques, and principles you need to implement low-cost, high-value component tests.
Table of contents- The different kinds of React application tests, and where component tests fit in- A mental model for thinking about the inputs and outputs of the components you test- Options for selecting DOM elements to verify and interact with them- The value of mocks and why they shouldn’t be avoided- The challenges with asynchrony in RTL tests and how to handle them
Prerequisites- Familiarity with building applications with React- Basic experience writing automated tests with Jest or another unit testing framework- You do not need any experience with React Testing Library- Machine setup: Node LTS, Yarn
Detox 101: How to write stable end-to-end tests for your React Native application
React Summit 2022React Summit 2022
117 min
Detox 101: How to write stable end-to-end tests for your React Native application
Top Content
Workshop
Yevheniia Hlovatska
Yevheniia Hlovatska
Compared to unit testing, end-to-end testing aims to interact with your application just like a real user. And as we all know it can be pretty challenging. Especially when we talk about Mobile applications.
Tests rely on many conditions and are considered to be slow and flaky. On the other hand - end-to-end tests can give the greatest confidence that your app is working. And if done right - can become an amazing tool for boosting developer velocity.
Detox is a gray-box end-to-end testing framework for mobile apps. Developed by Wix to solve the problem of slowness and flakiness and used by React Native itself as its E2E testing tool.
Join me on this workshop to learn how to make your mobile end-to-end tests with Detox rock.
Prerequisites- iOS/Android: MacOS Catalina or newer- Android only: Linux- Install before the workshop
API Testing with Postman Workshop
TestJS Summit 2023TestJS Summit 2023
48 min
API Testing with Postman Workshop
Top Content
WorkshopFree
Pooja Mistry
Pooja Mistry
In the ever-evolving landscape of software development, ensuring the reliability and functionality of APIs has become paramount. "API Testing with Postman" is a comprehensive workshop designed to equip participants with the knowledge and skills needed to excel in API testing using Postman, a powerful tool widely adopted by professionals in the field. This workshop delves into the fundamentals of API testing, progresses to advanced testing techniques, and explores automation, performance testing, and multi-protocol support, providing attendees with a holistic understanding of API testing with Postman.
1. Welcome to Postman- Explaining the Postman User Interface (UI)2. Workspace and Collections Collaboration- Understanding Workspaces and their role in collaboration- Exploring the concept of Collections for organizing and executing API requests3. Introduction to API Testing- Covering the basics of API testing and its significance4. Variable Management- Managing environment, global, and collection variables- Utilizing scripting snippets for dynamic data5. Building Testing Workflows- Creating effective testing workflows for comprehensive testing- Utilizing the Collection Runner for test execution- Introduction to Postbot for automated testing6. Advanced Testing- Contract Testing for ensuring API contracts- Using Mock Servers for effective testing- Maximizing productivity with Collection/Workspace templates- Integration Testing and Regression Testing strategies7. Automation with Postman- Leveraging the Postman CLI for automation- Scheduled Runs for regular testing- Integrating Postman into CI/CD pipelines8. Performance Testing- Demonstrating performance testing capabilities (showing the desktop client)- Synchronizing tests with VS Code for streamlined development9. Exploring Advanced Features - Working with Multiple Protocols: GraphQL, gRPC, and more
Join us for this workshop to unlock the full potential of Postman for API testing, streamline your testing processes, and enhance the quality and reliability of your software. Whether you're a beginner or an experienced tester, this workshop will equip you with the skills needed to excel in API testing with Postman.
How to Build an Interactive “Wheel of Fortune” Animation with React Native
React Summit Remote Edition 2021React Summit Remote Edition 2021
60 min
How to Build an Interactive “Wheel of Fortune” Animation with React Native
Top Content
Workshop
Oli Bates
Oli Bates
- Intro - Cleo & our mission- What we want to build, how it fits into our product & purpose, run through designs- Getting started with environment set up & “hello world”- Intro to React Native Animation- Step 1: Spinning the wheel on a button press- Step 2: Dragging the wheel to give it velocity- Step 3: Adding friction to the wheel to slow it down- Step 4 (stretch): Adding haptics for an immersive feel
Monitoring 101 for React Developers
React Summit US 2023React Summit US 2023
107 min
Monitoring 101 for React Developers
Top Content
WorkshopFree
Lazar Nikolov
Sarah Guthals
2 authors
If finding errors in your frontend project is like searching for a needle in a code haystack, then Sentry error monitoring can be your metal detector. Learn the basics of error monitoring with Sentry. Whether you are running a React, Angular, Vue, or just “vanilla” JavaScript, see how Sentry can help you find the who, what, when and where behind errors in your frontend project. 
Workshop level: Intermediate