The evolution of modern web applications and their monitoring

Web applications continue to evolve at an unbelievable pace, and the architecture surrounding web apps get more complicated all of the time. The people that maintain them have grown beyond a handful of developers from just a few years ago to highly specialized teams. Developers make constant adjustments to the code and content, and their changes get published to the live site instantly in some cases. With the growth in complexity of the web application and the development process, web application monitoring also needs to keep pace with the ever-changing demands.

Web application evolution

The last three decades have seen dramatic changes in web technology. As applications become more distributed across data centers and the cloud, locating and troubleshooting problems becomes more challenging than ever before.

The 1990s

The early days of the web saw simple web applications. A typical application had a few interactive elements in a form. The user provided information, submitted their input, and a new page loaded as a result. That user moves along in the application with each static page building on the user’s input on the previous page.

Mid-decade, client-side scripting (JavaScript) allowed developers to create the illusion of dynamic web applications. Developers used code to show and hide elements and provide input validation before the form submit. However, until the submission of the form and the page refreshed, there could be no actual interaction.

By the late ’90s, ActiveX objects downloaded to Windows-based machines made for a richer web application experience. However, they presented other problems due to incompatibility with different operating systems and security risks.

The 2000s

The introduction of AJAX (Asynchronous JavaScript and Extensible Markup Language (XML)), SOAP (Simple Object Access Protocol), and REST (Representational State Transfer), broadband, and a host of other web technologies changed the way web applications work. AJAX allowed communication with servers that didn’t require a full page submit and reload, so user interfaces became truly interactive.

The 2010s

The 2000s saw the rise of the Application Program Interface (API). The introduction of HTML5 late in the decade supported the APIs as well as native multimedia (no special plugins needed) and full support for the Document Object Model. The conditions were right for an explosion of new applications.

The day of the static webpage is over, and web applications have and continue to evolve. The monitoring tools meant to test them also needed to expand and improve to keep pace with the apps themselves but also support the development environments that generate them.

Web Application Monitoring then and now

The web is no longer a single server and a client. Today’s web applications require several servers to generate a single interaction. You can no longer monitor a few servers and check a few pages for uptime to guarantee that your web service is up and running. The intricacies of today’s web applications require a dynamic solution.

A web application monitoring solution needs to fit into today’s development processes

In the past, a web application went through a long development and testing phase before anyone dared bring the new application live. The process may take months, and sometimes years from inception to live on the Internet. Not anymore.

The modern development environment is one in constant flux. Developers integrate code changes multiple times a day, and automated processes kick in to build and test the web application immediately. The continuous integration and continuous deployment (CI/CD) environment means that new functionality and fixes get to the user faster, some in minutes, days, or a few weeks instead of the months the old development approaches needed. Uptrends Web Application Monitoring can support your CI/CD automation needs.

Previously, Uptrends wrote and maintained your scripts for you, but now you have full access to your transaction scripts. You can modify them at will, include them in your code repository for versioning, and include your monitoring updates in your build scripts by utilizing Uptrends API.

You’ll know your Uptrends monitoring is working because you’ve incorporated it into your development environment (monitoring behind your firewall works best with a Private Checkpoint). You update your scripts to reflect the changes in your application, check them in, and your build process updates Uptrends with the new script. As the changes perpetuate to your acceptance and production environments, the monitoring follows.

Moving beyond manual testing

Early in the evolution of web applications, testing a user interaction meant manually checking them. However, in 2004, Selenium Remote Control became a popular tool for testing web applications. Based on JavaScript, a developer could write a script to interact with a webpage in the same way a user does.

For many people the testing infrastructure and coding experience required proved to be beyond challenging. Instead, some needed a tool that could quickly generate working scripts and had an infrastructure in place to handle the testing. Third-party web application monitoring does that and more.

Uptrends Web Application Monitoring lets you decide how to develop, test, and maintain your scripts. From the novice to the DevOps pro can develop robust transaction scripts using Uptrends tools, and if needed, Uptrends support can step in to help.

The Transaction Recorder

The Transaction Recorder is a wonderful place to start. Using the Chrome extension, you click through your user path. You perform actions just like your user would do: click buttons, tick boxes, insert text, and switch tabs. The Transaction Recorder captures your activity. When you finish recording, you upload the recording to your account or Uptrends Support if you don’t want to optimize the script yourself.

The Transaction Recorder gets the bulk of the work done for you before you start to test and edit your transaction script.

Uptrends Transaction Recorder

The Step Editor

The Step Editor is an interactive interface for building out your transaction script. If you started with the Transaction Recorder, you’re well on your way, but you can also generate your entire script using the Step Editor.

  • Add Interactions: You can add needed actions. For example, the recorder can’t capture hover actions that activate menus, so adding a hover action before the click action fixes a problem.
  • Add Tests: Check for page or document elements to appear before proceeding with the next action.
  • Add Controls: Controls let you add screenshots, switch between tabs and frames, and scroll the page.
  • Use the text editor: If you’re comfortable with JSON code, you can always toggle to the script and edit using the text editor.

Self-Service Transactions step editor

Manual testing with Test now

The Test now button lets you watch as one of Uptrends’ 200+ checkpoints steps through your script. You can quickly see where your script is failing, and you get free screenshots for each step.

Monitor Modes

You don’t have to go straight into production with a new script. Monitor modes let you manually test while in Development mode. Once you’re satisfied, move your monitor to Staging mode. Staging mode is just like production, but the data generated doesn’t affect your production data, and no alerts are issued. It is a good idea to test your transaction in Staging mode for a few weeks before moving it to Production mode.


The chances are that your transaction requires login credentials and client certificates. You probably don’t want these sensitive pieces of information out there exposed in your monitor settings or your reporting. Uptrends’ Vault locks those values away, and you control who can see them. Your protected values only appear as asterisks when used outside the Vault.

In-house vs. third-party monitoring

The temptation may be to expand your automated internal testing to your production environment. Of course, that is better than manual testing, but you need to test from outside your firewall for results true to your users’ experiences. Third-party testing with Uptrends moves your web application monitoring to your users’ locations. By monitoring from outside your firewall, transaction issues may surface that affect your users due to location, such as DNS or latency problems. Location-based problems can take days, weeks, or months to capture with internal testing.

Take Uptrends’ Web Application Monitoring for a test drive

Web Application Monitoring with Uptrends utilizes the latest in technology. We’ve got the tools you need to protect your investment. Set up a demo, and one of our monitoring consultants can show you the ropes. A free trial of our Business or Enterprise plan is all you need to get started monitoring your crucial functionality. Uptrends Support is available to assist you if you need any extra help setting up your Web Application Monitoring.