The most useful features of Tricentis Tosca include API scanning, basic web application automation, and data validation capabilities. It is easy to automate tasks, highly flexible, straightforward to learn, and easy to maintain.

The most valuable features of Tricentis Tosca are the modular approach and Vision AI. The modular approach reduces scripting effort by at least fifty percent, which significantly cuts down on the script development time. Reusability is high, resulting in effort reduction. Additionally, the Vision AI feature is really good. The Scan module, reporting, and execution are also highly effective.

Tosca can go through platforms to make end-to-end testing across CRM, billing, provisioning, order management flow, and databases to check for errors. It can interface with Azure to open the box and collect evidence, documentation, or the Tosca document that was realized. It can have scheduled tasks to monitor APIs and other services to ensure they are up and working correctly. These are the main functions we use Tosca for. Additionally, it is codeless, making implementation easier. It can be divided into bricks and modules that can be easily aggregated to build new use cases.

It's codeless to speed up the work. But the possibility to also do some coding, I know it's not as fast, but when you can code, you can make Tosca more customizable to fit in some strange cases.

So there should be this possibility, it should be avoided when possible, but to have the possibility to fit all systems and other things where codeless cannot fit. So, it gives flexibility and agility.

The scriptless automation tool is one of the important features. It allows for drag-and-drop functionality and demo automation in SAP-based applications, which can be challenging with other automation tools. Model-based automation is another good feature, allowing similar models to work by changing the engine. The integration capabilities with QTES tools, CSE tools, or JIT also improved a lot over the years.

The most valuable feature of the solution stems from the fact that it offers technology coverage because you can automate any technology, like in the mainframe, applications, client applications, or Word documents. I would say that we can automate the entire flow for endpoints where we work with such tools.

It has all the features you need. You can see your testing status, generate reports, and have a dashboard to track the progress of your projects. You'll see how many tests passed or failed, how many defects were raised, and other traceability metrics. 

In one go, on the dashboard, you'll get a lot of information so that the management can know what's exactly going on with the testing projects. It's the best.

It offers many features, such as risk-based testing and scenario creation using Kafka. Tosca performs well for web applications, particularly in terms of object identification and overall functionality, but its performance lags when it comes to SAP, client applications, or mobile applications. 

The platform's most valuable feature is model-based testing, which is effective for test case design and optimization.

The most important feature is its ability to support the technical automation of specific clients that we cannot use with other tools.

The solution can be deployed in DevOps and ERP environments like Oracle Fusion. It accelerates testing with the libraries. The product incorporates libraries and is more sensitive to the scans. 

The tool incorporates AI in maintaining and capturing libraries, making script maintenance easier for automated testing cases.

Tosca offers encryption features for securing sensitive data such as usernames, passwords, credentials, and other data managed within the tool. This information is encrypted and can be decrypted within the Tosca environment.

The tool's most valuable feature is Tosca Commander. 

The scalability is a valuable feature of Tricentis Tosca.

The ability to pick up when a desktop picks up, which makes it much faster to run tests. Also, its ability to work across multiple systems is very useful.

Test case design and test data management are the most valuable features for us.

There is a specific feature in Tricentis Tosca called Vision AI. What it does is basically it'll capture the entire screen, and you can automate anything that can be viewed on our screen. For example, if you are trying to access an application like Teams, so if you want to select any user and call him, you can do that. Anything that is on a screen, you can automate using that Vision AI tool.

The interface is pretty simple, and it's user-friendly, so people with minimal knowledge also can start using the Tosca tool. The widgets and the invoicing are also user-friendly.

It's stable and reliable.

The solution can scale.

Support is helpful. 

Pricing is affordable. 

The item that is different from all the other tools is that it's module based. This is the thing that I like about Tosca. It means there is no hassle in coding. 

The low code is the best feature, and clients like it.

The most valuable feature of Tricentis Tosca is the Tosca Commander. Functionality is another thing I find most valuable in the solution.

Before we bought Tricentis Tosca, we had around three tools, Selenium, Worksoft, and Provar. The amount of automation was distributed between these three tools. So it was always a challenge to maintain all these separate automated scripts. Also, you need to have experts on all these tools. So once we brought in Tosca, we actually removed the licenses for Worksoft and Provar.

The major advantage is that it supports all kinds of applications, so it can be either web-based automation or desktop application automation, SAP or other ERP, or the mainframe, Citrix applications. If you want to automate any kind of applications, you can use Tosca, which is not possible with tools like Selenium, Worksoft, or Provar. There are all application-specific solutions.

Tosca is flexible enough to work with multiple areas, like web, API, database, and retail automation. Tricentis team supports all these areas regardless of your operating system 

Recently, I've been working on an automation application. To date, I've designed almost 10,000 scripts. In addition ETL and AP automation, we are using Tosca API to automate web services.

We can also create customized functions. For example, if something isn't supported in Tricentis Tosca Commander, we can create our own function to integrate it with Tosca Commander, so we can utilize it and integrate with the macros.

We create macros in the Excel DVS, and I created multiple tools via VBA as part of the ATL automation to compare source data to the target. We just need to schedule it. We schedule that via Postcard, so the macros we created will compare the source data versus the target data. 

I like how the modules are set up, particularly how you can use the screens you're automating. This automation helps save both time and money because we use less test capacity regarding personnel.

You can scan an entire browser or application window and define all the controls you want to steer, which you can reuse. In other tools, you have to define each control individually, so this feature in Tricentis Tosca is quite nice.

The most valuable feature is automating regression testing scripts linked with Solution Manager. This functionality supports our current requirement for automated testing without utilizing other features like LiveCompare.

The mainframe testing and UI automation are the most valuable aspects of the solution.

Technical support is good.

The solution offers good tutorials. 

It's pretty easy to use.

The solution is model-based. I know and that's the main reason we went there. We are also using Tosca BI, which is the BI module. We're using that regularly for most of our teams. We just purchased it for our Business Intelligence. We ran a POC and then we just purchased it. 

The initial setup isn't too difficult. 

The Model-Based Test Automation is the most valuable feature, where you can create reusable components. Even though we are using a scriptless automation tool, there still needs to be an understanding of how to create reusable components and how to keep refactoring and how to keep regression, the test scripts, at an okay level. We are coupling Tosca with some other risk-based testing tools, as well, but automation is primarily what we're using Tosca for, the scriptless, model-based technology which is driving automation for us.

It has other features for requirements which we are just starting to look at. We do have another requirements tool which is enterprise-wide. Not everyone is using Tosca in our company. We still have a mix of a couple of tools. Even though Tosca has a great requirements feature, and some teams are using it, they are still expected to use our standard enterprise requirements tool. It's a choice that the users are making regarding whether they use the other features of Tosca, like requirements and risk-based testing, or not.

The most valuable features of Tricentis Tosca was the ease of use, but it is getting more and more difficult to use. It is almost impossible to use Tosca without programming knowledge. 

The way of creating modules is basically simple. But when you have the module it is trial and error method on settings to get them working in a testcase.

Tricentis Tosca is well integrated with other products like Jira. It's also relatively easy to use and doesn't need experience or a specific skill set.

The solution is very user-friendly and the low code automation is great and very helpful.

To me, what stands out the most about Tricentis Tosca is that even if I'm not a technical tester, I could pick up on how to use it very quickly because of the mechanisms of the tool, for example, its scanning mechanism. I'm not so technical, but I'm able to maneuver through Tricentis Tosca and derive capability. It's a user-friendly tool. It's not very complex.

All the features available now in Tricentis Tosca are valuable.

The most valuable feature of Tricentis Tosca is it is a completely scriptless automation tool, which I liked a lot. They keep on continuously improving their tools, wherever we are facing any challenges they are able to provide a solution for it. It is easy to learn, everyone can easily read and understand what is happening with the scripts. Any business user or function tester can use the tool efficiently. This is a complete solution package.

It's been very helpful to have connectivity with mobile. The tool also identifies some of the actual changes from the recordings on the actual testing suite. That is something that I really like.

The most valuable features of Tricentis Tosca are the Salesforce scanning. There are two scanning for Salesforce applications. There is Salesforce scanning and normal application scanning. Object identification has been really useful in Tricentis Tosca.

The API testing has been useful. We can do testing in Postman and we receive good responses. We can import the Postman to Tricentis Tosca and start using it right away. The manual testing to automation can be done smoothly. You get the Postman sponsors from the manual testing team and we can import it to this solution.

There is a source code repository within Tricentis Tosca. There is no need to use GitHub or something else. We can do provisioning and all the switches in Tricentis Tosca. We use qTest as our direct test management tool, and it is integrated with this solution. Once installed it can easily be used and it is very easy to share the objects across the projects, such as if one developer scans all the pages we can share them across all the modules. The modules can be shareable as well. The reusability of some of the features is very good.

Overall the solution is easy to use compared to any other tools, it's very easy to organize and develop. It's simple for new people to have them be onboarded. There's not much coding involved, and the framework is stable.

Tricentis Tosca supports Salesforce Lightning which many other tools will not.

We are using the Tricentis Tosca BI testing module, analytics, and data testing and they have been great.

The automation engine is very strong, and it is very competitive in the market in terms of features. They develop a lot of features. 

The advantage of using Tricentis Tosca is that we can get started with automation without much investment on solution development, with it following a keyword-driven approach. We have the actions and verifications readily available, so you can get started on the Tricentis Tosca conversion from the first day of training, and this is the advantage we have observed from the tool.

I also like that it is a simple tool, in terms of system testing, though there are other tools now that are good competitors for Tricentis Tosca, e.g. Katalon Studio.

Tricentis Tosca is a really cool tool that you don't have to be technical to use it. Additionally, the solution is easy to use. The modules, libraries, and reusable are in an efficient way to update all the tests. I find it spot on with that. We also started using the design which we switched from Excel. The design was superior to Excel.

The most valuable aspect of using Tosca is that its user interfaces are intuitive. 

With the resources, we can quickly learn the product. You can quickly build automated testing, manage it, and have it run on a regular basis to ensure that there are no issues. It gave us a greater level of confidence when we were carrying out those tasks.

Some of those testing with other code-based setting frameworks found it to be much more fragile. As a result, managing and updating were much more difficult than with Tosca.

In terms of tool limitations, there is not a lot that the vendor would need to develop at this time. I believe that the Tosca tool's setup capabilities, as well as functionaries, could easily assist us in a very nice way with our automated testing effort.

With code free automation concept, it's easy to automate and maintain test scripts. Many of my team members shifted over the past two years, and upskilling and knowledge transition was never a problem. 

In today's agile and cloud world when solution and functionality are not stable, automation scripts' maintenance was not a big issue. Looking at the amount of rework and maintenance activity that we had done for our scripts, it might have been a nightmare with some other scripting tool.

The use of automation is most valuable.

The feature that I have found the most valuable is the recovery and cleanup process. Suppose there is a list of test cases and one test case has failed, it should not impact the other test cases. We can reuse the same test case. We can change the configuration of parameters and then use the test cases on the same thing. So, that's a useful thing. Otherwise, we have to use the cleanup process.

Another useful feature is to have our own library files. We can create our objects in the libraries and reuse them. There is no need to create duplicate data for that.

They have been giving some enhancements recently which means integration is also there. They've integrated with different software like Jenkins, Bamboo. So, we can also create pipeline points. They have recently given SAP and everything, which is very useful.

The most valuable feature is being able to create a test case by recording some scenarios and then leasing that task case to other scenarios.

We only use the UI for testing purposes, so all other features are unusable to us.

What I find valuable is that Tricentis is always refining the test methodology. They listen to feedback from the analysts about what the testing tool should do, and then Tricentis always implements it. So all the necessary testing functions are already implemented in their tools. So whenever there is some new need for a testing capability, I can be sure that Tricentis will implement it into the Tosca Test Suite quickly, and we can use it.

The most valuable feature is the UI.

We work primarily on evaluating the UI. We evaluated Tosca BI and a bit for Tosca APIs and think they are very useful.

The reporting is really nice. There are many clients who ask for a feature with any automation tool that can generate good reports for them. There is only one such tool that facilitates that option, which is Tosca.

I have found the test templates to be very useful.

Distributed execution with RDP is highly useful.

This solution is very easy to learn and any non-programmer or manual tester, with little experience in automation, can pick it up quite easily. 

It has a built-in repository to store all of the artifacts in the same place.

This product contains a lot of functionality.

It can provide all levels of testing from design to execution to reporting. I like it because everything is available in one place.

The automation testing functionality is very powerful.

This tool is very easy to use and I think that anyone can come in, having no experience with it, and within four to six months be comfortable with it.

The graphical interface means that you don't have to write any code.

The interface is very organized. You can find folders and settings for everything that you need, and you can easily connect things together.  

The most valuable aspect of the solution is the extremely fast setup. You can really get up and running within a very small window of time. It's great.

We like the fact that it works across mobile, desktop, web, and APIs. Due to this, the solution has a broad range of applications.

The most valuable features are 

• Tosca BI 
• Tosca Commander.

Tosca BI is important to make sure that our data integrity is in check and validated; to make sure our data is good. Our data is the number-one important driver for our company, so if that's not good, we have some big problems. 

Tosca Commander lets any test cases that are UI driven validate, and tests the UI and expected results.

Also, the nice thing about the model's solution is that we're able to build out the modules within Tosca, to facilitate ease of maintaining the test cases. It allows one spot to do an update and that flows through all the test cases that need to be updated.

Risk-based testing, test optimization, and support for over one hundred technologies are some of the most important capabilities of the platform. Many may argue that the same can be achieved by other tools as well, but not all within the same platform. The ease of maintainability is also a differentiating factor.

- Great User Interface and ease of checking all your artifacts of Testing.

- Makes optimal use of Model-based Test practice in getting Object-references from the application.

- Script-less, so less maintenance headache for non-technical users also.

- Drag and drop functionality to create and re-use your Test Cases

- Excellent re-use of Excel functionality for formulas and functions.

- Conditions which let the test case branch off from the Template. Helps work out different scenarios for data.

- Has been tried out on SAP, Oracle Apps, and IBM COGNOS BI applications. With a few tweaks works well with these applications.

- IF and LOOP statements introduced with the latest version.

- Improved performance of Web-Based Tests. WHILE LOOP and IF made better and more responsive with added error recovery options.

- Intuitive based options available, along with a rudimentary record and play functionality.

- Next version will even have the visualization tools required to see the interconnections between the TCD and the Test Cases, along with the workflow in the TCD and Tests.

- New and improved visualization for multiple browsers and a totally new Wizard with TBox out of Box support has been added to the (v9.2) of TOSCA Commander.

- Access to Business Intelligence (BI) features of comparing a DB to another one, also have been added as plugins.

- Access to an Analytical Engine to view and get reports from the Test Runs.

- Version 13 has also brought in BI testing and improvements on SAP Test scenarios

The most valuable features of Tricentis Tosca are all the test automation functionality. It is a full-scale automation tool.

Tosca can work with a wide range of technological solutions. So Tosca is not just a replacement for open-source products. It's integrated with different technologies, desktop applications, package solutions like SAP, and mobile applications.

This solution is easy to use for everybody, including those who are not IT-educated.

It allows for effective test management and an effective test case design.

The most valuable features are:

• Non-scripting test case building
• Test cases are easy to maintain
• Very good test case design module
• All of the features are well integrated into the suite

The solution is script-less, so you don't need IT knowledge to use the solution in an operational way. This is the most valuable feature. It's also only one of two or three tools that can do good automation on SAP, and in my opinion, it's the best of those.

The test sheet is very good.

There are algorithms that allow you to generate various test cases that guarantee maximum coverage.

The XScan was great because it was a handy way to automate on a surface which made it very easy and simple.

Compared to other tools we have been looking at, you don't have to be a programmer to operate it, though it helps. It also a product that can be used by business people.

We have multiple applications, and it supports parallel execution. It has mobile automation.

• Multiple scanning engines to automate many different applications.
• Powerful ability to generate different test data combinations from test instances.
• Logical workflow (from requirements through to execution and reporting).
• GUI is easy to learn.

• Scriptless automation
• Ease of using
• Object Identification Wizard
• Business parameters
• Steering controls

• Automation of regressive test cases
• Entering process and risk structures as basis for test design
• Entering logical test cases as basis for meaningful executable test cases
• Using the same test tool now as well for manual business testing

Image recognition: It has allowed us to automate a GUI section of our product which involves drawing different topologies.

I’m aware that other tools have this feature, but the whole test suite, it makes it good enough for us not to look for something else.

The tool can be handled without any knowledge in parameterisation, especially the TestCaseDesign which makes the tool mighty and stable - even when releases in the tested software are subjected to deep code changes. The maintenance of the test tool is manageble.

• Test case design: Integrated test data management in the tool itself
• Web services automation: Easier API testing
• DevOps: Testing starts as soon as development gets completed
• Service Virtualization: Early automation

The scanner helps us to define many tests with one scan.

Valuable features include generating data including ECP, BVC and risk-based opportunities:

• If the data is vast, we may miss a few scenarios. To avoid this, the Tosca tool provides an inbuilt feature.
• Classifying tests into two types: Equivalence partitioning (+.-) and boundary value tests (inbuilt feature of Tosca).
• Risk-based opportunities are identified based on customer weightage for the modules (inbuilt feature of Tosca).

I liked the "no required scripting" part as most of the people in my team are not skilled QAs and half of the team reside offshore, thus it suited to most of our requirements.

The model-based scriptless automation is the most valuable feature because it needs less maintenance as compared to script-based automation.

Tricentis Tosca supports 35 technologies, such as web, mobile, Salesforce, Java, SAP, ServiceMax, and Flash applications.

This is a complete Test Automation solution of our Enterprise Legacy system, which has many technical peripherals. It provides complete automation for apps/services of all domains and technology integration. Although not yet implemented on our site, features like Orchestrated Service Virtualization and Exploratory Testing excite me and have a huge potential for us.

Tosca is a model based component tool and also quite flexible in terms of the customization required for most of the applications, if objects are not recognized. It allows manual testers to pick up automation, because it is a scriptless tool. Reporting is well managed within Tosca and there is no requirement to build a framework around it.

The most valuable feature is the UI-based interface for building modules and turning modules into test cases.

Scriptless SW QA automation. Provides a very quick on ramp to test automation with little maintenance.

Below are the features that are the most valuable in regards to this product:

• With one click, it will scan all the elements on the screen, so that the user can select the required elements for automation tests.
• Exploratory testing gives an option to record a video, has interactive steps to capture a manual test case flow, and it can be converted to a PDF document with links for the video.
• Using exploratory testing, we can send an email to record manual test cases to the business analysts (BAs) who never need a product to be installed in their machine. The recorded files can be stored on a common server (that needs to be set up separately) or they can send those files to the intended automation team via emails.
• Not much in the way of programming skills is required to use this product.

Ability to test Java Swing UI on business application.

User friendly, Model Based Test Automation.

• Dynamic test case creation: Tosca lets you create automated test cases in no time. You can also convert your manual test cases into automated in a matter of seconds.
• Optimize, manage and automate: It lets you jot down your requirements, design test cases, automate and analyse your test results within one GUI.
• Scriptless automation:Testers can test without worrying about writing code.
• Supports both GUI as well as non-UI testing.
• Test case design: Really lets you think about your test approach and strategy, It lets you automatically generate all the possible (and required) permutations and combinations of the functionality to be tested.

Tosca Continuous Integration (Tosca CI) - today's fast pace agile environment needs fast feedback. Working along with the development team and being able to test as soon as the code is available; gives the organisation an edge!

Tosca Continuous Integration allows you to exactly achieve that.

Tricentis Tosca is a fast-pace, ever-evolving test automation tool that can solve today's testing requirements and provide fast feedback. The recent version of Tosca introduces a number of exciting features, such as:

• Web analytics
• Better identification of test objects
• Record manual and automated test cases

Tosca has made the non-programming engineers job easy. The concept is unique but indeed the tool is very powerful in analyzing the functional aspects of both standalone and browser applications. I had a very wonderful experience with Tosca.

There are a lot of features that I love within Tosca. To name a few:

• Model-based automation
• Scripting knowledge is not required
• Requirement traceability
• Usage of built-in aid packs

Tosca Testsuite is a model based automation tool and it doesn't require an explicit framework, unlike other automation tools.

While we started implementation with a focus on testing automation, the Risk Management feature is one we are seeing as very valuable in our environment, allowing us to better focus on critical testing.

• Scriptless tool -- great for those, like me, who don't have a lot of knowledge in coding to test software
• Works quickly and easily

I wouldn't usually describe user automation as a key feature but it is a key feature. The ability to scan the application and for it to have all of the attributes and things you need and put them into the test is the most valuable feature for us.

The best feature is the speed in which we are able to get our automation up and running. We had an unorganized library of regression test cases. We have, within the first six months, been able to automate 85% on our critical business processes and we have been able to maintain that while keeping our BCR ratio down. We have also seen about 234 defects per month in production to less than 8.

This solution allows you to create an entire automated framework where it allows you to easily manage everything in one place.

For me there are three outstanding features:

The first one is the test case design feature. When using the feature in your project - I definitely recommend using it – it forces you to think about your test approach, and your overall test strategy. Using this feature you have to define valid and invalid states and conditions of your SUT from a business perspective (e.g. defining a valid age or a valid combination of two business properties). The tool helps you here by generating all necessary combinations automatically out of your prior definitions. You link them to a test case template and all the necessary combinations of your test cases are generated automatically. In most cases you need to adapt the generated test cases for the specific test case, but the fundamental work is done by the tool.

The second one is the simplicity of creating test cases and the underlying model based approach. The process of creating a test case is pretty straightforward. In case of a GUI application you “scan” the current screen of the SUT first. Afterwards all UI controls are displayed and you can choose the relevant one for your test. A representation of the screen – a module – is created and stored in a module folder. You can then simply drag and drop this module into your test case. In the test case, you select, for each UI control, an action e.g. “click” or a specific value. Afterwards, you can arrange the test cases in different execution lists, which are the representations of a test run from a business perspective (e.g. smoke test, regression test, etc.).

Overall, everything is reusable simply via drag and drop, and you will always have a single point of maintenance (e.g. in a future release of your SUT a button was added, you just need adapt the module. Linked test cases and execution lists are updated automatically).

The third one is the support of multiple UI technologies as well as non-UI technologies. In addition, there are (extra payable) features like mobile testing support and service virtualization capabilities.

The features we've found most valuable are--

• It’s a modular structure, so changes in a module are automatically updated in all relevant test cases.
• It uses a risk-based approached via a weighted requirement set.

I think the most valuable features are:

• Scriptless testing
• Modules (object repository)
• Test data management
• It can be used by non-technical users, such as business analysts

We've found TBox to be valuable for scanning applications and automating test cases. In newest version, time of scanning the application has been reduced immensely. Also, there is a lot of ways to identify controls that doesn't have unique IDs, and that process is more stable than before.

Testcase design is most valuable, as it has helped in 2 different aspects. Storing the test data in one place, and deciding how many test cases are needed for a given scenario using one of the inbuilt algorithms, thereby ensuring the test coverage.

• Test cases design
• Model based test automation

• Complete or partial test automation
• Methodology for reducing the number of test cases needed along with high risk coverage
• Easy way to prioritize requirements
• Ease of test case maintenance
• It can be used by people with no previous programming knowledge
• Agile

The test automation function is independent of the technology used by the drag & drop functionality.

I mostly use the TOSCA Commander to create test cases. I also utilize the Tbox feature to automate complex test scenarios. Lastly, I find the requirements linking very useful in analysis after a release (i.e. test coverage, etc.).

• Test case design
• Shows results in the requirements section
• Manual test cases
• Automation

Business dynamic steering and table steering.

We like the idea of reusable data classes when we are using our test cases. We work with a lot of data, and so being able to create reusable data classes is very helpful to us.

I am impressed with the product's script test. 

The solution has plenty of features compared to other solutions.

Tosca is a good tool. The product enables codeless automation. If we need to write codes, it will take some time. With Tosca, we can scan things within a second, add the test, and run the script. We can track automation coverage with the help of requirements and coverage features. It is an effective feature. Reusable and library are key features of the product. Once we create the test cases with the help of the library and Reusable, we can call it repeatedly wherever we go.

Tricentis Tosca can be easily integrated with SAP infrastructure. It's a proven solution.