Today’s retail scene is a shopper’s paradise—from one-click purchases to customized web experiences to personalized in-store experiences, it’s become easier than ever to spend money on yourself and loved ones. As consumers buy more via mobile and other devices, and IoT becomes more than just a buzzword, retailers rely on robust sets of APIs to bring consumer data in and make these in- and out-of-store experiences unique and consistent.
Posts filtered by category: customers
Managing Change Behind the Scenes with Continuous Regression Testing for a Seamless Customer Experience
Updating APIs can be a tricky business. Whenever you modify an API, even if it’s a minuscule change to the code, you run the risk of breaking some existing functionality in an unintended way. So even if you’re fixing a minor bug, you want to make sure other working components in the API are left unharmed. Otherwise, you can cause issues in your customer’s integrations—and when that happens, you hear about it.
When introducing breaking changes to an API, you want your customers to keep the version they already have and update when they are ready—so they can test the changes in their own systems before releasing any changes downstream to their users. This is why making sure your API versioning doesn’t break is so critical. We have two systems in place for that: point-in-time API versioning coupled with API monitoring from Runscope. Monitoring our APIs with regression tests is critical to making sure that our API versioning processes are effective and deliver value to us and the end-user.
We consider ourselves an API-first company, which means that our product and the way we interface with customers is entirely by APIs. There’s an expectation that APIs will be online 24/7. If a customer uses Clearbit for a product integration and our APIs go down or something breaks, then that can trickle down and cause issues in the customer’s system—and that’s not good for anyone’s business. So, more important than the way that we version and improve on our APIs is the way that we ensure that they’re performing optimally, and at all times. For that, Runscope is a vital component to our business.
Three Versions of API Versioning
Basically, you have three ways to version an API:
The first (and most common) is to include the version in the request URL — for example, v1, v2, and so on — and route different API versions to different endpoints. This works well for occasional updates, but quickly gets unruly if you have a lot of API changes.
The second approach, which I’ve seen GitHub successfully using, is to send the version in the header of the request. This approach (similar to url versioning) is probably best for APIs that only introduce breaking changes once in a great while.
The third approach, which I’m not sure if Stripe invented, but they certainly made it popular, is what we call point-in-time versioning. How it works is, the first time a user makes a request to the API, that point-in-time (timestamp) gets saved alongside the account data and becomes their version until they choose to manually bump it to the current version.
With this approach, when a user calls an API for the first time, they don’t have to worry about versioning. They make their first API request, and we record the version they are using automatically. Now, every time a user calls an API, that API version is locked.
Point-in-Time Versioning: Not a Numbers Game Anymore
The point-in-time method is slightly more complex, but it has advantages. For instance, at Clearbit, it allows us to make adjustments within our codebase without having to create create new endpoints within our system. It also allows us to easily see which API versions our customers are using. Since we’re anticipating quite a few changes to our APIs in the future as we improve them, this approach works well for us.
This approach also allows us to do some interesting things in our API Docs and Dashboard (below). We can look at the current version and compare that to the customer’s time-stamp. Based on that comparison, we can let the customer know they are not on the current version and, because we keep a detailed change log, spell out exactly what changes were made since their point-in-time version.
Someone once asked, how many versions of our API do we have? We don’t really think about versions in terms of numbers anymore. We think about them in terms of a point in time. This way if we ever have a breaking change, we can simply bump the timestamp on the current API to the time of change.
The key to all this of course is managing change on the backend so that API versioning is seamless for our customers. Basically, we need assurance that our versioning doesn’t break and that we can maintain this style without a lot of complexity.
Managing Change and Complexity with Runscope
By running a schedule of regression tests against our API endpoints, we’re able to support tons of API versions transparently. It’s easy for us to build and update tests and add custom headers and versioning so that there are no unknowns.
With dozens of API versions it’s important that we continually test their accuracy. We use Runscope for regression testing each of the versions. Runscope lets us test every point-in-time version we support and efficiently push out new versions when needed. We also know that we haven’t broken a legacy version that a certain percentage of customers are still using.
Plus, we integrate test failure alerts into Slack so we can triage API issues as they happen, and hopefully before they reach customers. Runscope covers all the bases for us as far as API monitoring goes.
As a developer, I typically don’t hear much until things go badly, so the radio silence on point-in-time versioning is kind of awesome. With Runscope, we can build tests, run them and then basically forget about it, because the less we hear from Runscope, the better. It means things are working as expected.
Today’s business landscape is becoming increasingly built on APIs. Companies in all industries not only provide APIs for their own infrastructure and front-end applications, they are also API consumers, integrating with strategic third-party APIs to supplement their services and provide the best customer experience possible. So monitoring the health of your own APIs isn’t always enough to ensure that these customer-facing applications don’t break. One broken API can cause a bad customer experience, which can in turn lead to a direct loss in revenue.
Fortunately, cloud-based API monitoring and testing tools allow you to monitor your partners’ APIs just like you do your own—Runscope works on anything that uses HTTP. Without having to write a single line of code, you can create multi-step API tests with assertions and insert dynamic data for chained requests. Plus, you can easily share request and response data with anyone outside of your team without exposing your Runscope instance, which makes debugging API issues with partners a snap.
Many companies are already seeing improved partner relationships, faster app development and greater reach by baking API monitoring and testing into their workflows.
uShip Maintains a Flourishing Partner Ecosystem
Shipping marketplace uShip reinvented the way people ship large items like boats and couches. The core of its business is a robust API that serves web, mobile and hundreds of partner integrations. In fact, the uShip API has led the company exclusively powering a shipping tab on eBay, plus partnerships with Cars.com, Penske Truck Rental and ShipStation.
At any given time, the uShip team may be working with upwards of five external partners to integrate the uShip API. If something isn’t working, the team needs to identify the problem fast so it can fix it.
“It’s crucial to our business that our API and our partners’ APIs are operating correctly,” says Troy Miller, API Product Manager at uShip. “However, our partners don’t always have insight into what they’re actually sending us versus what they think they’re sending us.”
To mitigate that issue and ensure that customers never experience a lull in service due to API issues, Miller and his team run scheduled API tests for each partner integration. When an API test fails, the team compares request and response data side by side and leverages live search to spot the issue in seconds. When the root of the problem is on the partner’s side, Miller and his team create a shareable link to send to the partner to show exactly what issue needs to be resolved.
“Since we began using Runscope, our average support time is a fraction of what it used to be. Our partners love it,” adds Miller.
MYOB Serves Customers with Powerful Integrations
MYOB, Australia’s leading accounting software provider, created a marketplace for powerful integrations to solve specific challenges of its diverse customer base. The MYOB Add-On Centre showcases more than 180 unique apps powered by hundreds of partner APIs serving 1.2 million businesses. MYOB relies on a community of developers to continuously build new integrations to maintain stickiness with customers.
In order to streamline app development and debug integration issues in minutes, MYOB’s developer evangelism team relies on API testing tools from Runscope to test any partner API for a variety of real-life scenarios.
“Testing integrations with Runscope gives instant visibility into API activity that you just can’t get with other tools,” says Keran McKenzie, API Platform Evangelist at MYOB. “Baking Runscope into our standard workflow helps us support the developer community, which in turn fuels our business and keeps our customers satisfied.”
Developers can easily create multi-step tests with assertions and insert dynamic data for chained requests, no matter the complexity of the API. By running real-time API tests against partner APIs and endpoints, MYOB went from spending hours fixing even the tiniest integration issue to just seconds.
Start Testing Your Partners’ APIs for Free
APIs are a key ingredient to flourishing partner ecosystems, whether you’re looking to build a successful app or extend your product’s reach. Developing and maintaining those integrations doesn’t have to be complicated. With Runscope API monitoring and testing tools, we give you the framework and you tell us what a successful API scenario should look like without having to write any code. Get started using Runscope for free and start testing the APIs your business relies on in just minutes.
Sometimes I wonder how quality assurance (QA) got this bad. Humanity's engineering achievements are nothing short of mind blowing. Buildings that reach the stars, tunnels bored under cities, bridges that span seas. But when it comes to software that doesn't break, quite frankly, we suck.
If you agree with me, the chances are you feel the situation is not getting any better. If you're an engineer, you probably feel like you don't test your software well enough. If you are a product manager, you likely feel like in the time it takes for you to explain how to test your software, you could have just done it yourself. If you run QA, you probably feel that people don't understand what you do or really value it, but gosh, is it hard! And as a CEO, you probably feel like your team doesn’t do enough QA because the last release had an embarrassing bug that showed up during your VC pitch.
If any of that rings true, then welcome to the club. The bottom line: QA is hard, and it is mostly because, up until now, much of the tooling out there has sucked. However, things changed drastically for us when we began relying on both API testing and UI testing solutions that are so easy to use, anyone from a developer to a business person can take them for a spin.
QA-ing Our QA Processes
Not long ago, the best QA solution was to throw people at the problem; pay an offshore outfit bags of cash to write a custom Selenium framework for your app, which unfortunately ceases to be useful the moment you discontinue the contract because, guess what? Maintaining 1,100 Selenium tests is impossible for anyone but a gang of offshore QA guys.
Two years ago, we replaced our monolith system with a microservices stack. We got into trouble pretty fast with integration issues—services at the core would change and everything else would break because of response differences and so forth. The unit tests on the core would pass, but those tests didn't cover all the ways that other services were interacting with them. As a result, sometimes the platform remained broken until someone manually tested it or another service was rebuilt. Sometimes defects went undetected for longer than you would typically like them to, making pinpointing those issues time-consuming.
We realized pretty quickly that the best people to contribute integration tests for a service are the people who depend on them—which isn’t necessarily the people who historically write the tests. We also understood that integration tests need to run constantly, not just at build time in the dev environment, but also at runtime in prod. As the platform grew and was used in ways we didn’t anticipate, defects would appear. Our users became the one mutagenic factor that the build server couldn't truly account for.
Decentralizing QA with Runscope and Ghost Inspector
This notion of democratizing the test capability started to germinate with us. We wanted to empower anyone in our company to write tests, especially the people on our team who maybe didn’t know how to code, but worked very closely with our clients. We started using Selenium and Postman, but the learning curve was too great and they lacked an easy framework for continually running and contributing to the corpus of services we have in our stack.
Once we signed up for Runscope for API testing and Ghost Inspector for browser and UI testing, they quickly bridged this gap for us. At the danger of this sounding liking a puff piece, I have to say that they are incredibly usable pieces of software that let you write functional tests and integration tests for your web app in an absolutely delightful way. I honestly love their software.
However, the victory for us though is how both Runscope and Ghost Inspector have changed the face of QA in our company. We are beginning to grow what I believe is a QA culture, in which people's feelings of dread and malaise around QA are now replaced with feelings of empowerment—even our chairman writes Ghost Inspector tests now!
Ghost Inspector is instrumental here because it allows us to observe the exact experience that a user would have visiting a site or app because of its video capability. Knowing something failed is one thing, but having a recorded video of the failure case, plus browser logs, is quite another. We also use Runscope heavily to monitor our APIs because it gives us probes that we couldn’t easily achieve in any other way.
Cutting through Complexity
When I think about what this all means to me, I'm reminded of something Kent Beck once said, something along the lines of, “Writing software without tests makes me anxious ... and I don't think software developers deserve to feel anxious about their jobs." When you boil down what we do as technologists, we try to make cool stuff that makes people’s lives better and absolutely, positively, never ever breaks. Trouble is, sometimes that last part is a whole lot more consuming than the first, and that's a bummer.
So I guess I'm here to report that QA might be easier than you think nowadays. With tools like Runscope and Ghost Inspector, you can all do it. While you are on the couch, on the way to work, in the shower (well, maybe not in the shower).
As the cloud enables companies to reach geographies that were previously unthinkable markets, businesses today see customer adoption abound wherever people have an Internet connection. However, this growth in marketplaces across the globe also presents challenges in maintaining high levels of customer satisfaction. With more people to please in more locations than ever, it can be nearly impossible for even a large company to develop the resources to monitor its services that reach customers thousands of miles away. But one unhappy user has the power to tarnish even the best app’s reputation.
Fortunately, Runscope has you covered with 12 global points of presence to test and monitor APIs. By monitoring in multiple locations, you can quickly determine whether your APIs are suffering from latency issues before your customers close your app because it’s loading too slowly or is completely unresponsive. Our locations span countries and continents—including Japan, Germany and Brazil—so that no matter where your end-users are, you’ll have a complete picture of how your API is performing.
Building Locations into Your Tests
Monitoring from multiple locations is as easy as one click and works just like any other test. Simply schedule your test to run at the frequency you need, and then select from which locations you’d like to test in the drop-down. In tests by location, response time assertions are particularly useful. For all of your tests by location and otherwise, you’ll receive a comprehensive API Performance Report in your inbox daily to show response times and success rates compared to the previous day. This way, you can stay ahead of latency issues that are too small to cause a test failure, but over time could be detrimental.
Global API Monitoring in Action
Keen IO’s business is its API, and its customers are distributed all over the world. Monitoring the Keen IO API from multiple points of presence provides direct value to customers and the business. As Cory Watson, Principal Infrastructure Engineer at Keen IO, says,
“We live and die by people’s access to our API. But I don’t hit the same infrastructure that many of our customers do when they experience problems with the API. Knowing from where a test failed is one of the most vital pieces of information we can get.”
Because Keen IO’s API is the lifeblood of its business, having full visibility into the API’s performance to stay ahead of issues that affect customers is mission critical, which includes latency issues that may occur based on a customer’s location.
In Australia, MYOB’s growing developer community builds valuable integrations that require testing in the local region. MYOB’s developers can easily test APIs in our Australia location to ensure that their integrations are production-ready.
To get a complete picture of your API’s performance, from almost every corner of the world, try Runscope free and begin monitoring globally—it’s just one click away.
This month, we are proud to celebrate two years of helping developers build better apps by giving them ultimate visibility into the health of their APIs. When Frank and I started Runscope in 2013, we set out to build tools that would solve the problems we experienced building API-driven applications. Two years later, our growing team of infrastructure and developer experience experts has built a suite of developer tools to support the modern application development lifecycle including API debugging, API monitoring and automated browser testing.
Inspired by Our Customers
We are thrilled to see more and more companies adopt Runscope to streamline the development, deployment and operation of their APIs. On behalf of the entire team, a huge thank you to our customers for pushing us to be the technology partner we strive to be and making us a vital part of your toolkit. We get to work with so many great customers. Here are a few of our favorite stories:
The de facto standard for automotive data, Edmunds.com, relies on API monitoring to ensure big-name partners like MSN and Honda are reaching end-users the right way with the right data.
Shipping giant uShip, made famous by A&E’s Shipping Wars, keeps its mobile apps, website and partner integrations with companies like eBay, running efficiently and smoothly thanks to production monitoring for continuous deployments.
Other customers are built entirely around an API, like Human API, which depends on deep API testing and debugging to save its small engineering team several hours of time and headaches.
Like us, Syncano helps developers build better apps, but via backend-as-a-service. The company depends on fully automated API monitoring and testing to ensure that its developers can easily build customer-facing, mission-critical apps.
Meeting the Needs of the Modern Developer
APIs and microservices are the lifeblood of the connected enterprise, powering applications running on multiple platforms and devices. API architects, app developers, QA teams and DevOps engineers rely on Runscope to give them confidence that API performance problems are not negatively impacting end-user experience. In-depth API monitoring and testing helps developers reduce lost revenue, bad app store reviews and customer service costs stemming from poorly performing APIs.
As Runscope has evolved to meet the needs of developers working on mission-critical services, we’ve achieved some incredible milestones:
40,000 developers in over 135 countries across the globe rely on Runscope.
Developers have used Runscope to monitor, test and debug more than 45,000 APIs; executing more than 150 million test runs from 12 locations around the world, and behind the firewall with our agent.
Our microservices architecture allows us to scale our infrastructure and our teams more quickly, facilitating an average of more than 50 deploys per workday.
More Than Just API Monitoring
API monitoring is just one aspect of a well-rounded approach to managing application performance. Late last year we acquired Ghost Inspector, an automated web UI testing service. Ghost Inspector has also seen tremendous growth in the few short months since joining Runscope:
Ghost Inspector has grown 750% since being acquired by Runscope.
An ever-expanding number of businesses rely on Ghost Inspector for automated website testing, including Anthropologie and Hint Health.
People > Product > Profit
All of this progress makes me incredibly proud. But above all that, the thing I'm most proud of is the team we've assembled. The people on our team are the smartest and most professional crew I've ever worked with. It was important to Frank and me that Runscope be a "People First" company that values work/life balance, diversity and career development. It's still early and we have a lot of work to do, but we're very happy with the results in that area so far.
Just as our product has evolved and expanded over the past two years, we are committed to creating the best application performance tools to help developers at big and small companies everywhere to build better apps and better businesses. If you're also excited about helping developers be more successful, we’d love for you to join us.
It's been a great ride so far, but we're just getting started! Thank you for being a part of it.
Feeling nostalgic? Check out how we’ve evolved over the years in our one-year anniversary and 2014 year in review posts, and read our full announcement. And if you haven't yet, be sure to sign up for your free Runscope and Ghost Inspector accounts.