Forem: Eternalight Infotech

How a Bad Push Crashed the Cloud Systems Outage:From One Region to Worldwide

Ayushi Shrivastava — Tue, 28 Oct 2025 13:53:06 +0000

In a cloud environment, professionals plan and release updates to speed up processes and adopt best-in-class practices. Most of the time, it goes well, but once in a blue moon, a bad push turns into a disaster, bringing the systems to a halt.

On Monday, 20 October, AWS experienced a worldwide cloud outage that affected many apps, websites, and social media platforms. Initially, no one had expected it to turn into a global cloud outage, but soon users began reporting issues on Twitter.

Soon, it was confirmed that the single-point failure in the US-East region had reached a significant threshold.

Give this blog post a read to learn in depth about how to recover from a cloud outage, ensuring the app remains available.

How a Routine AWS Update Triggered a Global Cloud Outage?

Initially, AWS identified the root cause of the DNS disturbance affecting the AWS DynamoDB endpoint and resolved it within 3 hours. However, EC2 subsequently crashed, which is responsible for creating virtual servers.

This EC2 function is integrated with DynamoDB, but after the database was lost, the EC2 stopped working. Later, the load balancer service was disrupted, causing network issues.

When these three core services stopped responding, AWS services suddenly experienced a chain of failures and crashes.

Lambda, CloudWatch, SQS, and 75+ other services were affected by this outage. Now you can understand how massive it is.

Because servers lost communication, everything just paused for 15+ hours, and that's an unbearable situation. Nowadays, when everything is moving to the cloud and everything is accessible, this pause was hard to swallow.

All the services were mapped and integrated, thus requests piled up and crashed in the queue, so it took a whole day to get back on track.

Now, many news sites are circulating a headline that cloud outage can happen again so it's better to be proactive and have a plan to prevent the issues.

They confirmed that the problem started with DynamoDB, but the twist is even more foolish. What's happening inside AWS is that they're just completing their weekly testing, so they pushed the update, but it went wrong—a bad one that crashed the database and took down all the web apps and sites, leaving them in a non-working state.

Let's jump into learning more about how to detect cloud outage and fix it, and how to ensure the application's availability.

How to Discover the AWS Services Outage?

If you encounter an unexpected failure when accessing any application or website, the app may be crashing and unavailable at the moment due to an uninstalled update. But in another way, the problem could be related to the cloud, which is causing the app or website to fail to load.

Let's detect what may trouble here causing global cloud outage:

Increase in Service Response Time

If you're experiencing delays accessing any AWS app or service that's taking longer than usual, and this issue persists for an hour, it may be due to an outage, a failed request, or a delayed response.

AWS Dashboard Reflects the Service's Health

Visit the official source to identify the scope and root of the issues affecting the applications.
Navigate to the AWS service health dashboard, which provides a comprehensive view of the latest updates on AWS services.

Social Media Updates

Whenever such incidents occur, the relevant authority issues a circular on the official pages of major social media platforms so everyone can understand what has happened.

Use third-party support services and tools if other users have reported the same problems. Stay calm, you're not the one.

Cascading Effect Creates Disturbance

If it's a cascading effect, it must disrupt other connected services across all regions, even if the app operates normally by default. Still, the DNS server or a related component encounters unpredictable issues.

Let's jump into the cloud outage recovery tactics to save from the upcoming disaster.

5 Ways to Recover from an Outage or Cloud Disaster

Outages are one of the most annoying things, just like headaches. After these mishaps, restoring the system's availability is a hectic task. Cloud service providers use the following tactics to recover from outages.

AWS Route 53, elastic load balancing, or other failover mechanisms can automatically redirect you to a safer space to manage the traffic and availability.
All cloud service providers offer disaster recovery strategies and plans. So follow their user manual or books to deal with such circumstances.
Manual failover mechanisms are good, but don't forget to utilize the automated failover mechanism provided by default troubleshooting, which boosts uptime through Recovery Time Objectives and Recovery Point Objectives.
Lastly, if all the core AWS services are affected by this outage, nothing we have mentioned above will fix the situation. Backstep and wait for the official AWS announcement confirming that everything is under control and restored.
Don’t forget to perform sanity checking after the cloud outage is over.

How to Ensure Application Availability During a Cloud Outage?

Outages are unpredictable; to reduce downtime and ensure reliability and resiliency, you must know your approach. Let's get to know how to make system outage proof so you don’t need to face it again, like the recent AWS worldwide outage.

Single Server Reliance isn’t Enough

Reduce reliance on a single region server to improve resiliency. Build the architecture to operate applications across multiple AWS regions.

Mapping Hybrid or Multicloud Service Providers

Whether you're a mid-sized, large, enterprise, or startup, to keep your application operating hassle-free even during outages, consider on-premises support and accessibility from other established cloud service providers.

If services are well mapped and connected across AWS and other providers, it will reduce the risk of a single failure or vendor lock-in.

Perform Automated Failovers for Quick Recovery

You can also tailor automated failovers beyond AWS, assuming both worst-case and best-case scenarios. Define them, align them with your specific needs, and periodically refine and test your tactics.

Practicing with RTO, RPO, and DR policies enabled us to survive these cloud disasters.

Offline Mode and Local Caching

Whether it's primary or secondary services, data is a critical asset that can't be neglected. To ensure the application remains available and active in all scenarios, consider adopting local caching or offline functionality so that some applications can continue to function even when offline.

Reattempt Unfulfilled Requests

During the recovery process, not all services are fully restored or active, and some may also fail. So, it would be best to retry the failed requests or use fallback mechanisms to get the services back up and running.

Revisit Service Agreements/ Contract

While accessing any service from AWS or any other cloud service provider. Go through the offerings and support clauses.

How will they provide support in the event of an outage, recovery, process interruption, or escalation?

How will they ensure all components are available?

It's a wrap now!

One thing to say here!
Disasters are common, but what matters is how we deal with it, making our system resilient for the future. Be innovative and proactive, refine the recovery plan to proactively deal with the outage, and stay ahead of the competitors.

Final Words:

Cloud Outages often irritate us, no matter how hard we try to make the architecture perfect. Whether it is for short term or long term outage that causes disruption, keeping the system still. To improve the uptime, having the right strategy and a proactive automated recovery plan is worth it.

At Eternalight Infotech, we build cloud-based solutions that automate and consult our clients on best-in-class recovery plans to fix cloud outages, keeping applications available 24 hours a day.

The Maze of Flaky Tests isn’t Less than the Nightmares: Cypress Turns Regression into Robust Product with Confidence

Ayushi Shrivastava — Mon, 06 Oct 2025 11:42:00 +0000

The Struggle is Real to solve the manual maze regression and debug the flaky results. Cypress not only resolves headaches but also helps you understand the pain point.

Have you ever been stuck in a regression of testing the app that is scheduled to release within a few days?

Whenever you try to resolve the flaky issues, a new feature or functionality gets disturbed, and the loop continues.

You’re just waiting for that one moment, that one miracle, that the app has no issues, all bugs are fixed, and it's ready to ship, and all your restless nights and hours of regression paid off.

“According to statistics, every minute spent on debugging concurrent requests through manual testing results in a 15% loss in customer engagement.”

Well, you’re not alone in struggling with the situation; software development teams often go through these chaotic cycles, marked by regrets and regression testing, involving manual bug fixes and updates.
The only goal is to ship a brilliant bug-free product. If any bug slips through undetected and the product is released to end-users, it's a crash. It will put the business's reputation under scrutiny.

The development team appointed to deploy an app needs to be both cautious and confident in the practices employed in the development environment.

Get out of this loop now!

Launch Cypress now. It is like a hidden engine integrated into pipelines, preventing crises in the real world. It helps the development team catch bugs and bottlenecks, reducing regressions and test cycles.

Discovering in this blog story in-depth, how it’s transforming the test case workflows, infusing reliability and stability.

Let's Explore Real-world Scenarios that Seem Like a Headache!

Scenario 1: Assume that we are building an app for the e-commerce industry. It contains all the following functionalities: a user login page, profile, history, payment integration, and other features.

Now we need to test if everything synced and is responding according to plan.

If a developer chooses to do it manually, it will take time to detect the bugs or test failures.

Imagine accessing a payment gateway that fails to validate customer credentials, interrupting the login process.

Alternatively, if the user is about to purchase a product, service, or subscription, but the checkout button gets stuck. The user will become frustrated with these false flows and interactions.

Scenario 2:The development team is testing the UI/UX flow functionality to validate the user's KYC. It can throw errors like the following:

The user can’t create the account due to ID rejection.
While the developer is fixing that functionality, it may take longer to respond.

These are not just headaches; it’s a business debt. Cypress ensures the functionality path is reliable by mocking the API, saving development time and maintaining trust across users.

The complaints are endless, and when you initially check, it may seem very small, but it's enough to give a reason why customers will ditch the app.

As humans, QAs can miss the problematic spot or may get frustrated when they need to repeat test journeys.

In that state of frustration, they push the app to market launch. Ultimately, customers will report the bugs. In that case, the developer’s confidence will drop.

How does Cypress Automation Push Up the App Release?

If the app exhibits any unexpected behavior or lags while accessing a feature, users may consider uninstalling the app or switching to alternative, competitor app options. With Cypress, the problem is resolved.

In a conventional QA cycle, the development team must start from scratch every time they fix a bug. It requires a lot of rework, delaying the timelines. If we integrate Cypress, it eliminates the need for human intervention with every tap. It is programmed to tackle all issues automatically, breaking the loop of repetitive taps to validate the interactions.

Cypress is worth it:

Uninterrupted feature tracing covering all test journeys
Flags the failures/ critical issues in real-time
There is no need to perform a manual fix and validate every flow and interaction.

It's the collaborative effort of the developer and QA professional to build an intuitive, interactive, and responsive experience for every action within the production phase, before it is shipped to the end user. With Cypress, it is easy to speed up app launch.

Cypress: An All-Rounder Tool for Modern World Quality Analyst

Cypress is a JavaScript-based 360-degree testing tool to automate the work QA does in the development ecosystem. A developer's tech stack is incomplete without this tool. It quantifies the racks in minutes and escalates the quality of the app.

We can indeed manage the testing manually, but testing 100+ functionalities repeatedly isn’t realistic. Cypress is a robust and reliable testing framework relevant to the next generation of bug-free application execution.

It is the preferred choice for automation experts, managing end-to-end (E2E) testing. Abstracts the layers of automation for successful cross-browser testing and continuous integration/ development.

Suppose any app takes 10 hours to resolve flaky false tests, maintain Selenium Scripts, address server delay time, and conduct manual testing.
In that case, Cypress will save them from wasting their precious time and efforts, allowing them to focus on another project.

Cypress shreds off the load of QAs, completing the functionality testing in minutes. You may have heard about Selenium and Playwright, but Cypress surpasses them all with its unique set of capabilities.

If you haven't integrated Cypress yet at your workplace, it's an enormous technical debt that multiplies with every repeated sprint. Get out of FOMO by integrating Cypress into your system.

Why Developers and QA Trust in Cypress over Selenium?

To evaluate the potential bugs, false failures, or problematic scenarios, developers widely integrate Selenium in their systems. However, it also encounters the challenges:

Flaky tests because of manual wait and time intervals
Complex setup configurations
An extended server response time slows down the text execution

Cypress is a comparatively better automation tool for eliminating bugs and providing developers with relief from the endless test cycle loop, offering proper visibility of errors and suggestions for fixes.

It is developer-friendly.
Offers the visual representation of each test and bug
Integrate well in agile and DevOps development sprints
Improve user experience and product market release.

Only a single sprint doesn't validate that the app is perfect to release. The developer and QA need to perform multiple sprints multiple times. Manual testing extends the release time as the team spends hours on fixing false failures.

Customers don’t like a troubled app; they want a seamless onboarding experience and smooth interaction with each tap wherever they the interface.

In case the login failed, the checkout button doesn’t respond, or the test script is flaky.

Rather than a technical bug, it wastes a complete sprint time, impacts revenue, and disappoints customers.

That’s where Cypress enters and transforms the real picture. Not just an automation weapon, but the answer to all the problems developers have been waiting for.

How Does Cypress Work Under the Hood?

To make the Cypress drive in action, the secret lies in its architectural engine. It utilizes the GUI or Test Runner, the Cypress Server, and the browser to test the app behavior.

Comprehensive GUI View
GUI enables accessibility to interact with test journeys and results that can be viewed in a parallel browser, improving the efficiency of the test suite.

Backend: Node.js Server
The backend server of Cypress utilizes a dual-server architecture to synchronize the interaction between the test runner and the browser. Both run efficiently, managing the process in parallel with Node.js.

Browser
It displays the actual test execution runs, accessing the Cypress Protocol, which allows control over the browser, DOM, and network requests/responses.

Capabilities of Cypress that Impress Developers

- Code and Configure with the Universal JS Stack
Nowadays, React, Angular, and Vue are worth launching dynamic solutions. These JavaScript-based frameworks are the developers' first preference in the modern world, and Cypress itself is built in JavaScript.

- Intuitive and Interactive Framework
Beyond control and convenience, it is designed to address the pain points of development enthusiasts, saving hours on manual test runs and driving efficiency, reliability, and quality as an exceptional weapon.

- Debug Effortlessly
Automatic bugs and bottlenecks diagnosis, and built-in troubleshooting tools accessibility. QAs can watch what’s happening through visual representation, push the correct codes on the spot, and rerun tests.

It's exhausting to switch on different tech stacks for styling, scripting, and configuring functionality. Thus, if any developer isn’t involved in the process from the start, it would be difficult to steer the ship confidently.

Now that we have understood the Cypress engine, let’s explore its features.

Features of Cypress: What Makes this Test Automation Tool Stand Out?

QAs can adapt this modern world testing framework to eliminate inefficiencies and shorten the market release time, utilizing its capabilities. Let's go through the dashboard features, grab the dev team's attention one by one:

Resume in Realtime Without the Need to Reload

Cypress resume from the point you tracked and tweak out the piece from Cypress. Access the capabilities and receive the feedback from the built-in system, and process confidently.

Automated Wait Intervals

Humans tend to know how long they need to wait, as long as the activities are still in progress or have been completed. Cypress just flipped the script, and it's intelligent enough to tackle the wait durations for the time elements loading.

Check Test Runs in Browser

You can take snapshots of tests from the browsers; these are clickable and serve as a reference in the event of troubleshooting.

Understand Errors in-depth

No need to feel miserable, you can get the status in real-time with a description. The error messages provide a detailed description of the root cause and indicate the specific changes made. QAs can easily track and read the logs from the stack.

Responsive in Poor Network Conditions

No need to stress your head if the network is not stable. Cypress lets you mock, stub, and secure API calls even when the network is slower. Backend services are interrupted, but it’s still possible to test the app's functionalities.

If you're tired of flaky code and repetitive manual test cycles, why don’t you launch Cypress? Within a few minutes, you’re ready to test the app's quality and identify inefficiencies hidden across 100s of functionalities.

Read this step-by-step guide from Cypress to launch Cypress, resolve the app complications, and optimize for the best quality.

Knowing only the installation process isn’t enough; you also need to be familiar with the proper practices to fight the endless battle like a pro. Many have applied them to skim and ship faster.

9 Best Cypress Practices to Perform Debugging for the Dev Team

While preparing for app testing with the Cypress automation tool, optimize the CI/CD pipeline to minimize technical issues and manage test write-ups and journeys efficiently and independently. Don’t miss these practices that QAs prefer within the dev ecosystem.

Practice # 1: Concise and Feature-specific Tests

Tests with lengthy scripts or those that have extensive durations seem overwhelmed. Write one for a single feature or functionality journey. It gives them sufficient time to fix the failures without getting exhausted, and they can be identified promptly.

describe('Login Feature', () => {
  it('should log in with valid credentials', () => {
    cy.visit('/login')
    cy.get('#username').type('admin')
    cy.get('#password').type('password123')
    cy.get('button[type=submit]').click()
    cy.contains('Welcome, admin').should('be.visible')
  })
})

Practice # 2: Specific test names

If the intent is clearly defined with the test name. It will reduce the chances of redundancy and confusion, makes easy to understand, and be remembered for future QA tasks.

describe('User Profile Update', () => {
  it('should allow user to update profile picture', () => {
    // clear test intent is defined
    cy.visit('/profile')
    cy.get('input[type=file]').attachFile('profile.png')
    cy.contains('Profile updated successfully').should('be.visible')
  })
})

Practice # 3: Feature a Clear Folder Structure

Create independent folders to organize all: features, functionalities, user stories, and test journeys files. Having organized in the proper structure, it will resolve all the tension.

// Suggested structure
cypress/
  e2e/
    auth/
      login.cy.js
      register.cy.js
    cart/
      add_to_cart.cy.js
      checkout.cy.js

Practice # 4: Maintain Consistency using Fixtures

It's worth using Fixtures to deal with a wide array of scenarios for the startup. Whenever we need to test the journeys, the database data is automatically downloaded at startup and can be easily cleaned after the test cycles are completed.

// cypress/fixtures/user.json
{
  "username": "testUser",
  "password": "securePass"
}

// cypress/e2e/login.cy.js
describe('Login with Fixtures', () => {
  it('logs in using fixture data', () => {
    cy.fixture('user').then((user) => {
      cy.visit('/login')
      cy.get('#username').type(user.username)
      cy.get('#password').type(user.password)
      cy.get('button[type=submit]').click()
      cy.contains('Dashboard').should('be.visible')
    })
  })
})

Practice # 5: Manage Initial and End Hook Setup

Define every task cycle with a distinct hook setup to isolate and prevent interruptions. Using beforeEach() and afterEach() at every setup and cleanup of the task will make things clear.

describe('Hooks Example', () => {
  beforeEach(() => {
    cy.visit('/login')
  })

  it('logs in successfully', () => {
    cy.get('#username').type('admin')
    cy.get('#password').type('password')
    cy.get('button[type=submit]').click()
    cy.contains('Dashboard').should('be.visible')
  })

  afterEach(() => {
    cy.clearCookies()
    cy.clearLocalStorage()
  })
})

Practice # 6: Improve Readability using Commands

You know the test cycles/ tasks are repetitive; this sometimes creates a mess or a conflicting situation. To improve the clarity and readability, simplify things using custom commands.

// cypress/support/commands.js
Cypress.Commands.add('login', (username, password) => {
  cy.get('#username').type(username)
  cy.get('#password').type(password)
  cy.get('button[type=submit]').click()
})

// usage
describe('Login Tests', () => {
  it('logs in with valid credentials', () => {
    cy.visit('/login')
    cy.login('admin', 'password')
    cy.contains('Dashboard').should('be.visible')
  })
})

Practice # 7: Keep the Count Low of Assertions

Be wise when using assertions to validate app behaviors. If you apply too many assertions, it will become difficult to trace the root cause of the failure encountered.

describe('Product Page', () => {
  it('should load product details', () => {
    cy.visit('/product/1')
    // Keep only essential assertions
    cy.get('.product-title').should('be.visible')
    cy.get('.price').should('contain', '$')
  })
})

Practice # 8: Dashboard Accessibility

Take a glance at every test journey and track its results through the Cypress Dashboard. Be aware of what and when failures occur so that you can address them promptly.

// Run this to view tests in Dashboard mode
npx cypress run --record --key <your-cypress-dashboard-key>

Practice # 9: Adapt the Rule of Continuous Integration

Automate the testing process, prioritizing continuous integration. Ensure that everything is in sync and processing without skipping any functionality. If any complications are encountered, they can be captured in this phase before pushing it up for launch.

We’ve reached the endpoint, and the thought is clear: Cypress is not another tool; it's a productivity booster for the dev team.

How do we leverage AI to build Cypress Automation for our customers?

At Eternalight, we’re working on a “LinkedIn” type of job hunting platform that has 100s of functionalities. To validate them one by one was difficult.

Therefore, we have integrated Cypress to eliminate bugs. It traced all folders with a single tap and ensured everything is good to go. It has truly saved hours on repetitive regression tasks.

Final Words:

From the sleepless nights of debugging to innovative product launches, Cypress brings the confidence and smile back on the developer's face. No more guessing: integrate Cypress with the app product to determine the exact cause of why the application behaves in specific scenarios. Why is the functionality not responding as you planned?

Get control of application behaviour with one click and make the application flake-free. For resources, you can access the Cypress documentation , which will give you clarity.

At Eternalight Infotech, we’re accessing its real-time debugging and testing capabilities to test our client application. Resolving industry-specific Challenges with AI Solutions to deliver apps faster and troubleshoot glitches more efficiently.