
Infrastructure as Code (IaC) has transformed the way we build and manage cloud environments. Instead of clicking through a cloud console, we define infrastructure in code and let automation handle the rest.


One of the most important concepts to understand in **Terraform** is its lifecycle:


**Write → Init → Plan → Apply → Destroy**


In this blog, we’ll break down each stage clearly with examples so you can confidently use Terraform in real-world projects.


# What is Terraform?


Terraform is an Infrastructure as Code (IaC) tool created by HashiCorp. It allows you to define, provision, and manage infrastructure using declarative configuration files written in HCL (HashiCorp Configuration Language).


Terraform works with cloud providers like:

- Amazon Web Services
- Microsoft Azure
- Google Cloud Platform

Now let’s understand how the lifecycle works.


# Step 1: Write (Define Infrastructure)


Everything starts with writing configuration files.


Terraform configurations are written in `.tf` files using HCL.


Example:


```plain text
provider "aws" {
  region = "us-east-1"
}

resource "aws_instance" "web" {
  ami           = "ami-123456"
  instance_type = "t2.micro"
}
```


Here, we are declaring:

- A provider (AWS)
- A resource (EC2 instance)

This defines the **desired state** of infrastructure.


Important:


You are not writing steps. You are describing the final state.


# Step 2: Init (`terraform init`)


Before Terraform can create anything, it must initialize the working directory.


Run:


```plain text
terraform init
```


### What happens during init?

- Downloads required provider plugins
- Initializes backend (state configuration)
- Prepares modules
- Sets up the working directory

Think of `init` as: “Prepare Terraform to work with this project.”


You only need to run this once per project (or after adding new providers/modules).


# Step 3: Plan (`terraform plan`)


Now comes the most important safety step.


Run:


```plain text
terraform plan
```


Terraform compares:

- **Desired state** (your `.tf` files)
- **Current state** (terraform.tfstate or real infrastructure)

It then generates an **execution plan** showing what will change.


### Plan Output Symbols


Example output:


```plain text
+ aws_instance.web
```


Meaning: Terraform will create a new EC2 instance.


Important:

- `plan` does NOT change anything.
- It is a preview step.
- Always review the plan before applying.

# Step 4: Apply (`terraform apply`)


Once you are satisfied with the plan, run:


```plain text
terraform apply
```


Terraform will:

- Create resources
- Modify resources
- Delete resources
- Handle dependencies automatically
- Update the state file

After confirmation, Terraform calls the provider APIs and provisions infrastructure.


At this stage:

- Infrastructure is live
- State file is updated
- Desired state = Actual state

# Step 5: State Management


Terraform keeps track of infrastructure using a **state file**:


```plain text
terraform.tfstate
```


The state file:

- Maps configuration to real-world resources
- Stores resource IDs
- Tracks dependencies
- Enables drift detection
- Ensures idempotency

Without state, Terraform wouldn’t know what it created.


In team environments, state is usually stored remotely (e.g., Terraform Cloud or S3 backend) to prevent conflicts.


# Step 6: Destroy (`terraform destroy`)


When you no longer need the infrastructure, run:


```plain text
terraform destroy
```


Terraform will:

- Generate a destroy plan
- Delete all managed resources
- Clean up infrastructure

Common use cases:

- Cleaning up test environments
- Cost control
- Temporary demo environments

Warning:


Always double-check before running destroy in production.


# The Complete Terraform Lifecycle


Here’s the simplified workflow:


```plain text
Write → Init → Plan → Apply → Manage → Destroy
```


Or in command form:


```plain text
terraform init
terraform plan
terraform apply
terraform destroy
```


# Why This Lifecycle Matters


Understanding the lifecycle helps you:

- Avoid accidental infrastructure changes
- Detect errors early
- Prevent configuration drift
- Work safely in teams
- Integrate Terraform into CI/CD pipelines
- Follow DevOps best practices

Each step exists for a reason:

- **Init** prepares
- **Plan** previews
- **Apply** executes
- **Destroy** cleans up

Skipping steps can lead to serious production issues.


# Real-World Example Flow


Imagine deploying a web application:

1. Write configuration for: VPC, Subnets, EC2, Load Balancer
2. Run `terraform init`
3. Run `terraform plan`
4. Review changes
5. Run `terraform apply`
6. Application goes live
7. After demo → `terraform destroy`

The lifecycle makes Terraform safe and predictable for managing infrastructure. By following these steps, teams can automate deployments, prevent errors, and maintain consistent cloud environments with confidence.



Terraform Lifecycle Explained


As modern applications increasingly adopt event-driven architectures, the line between application logic and database behavior has blurred. Supabase, built on PostgreSQL, provides developers with powerful tools to implement reactive workflows directly at the database layer through triggers. In this post, we’ll explore how to design, implement, and maintain database triggers in Supabase, providing real-world use cases, technical insights, and best practices.


![image.png](https://prod-files-secure.s3.us-west-2.amazonaws.com/655b33b3-36d2-8121-828f-0003e6db7868/b3f66456-e82f-4af7-8a4a-515de04c872f/image.png?X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Content-Sha256=UNSIGNED-PAYLOAD&X-Amz-Credential=ASIAZI2LB4663LZGRVFX%2F20260301%2Fus-west-2%2Fs3%2Faws4_request&X-Amz-Date=20260301T082053Z&X-Amz-Expires=3600&X-Amz-Security-Token=IQoJb3JpZ2luX2VjEJv%2F%2F%2F%2F%2F%2F%2F%2F%2F%2FwEaCXVzLXdlc3QtMiJIMEYCIQDDV%2FZVXKVVItcSPbay37lvYyCRH%2BGqRGiUSi7KVeH%2FNQIhAOrcFUgCgBEx1xqgOY2XWlrUMOf3C54xtrFtKubD8qP1Kv8DCGQQABoMNjM3NDIzMTgzODA1IgycJqGnjZFPnuumdUUq3AMdUg4v2ktlen4oM%2BQENDrXvutRwYTh8JMUIX%2BzgNoKgsK0XuKnvW3T2IBvyCQRbrHfoDFi7D3097Kuzbry5Xv%2FGYYzpG%2FeuTAtYD%2BN0PaOGklfPhgG%2BuuPGsrw03vOdvlOpk2rtvO7SzF7aPDl2A0KcUmNsluaJzWjy%2FYyBaDMBBkXVQUtn0u3b4LmqWU%2B95piFv5tpXm4po1FH9N22gVoaDX3nd%2BKLaqE%2BddqHR0Hy5akmqH5eNB1oGeD4JHupkhX6wEB1zGXYkNE9Ky%2Bmm9XLLnd%2Btv%2BkzqJ3q%2FuhKM378fzt8U0%2BuHNXFb8TTybVHnOghhbY4S%2FiHHSr9m8VzMCPxP5eHsvrEFEcP6cby3CVuXIeAU76rTo3k6AAKUSEU4L3NVTJQPVL0h%2BFe9jrCqiR8aFbSOQHLfWwvIBMEwjrmxEqZybUMee1LMZs%2BoGJVgJmynu6Eq5PEYj0ErJuvTr%2BgXKQQVRq7vSeIBo7K66502Ek%2Fo6lRgwsk%2FldCcJXCh0XFbcF20Zo7IBYN%2Fl3G32wMH8jVW0gGaP2BLI2v%2B%2F%2Fyxl3W7JogzwAqp7keQIVR67IdllPTZHa17HnAxQc3vxP%2BIhtjv8T5j5sAKKVLEVD8i6VihDR%2BM5YxnYOzDE0I7NBjqkAYYY5%2Be3IuXy%2F1q1M8fGes4nWD774qWnSQnYoNn%2FBJddLvTF3h6gKx3gn98YBC9pcBfkS7hyB5d7%2Ba%2Fuc4aGcsSiMsbRgYuzCHfnT2ZVw0IJDLsdFwvHWQCFv4bqr8Pyvs4eCl5hmkzGshLvsmH%2Bx2z7F0gH2WE71qQAKDkDyCs95FJzIPD25vQ%2BY6swjAtlHUrwtqTjGQMocobEcLDmeHwGsrqv&X-Amz-Signature=d0cc79db8ec19d517eea45755c411d359ed6ce9f6b9de309abdc3aa860f9cc33&X-Amz-SignedHeaders=host&x-amz-checksum-mode=ENABLED&x-id=GetObject)


## Understanding Database Triggers in Supabase


At its core, a trigger is a procedural code snippet that automatically executes in response to specific changes in a table `INSERT`, `UPDATE`, `DELETE`, or even `TRUNCATE`. In Supabase, triggers are implemented using PostgreSQL's native capabilities, giving developers access to a robust, reliable mechanism for reactive behavior.


Triggers are particularly useful in scenarios such as:

- Enforcing complex business rules that span multiple tables
- Maintaining audit logs without polluting application logic
- Synchronizing data between tables or external services
- Supporting real-time notifications via Supabase's Real-time engine

By moving certain logic to the database, we reduce round trips between the application and the database, improving performance and consistency.


## Anatomy of a PostgreSQL Trigger


A trigger in PostgreSQL requires two components:

1. **Trigger Function (Procedure):** The actual code executed when the trigger fires.
2. **Trigger Definition:** Specifies the timing (`BEFORE` or `AFTER`) and the event (`INSERT`, `UPDATE`, `DELETE`) that fires the function.

For example, consider a scenario where we want to automatically update a `last_modified` timestamp whenever a row in the `projects` table is updated:


```sql
-- Trigger function
CREATE OR REPLACE FUNCTION update_last_modified()
RETURNS TRIGGER AS $$
BEGIN
  NEW.last_modified = NOW();
  RETURN NEW;
END;
$$ LANGUAGE plpgsql;

-- Trigger definition
CREATE TRIGGER set_last_modified
BEFORE UPDATE ON projects
FOR EACH ROW
EXECUTE FUNCTION update_last_modified();
```


Here, the `update_last_modified` function ensures consistency across updates without requiring application-side enforcement.


## Use Case: Audit Logging


Maintaining an audit trail is a common requirement. Let’s track every change to the `users` table:


```sql
-- Audit log table
CREATE TABLE user_audit_log (
    id BIGSERIAL PRIMARY KEY,
    user_id UUID,
    operation TEXT,
    changed_data JSONB,
    changed_at TIMESTAMPTZ DEFAULT NOW()
);

-- Trigger function
CREATE OR REPLACE FUNCTION log_user_changes()
RETURNS TRIGGER AS $$
BEGIN
  INSERT INTO user_audit_log(user_id, operation, changed_data)
  VALUES (
    NEW.id,
    TG_OP,
    to_jsonb(NEW)
  );
  RETURN NEW;
END;
$$ LANGUAGE plpgsql;

-- Trigger
CREATE TRIGGER user_audit_trigger
AFTER INSERT OR UPDATE OR DELETE ON users
FOR EACH ROW
EXECUTE FUNCTION log_user_changes();
```


With this approach:

- `TG_OP` automatically provides the operation type (`INSERT`, `UPDATE`, `DELETE`).
- `to_jsonb(NEW)` captures the full state of the row after modification.

This ensures every change is traceable while remaining fully automated in the database layer.


## Integrating Triggers with Supabase Real-time


Supabase provides a Real-time engine that allows applications to subscribe to database changes. When combined with triggers, this enables robust, event-driven workflows.


For example, suppose we want to notify an admin whenever a new project is created:


```sql
CREATE OR REPLACE FUNCTION notify_new_project()
RETURNS TRIGGER AS $$
BEGIN
  PERFORM pg_notify('projects_channel', row_to_json(NEW)::text);
  RETURN NEW;
END;
$$ LANGUAGE plpgsql;

CREATE TRIGGER project_created
AFTER INSERT ON projects
FOR EACH ROW
EXECUTE FUNCTION notify_new_project();
```


On the frontend, you can listen for these notifications:


```javascript
import { createClient } from '@supabase/supabase-js';

const supabase = createClient(SUPABASE_URL, SUPABASE_KEY);

supabase
  .channel('projects_channel')
  .on('postgres_changes', { event: 'INSERT', schema: 'public', table: 'projects' }, (payload) => {
    console.log('New project created:', payload);
  })
  .subscribe();
```


This pattern enables real-time dashboards, automatic email notifications, or triggers that update caches without adding extra complexity to your application code.


## Best Practices for Triggers in Supabase

1. **Prefer** **`AFTER`** **triggers for notifications and external side effects**

    `BEFORE` triggers are better suited for validation or data normalization.

2. **Minimize complex logic in triggers**

    Triggers should be fast; avoid heavy computations or network calls inside the function.

3. **Use** **`FOR EACH ROW`** **vs** **`FOR EACH STATEMENT`** **wisely**

    `FOR EACH ROW` triggers fire for every affected row. `FOR EACH STATEMENT` is suitable for bulk operations like logging counts or batch metrics.

4. **Monitor and debug**

    Use `RAISE NOTICE` or temporary logging tables to inspect trigger behavior during development.

5. **Maintain idempotency**

    Ensure that re-running triggers due to retries or replication does not create inconsistent states.

6. **Version your triggers**

    Use `CREATE OR REPLACE FUNCTION` carefully, and consider migrations to manage trigger changes in a team environment.


## Debugging Triggers


Triggers can silently fail if not implemented correctly. Techniques for debugging include:

- **RAISE statements:** Print debug info directly in PostgreSQL logs:

```sql
RAISE NOTICE 'Trigger fired on ID: %', NEW.id;
```

- **Temporary logging tables:** Capture payloads for analysis:

```sql
INSERT INTO trigger_debug_log(payload) VALUES (row_to_json(NEW));
```

- **Test in isolation:** Execute the trigger function directly with sample data using `SELECT function_name(ROW(...))` before attaching it to production tables.

## Conclusion


Database triggers in Supabase are a powerful tool for building reactive, event-driven applications without over-complicating your backend code. By leveraging PostgreSQL’s rich trigger system, developers can enforce business logic, maintain audit trails, and enable real-time notifications efficiently and reliably.


When used judiciously, triggers reduce repetitive logic in your application, improve consistency, and empower developers to design more scalable, maintainable systems. As Supabase continues to evolve, combining triggers with its Real-time engine and edge functions opens exciting possibilities for truly serverless, event-driven architectures.



Creating and Using Database Triggers in Supabase


In the world of Node.js development, it’s common to juggle multiple versions of Node across different projects. Using a single global Node installation can lead to version conflicts, dependency issues, or surprises in production. That’s where **NVM (Node Version Manager)** shines: it enables you to install, switch, and manage multiple Node.js versions side by side on the same machine.



![https___dev-to-uploads.s3.amazonaws.com_uploads_articles_tns0q1sn1n531uk9e8mt.webp](https://prod-files-secure.s3.us-west-2.amazonaws.com/655b33b3-36d2-8121-828f-0003e6db7868/5b95a022-33d5-40c3-869f-ff4584d211f9/https___dev-to-uploads.s3.amazonaws.com_uploads_articles_tns0q1sn1n531uk9e8mt.webp?X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Content-Sha256=UNSIGNED-PAYLOAD&X-Amz-Credential=ASIAZI2LB466ZS7CTP2G%2F20260301%2Fus-west-2%2Fs3%2Faws4_request&X-Amz-Date=20260301T082053Z&X-Amz-Expires=3600&X-Amz-Security-Token=IQoJb3JpZ2luX2VjEJv%2F%2F%2F%2F%2F%2F%2F%2F%2F%2FwEaCXVzLXdlc3QtMiJGMEQCIFqg%2FhKQLpcjLe69Hrp7T5WzF1xbe72vcvPSDepOmS1%2BAiAeTV2B08LYyC0uzmXkYkxwf3aMxylGKCnDn%2BhBHyKLqyr%2FAwhkEAAaDDYzNzQyMzE4MzgwNSIMHo92iME29dgBefqwKtwDbvKiKho2kLL2PsuvTIetqxaSjn6nzbKkqyiRAs%2F1cCEaRvcZ0D1%2BdKXBf%2FKqjeAF5BlATpsq%2BqSk1K6EsSS8O4fd6WIFDD5f847XIjZ8r3yaziDijo%2Bf0CqmyvNqyEql46xFQw7fr8f3hbCRxkelGMJ8IiFnipLsk2iunD%2Fki%2FelIoEjwQsl0PbkSbjejxhiJ5kXR4TWflVq6lhN%2B0qyE2FqmFE8OO5J109Gj9EK2zvggAkHXho2tu0lmYYLjDuOd5VezjLJvuHczUKyKUCqoHDlJGVhPF3MC0SbpJKJSZOjl3mJfwO9cMisNOjUqHnjEvg%2BMGGmgXMHxidcttVFt2pRYdXMoimrTqG0FxSwhZzLJYpglH%2Bu27LnFUADjb20149rUeswVPfdlN2CTbj7EX458pmX2hexT3j41rodzE5kgECdi%2B1hBHBxK0Q4iEnqwmiFFLX69xnasDc67Rpz%2B4CpekWoNRWYCdOc3ZVgWAHiqotR8GlLbgj2IomHCyK72LY2btWhcel7wQlIJNjxL5HcYI0lIufPepU%2FJeLr2sUIe8llQma8HmFBrFH8Z0I0WoeieO2Z1oiYM1LDW3wG4jTbnngIoURIUYCl7FNcJa5bKBpzEnmM3iFrQzwww9COzQY6pgGs8MD576dJQ48bDuA4tQreAZPTpHpNH4MUPLAqpUKzf6drQDOeEft0KYqDm3uizQAQ9FFyE0K79RgddcMgHlFgHOiH9Thh1uG95oHtgF2ldsXwKzbmZP%2F5rGZJfxE7OplEtrAYBYdprzoo2L5eLXeaVOKP65Wt4rJlT%2BfgObYpiHG%2FkyST9H1E%2FDA8oOsxGtjgqCv8jlVzm5uVo1942RPyCO84dcli&X-Amz-Signature=2b4ffcc45ea920fd6b2ba1de49e4f765db52d554d766a864d674cb1dd6d6db51&X-Amz-SignedHeaders=host&x-amz-checksum-mode=ENABLED&x-id=GetObject)


In this guide, I’ll walk you through installing NVM on **Ubuntu 24.04**, show you how to use it effectively, and offer best practices to keep your setup stable. Let’s get started.


## **Why Use NVM?**

1. **Switch Node.js versions seamlessly**: Perfect for projects that require specific Node versions.
2. **Isolated environments**: Run multiple Node.js versions without interference between them.
3. **User-friendly workflow**: Install, remove, and manage Node.js versions with simple command-line operations.

## **Step 1: Update Your System**


It’s crucial to update your system first, to ensure dependencies and package sources are current:


```bash
sudo apt update
sudo apt upgrade -y
```


Also, consider rebooting if you haven’t done that in a while, especially if kernel or low-level packages were upgraded.


## **Step 2: Install Necessary Tools**


You’ll need tools to download files and compile modules when required:


```bash
sudo apt install -y curl build-essential libssl-dev
```

- `curl` → For fetching remote scripts.
- `build-essential` → For compiling C/C++ add-ons (npm modules that need binaries).
- `libssl-dev` → Some Node versions/modules need SSL libraries.

## **Step 3: Download & Install NVM**


Here we fetch the official installer and run it:


```bash
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/vX.Y.Z/install.sh | bash
```

- Replace `vX.Y.Z` with the **latest stable NVM version**.
- This script creates a `.nvm` directory in your home (~/.nvm), and updates your shell config (like `~/.bashrc` or `~/.zshrc`) to load NVM automatically.

## **Step 4: Activating NVM in Your Shell**


After installation, you need to enable it:


```bash
# Either in current session:
export NVM_DIR="$HOME/.nvm"
[ -s "$NVM_DIR/nvm.sh" ] && . "$NVM_DIR/nvm.sh"

# Then, add these lines into ~/.bashrc or ~/.zshrc so they are loaded on login.
```


To apply changes right away:


```bash
source ~/.bashrc    # or source ~/.zshrc
```


## **Step 5: Confirming Installation**


Check NVM is available:


```bash
nvm --version
```


If this returns something like `0.40.x` (or whatever current), you’re good.


## **Step 6: Using NVM to Handle Node.js Versions**


With NVM ready, you’ll want to do things like:


### **Install the latest stable version**


```bash
nvm install node
```


### **Install the current LTS version**


```bash
nvm install --lts
```


### **Install a specific version**


```bash
nvm install 18.17.0
```


### **Switch to a version for current session**


```bash
nvm use 18.17.0
```


### **Set a default version, so new shells use it automatically**


```bash
nvm alias default 18.17.0
```


### **List versions you have installed**


```bash
nvm ls
```


### **See all Node.js versions available to install remotely**


```bash
nvm ls-remote
```


## **Step 7: Workflow Tips & Tricks**


These are the little practices that make your life easier:

- **Use a** **`.nvmrc`** **file:** In a project folder, put a file named `.nvmrc` with a version (e.g. `18.17.0`). Then you and your team can use `nvm use` inside that project to automatically pick the right version.
- **Global packages per version:** If you install global npm packages under one Node version, they won’t automatically be available under another. Use `-reinstall-packages-from=<old_version>` when installing a new version to copy over global packages.
- **Avoid mixing apt-installed Node with NVM:** If you had Node.js from Ubuntu’s package manager before, consider removing it (`sudo apt remove nodejs`) to avoid conflicts.

## **Step 8: Common Issues & Fixes**


Here are issues you might encounter, plus how to fix them:


| Problem                                        | Symptoms                                                      | Fix                                                                                                               |
| ---------------------------------------------- | ------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------- |
| `nvm: command not found` after install         | The shell doesn’t load NVM automatically                      | Ensure lines added to `.bash` / `.zshrc` by installer are present; then `source` the file or open a new terminal. |
| Old Node still used by system                  | `node -v` returns old version even after `nvm use`            | Remove or disable the system Node; ensure your `PATH` is set so NVM’s bin comes first.                            |
| Permission errors when installing npm packages | Errors related to permissions when installing global packages | Don’t use `sudo` with npm when using NVM; global installs happen in user’s home directory.                        |


## **Conclusion**


Setting up NVM on Ubuntu 24.04 gives you control, flexibility, and peace of mind when working with Node.js. Once it’s in place, switching versions becomes second nature, which is especially helpful when maintaining multiple projects, testing compatibility, or just staying up to date with Node.js.



Managing Multiple Node.js Versions with NVM on Ubuntu 24.04: A Developer’s Guide


On Monday, October 20, 2025, Amazon Web Services (AWS) experienced a significant outage that disrupted numerous major websites and applications worldwide. The incident primarily affected the US-EAST-1 region in Northern Virginia, leading to widespread service degradation across various platforms.


![70fdd33d-8eab-436a-935d-ec6baf932af5.png](https://prod-files-secure.s3.us-west-2.amazonaws.com/655b33b3-36d2-8121-828f-0003e6db7868/ce8963a1-9007-4fb5-a21d-cb5a388677fd/70fdd33d-8eab-436a-935d-ec6baf932af5.png?X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Content-Sha256=UNSIGNED-PAYLOAD&X-Amz-Credential=ASIAZI2LB466THAEZ36T%2F20260301%2Fus-west-2%2Fs3%2Faws4_request&X-Amz-Date=20260301T082053Z&X-Amz-Expires=3600&X-Amz-Security-Token=IQoJb3JpZ2luX2VjEJv%2F%2F%2F%2F%2F%2F%2F%2F%2F%2FwEaCXVzLXdlc3QtMiJHMEUCIG7%2F1vyqwTM37i9lJfx6wKIeGjDeVXYHxiL1cSNleyyqAiEA7wzKsId69sn9OA2U1VqqwSd0cGmqKq%2BmA52EJ9svD24q%2FwMIZBAAGgw2Mzc0MjMxODM4MDUiDJYhWNDy%2FrtYJr54hircA4zlNIv2h4aCAMtb7PUCePQHJycjaLRyV2otfma9%2BUTeSGa%2FpgmLJ9q6zG9Bz8QzujwbNucIiTW9vwToFOG%2FT7IGS8kkH%2F52CPXikgbgSpR%2Bx%2F%2B4%2BAB9S7QsdOVDYhJMe%2BScZhLWqkCjanjC8YczHaPRQzc8glzjwqmaMo8NeQvUTYjw14iSnGW55SVUSdZSQ26lHt7Ov%2FZys8PHpsdBe2t70S4NEnwDhMAtt%2FzrT%2B3y4lyarSCDykWWeOU92ViKS2hGsPvSMgGQMhHWMWAyxl6jlMKcNCm7z4wdTE3KdlXaFv4EoG%2FKGtaJp5ZPADTpvwFlEzBvhWauKFFXq%2BKaLbt4Is0BDrFncxBmxEKbS5VAmyFFFlOhl5s1eLyecze6sPCMCda6yqm29WF8WgKW3frvNBMnGYCoYf33hU%2F%2BosLAJD8SW1NVTzLhQh%2BShvj7OQcD8uondlNicLcf8QEJNXf2xByKaGHHCTyw5hKeGbEY88WFQhldJC%2FfgbjuOgI3fA92SMIcPjlqy3rYzxa567ysIRpKxNUdBVsndJ7uA2aQMLiV06QbCwVhp%2F%2FiDclKaHV%2BtD06oKYC%2B7hgeJPx0TfhEv6PVfhHel59JpYnaG2KTp4iQFBuOfcDff%2FmMMTQjs0GOqUBxArD1bfxtMKn4M11l2%2FQzJCy%2FLmgg8gJXmlyKMaMbyJplyJKajDwk1x7LYdGnxyrthGFJKzXv40Je%2FR6CVIG4Pm4N4%2FD8w1OxSOAql0zKKDeolBZ4Tc645LsTJZFCrb0P4nGc6yO%2BBrvwIvaGcQOM1%2BdNv7mNboOMMrJtBn59732Qt6p8Eo30EwuKeZbMw9L%2Fm%2F7rSjZLmC%2BG0U6wHL5bEuVSh3N&X-Amz-Signature=d95ff74007971be524a693c3265eaf7dfbe98750429e7789e48b49656f4c929e&X-Amz-SignedHeaders=host&x-amz-checksum-mode=ENABLED&x-id=GetObject)


## Affected Services and Platforms


The AWS outage impacted a diverse range of services, including:

- **Social Media & Communication**: Snapchat, Signal, Perplexity, and X (formerly Twitter)
- **Gaming**: Fortnite, Roblox, Clash Royale, and Clash of Clans
- **Financial Services**: Coinbase, Robinhood, Venmo, Chime, and Capital One
- **Streaming & Entertainment**: Amazon Prime Video, Hulu, Disney+, and the McDonald's app
- **Productivity & Cloud Tools**: Canva, Duolingo, Airtable, and the Epic Games Store
- **Smart Home Devices**: Amazon Alexa and Ring

According to DownDetector, over 13,000 user reports were logged, indicating widespread issues across these platforms.


## What the AWS Outage Revealed About Cloud Vulnerabilities


The AWS outage of 2025 exposed deep-rooted cloud computing vulnerabilities that many organizations overlook in pursuit of scalability and convenience. While cloud infrastructure enables global reach and agility, its centralized architecture often introduces a critical single point of failure. When one major region or service falters, the ripple effects can disrupt thousands of dependent systems worldwide.

- **Regional dependence**: Most disruptions occurred in the US-EAST-1 AWS region, highlighting the dangers of geographic concentration.
- **Cross-industry impact**: Finance, gaming, social media, streaming, and IoT platforms all experienced simultaneous outages.
- **Hidden infrastructure risks**: Even resilient systems can be affected by DNS resolution failures, API latencies, and network bottlenecks.

## Why Organizations Rely on a Single Cloud Provider


Despite risks, many companies stick to one cloud provider for several reasons:

1. **Operational simplicity:** Easier management and fewer integration challenges.
2. **Cost efficiency:** Economies of scale and provider-specific discounts.
3. **Integrated ecosystem:** Access to services like AWS Lambda, Azure Functions, or Google BigQuery.
4. **Faster deployment:** Reduced complexity leads to quicker time-to-market.

However, the convenience comes at a cost: vulnerability to catastrophic outages.


## The True Cost of Cloud Outages


Cloud outages aren’t just technical inconveniences they have real financial and operational consequences:

- **Revenue loss:** Downtime for e-commerce or fintech platforms results in lost transactions.
- **Reputation damage:** User trust erodes, leading to customer churn.
- **Operational disruption:** Emergency IT interventions and overtime costs rise sharply.
- **Regulatory risks:** Financial and healthcare sectors may face compliance penalties.

For large enterprises, the financial impact of a hyper-scale outage can reach tens of millions per hour, making reliance on a single cloud provider a serious business risk.


## **Forging Resilience: Advanced Solutions to Prevent Single-Cloud Failure**


Enterprises can adopt resilient cloud strategies to mitigate risk:

1. **Multi-Cloud Strategy:** Distributes workloads across two or more public cloud providers (e.g., AWS, Azure, GCP) to prevent dependence on a single vendor and minimize the impact of a single-provider outage.
2. **Hybrid Cloud Approach:** Blends public cloud services with private, on-premises infrastructure. Critical workloads stay private, while scalable workloads use the public cloud, balancing cost and control.
3. **Active Failover and Replication:** Ensures real-time data replication across different regions or clouds. Automatic failover redirects traffic seamlessly to healthy replicas upon an outage.
4. **Chaos Engineering:** Proactively simulates failures in a controlled environment to identify weak points, test incident response, and continuously improve system resilience _before_ real-world disruptions.
5. **Edge Computing:** Deploys critical services closer to end-users (at the network "edge"), reducing reliance on centralized cloud regions. This improves latency and provides localized resilience.

## Building Resilient Cloud Infrastructure


The 2025 AWS outage underscores the dangers of relying on a single cloud provider. While hyperscale platforms offer convenience and innovation, true resilience requires diversification. Adopting multi-cloud and hybrid strategies supported by advanced failover, chaos engineering, and edge computing is now a strategic necessity. Organizations that build resilient cloud architectures will better protect operations, revenue, and customer trust in an increasingly interconnected digital world.


![b2a51211-7bb1-4a45-81bb-f69e5a765731.png](https://prod-files-secure.s3.us-west-2.amazonaws.com/655b33b3-36d2-8121-828f-0003e6db7868/0088afb8-3904-4fe6-a6bd-42ca5e75eecd/b2a51211-7bb1-4a45-81bb-f69e5a765731.png?X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Content-Sha256=UNSIGNED-PAYLOAD&X-Amz-Credential=ASIAZI2LB466THAEZ36T%2F20260301%2Fus-west-2%2Fs3%2Faws4_request&X-Amz-Date=20260301T082053Z&X-Amz-Expires=3600&X-Amz-Security-Token=IQoJb3JpZ2luX2VjEJv%2F%2F%2F%2F%2F%2F%2F%2F%2F%2FwEaCXVzLXdlc3QtMiJHMEUCIG7%2F1vyqwTM37i9lJfx6wKIeGjDeVXYHxiL1cSNleyyqAiEA7wzKsId69sn9OA2U1VqqwSd0cGmqKq%2BmA52EJ9svD24q%2FwMIZBAAGgw2Mzc0MjMxODM4MDUiDJYhWNDy%2FrtYJr54hircA4zlNIv2h4aCAMtb7PUCePQHJycjaLRyV2otfma9%2BUTeSGa%2FpgmLJ9q6zG9Bz8QzujwbNucIiTW9vwToFOG%2FT7IGS8kkH%2F52CPXikgbgSpR%2Bx%2F%2B4%2BAB9S7QsdOVDYhJMe%2BScZhLWqkCjanjC8YczHaPRQzc8glzjwqmaMo8NeQvUTYjw14iSnGW55SVUSdZSQ26lHt7Ov%2FZys8PHpsdBe2t70S4NEnwDhMAtt%2FzrT%2B3y4lyarSCDykWWeOU92ViKS2hGsPvSMgGQMhHWMWAyxl6jlMKcNCm7z4wdTE3KdlXaFv4EoG%2FKGtaJp5ZPADTpvwFlEzBvhWauKFFXq%2BKaLbt4Is0BDrFncxBmxEKbS5VAmyFFFlOhl5s1eLyecze6sPCMCda6yqm29WF8WgKW3frvNBMnGYCoYf33hU%2F%2BosLAJD8SW1NVTzLhQh%2BShvj7OQcD8uondlNicLcf8QEJNXf2xByKaGHHCTyw5hKeGbEY88WFQhldJC%2FfgbjuOgI3fA92SMIcPjlqy3rYzxa567ysIRpKxNUdBVsndJ7uA2aQMLiV06QbCwVhp%2F%2FiDclKaHV%2BtD06oKYC%2B7hgeJPx0TfhEv6PVfhHel59JpYnaG2KTp4iQFBuOfcDff%2FmMMTQjs0GOqUBxArD1bfxtMKn4M11l2%2FQzJCy%2FLmgg8gJXmlyKMaMbyJplyJKajDwk1x7LYdGnxyrthGFJKzXv40Je%2FR6CVIG4Pm4N4%2FD8w1OxSOAql0zKKDeolBZ4Tc645LsTJZFCrb0P4nGc6yO%2BBrvwIvaGcQOM1%2BdNv7mNboOMMrJtBn59732Qt6p8Eo30EwuKeZbMw9L%2Fm%2F7rSjZLmC%2BG0U6wHL5bEuVSh3N&X-Amz-Signature=f86a22e227248bf829400b5f7156b829368ac29f56ef2ec56c4278c39a383a94&X-Amz-SignedHeaders=host&x-amz-checksum-mode=ENABLED&x-id=GetObject)


The accompanying diagram illustrates a Multi-Cloud / Hybrid-Cloud Architecture enabling seamless integration and data flow across private, public, and edge environments, unified through a global network and management plane built on common services.


## 1. Private Cloud / On-Premises Data Center


This represents the enterprise's locally hosted infrastructure.

- **Components:** Includes Virtual Machines, Virtual Managers, Private Storage, multiple Databases, Servers, and Enterprise Applications.
- **Role:** It hosts sensitive or legacy applications and data that may have specific security, compliance, or performance requirements best met by an on-site environment.

## 2. Public Clouds (A and B)


These are external cloud provider services, showcasing a multi-cloud strategy.

- **Public Cloud A (e.g., AWS):** Features core services like Compute (EC2), Storage (S3), Database (RDS), and Analytics.
- **Public Cloud B (Azure / GPC):** Includes services like Virtual Machines, Blob Storage, SQL Database, Machine Learning Services, and other Machine Services.
- **Role:** These clouds offer scalability, elasticity, and specialized services, allowing the organization to run different workloads in the provider best suited for the task or to ensure redundancy.

## 3. Global Network / Interconnect


This is the conduit enabling communication and data transfer between the disparate clouds.

- **Components:** Utilizes technologies like VPN / Direct Connect Interconnect for secure, high-speed links, and an API Gateway to manage and secure access to services exposed by the clouds.
- **Role:** Ensures reliable, secure, and low-latency data and application traffic flow between the Private Cloud and the Public Clouds, effectively creating a single, extended infrastructure.

## 4. Unified Management Plane and Common Services


These layers ensure consistent operation, governance, and security across all environments.


### Unified Management Plane


This is a single control point for operating the entire architecture.

- **Functions:** Includes tools for Monitoring (tracking performance and health), Orchestration (automating deployment and management of resources), and Security (enforcing policies across clouds).

### Common Services


These foundational services are essential for a cohesive environment.

- **Components:** Includes Identity & Access Management (IAM) for consistent authentication and authorization across all clouds, and Data Encryption to secure data both in transit (via the Global Network) and at rest (in storage/databases).
- **Role:** Provides a single, unified experience for users and administrators, ensuring security and compliance policies are applied consistently.

The hybrid architecture ensures seamless integration by allowing the Unified Management Plane and Common Services to manage the movement of data and workloads between the Private Cloud and Public Clouds. This design enables the enterprise to leverage multiple cloud platforms while retaining control over critical on-premises resources.


The 2025 AWS outage was a strategic warning. Investing in multi-cloud resilience, automation, and distributed architectures is key for enterprises to not just survive, but thrive through future disruptions.



AWS Outage 2025: Cloud Risks and Resilience Lessons


If you’ve ever found yourself copy-pasting data between tools, writing yet another one-off script to connect APIs, or juggling a dozen SaaS dashboards every day, you know the pain of repetitive work. That’s exactly where **n8n** comes in a tool I’ve been exploring recently, and honestly, it has quickly become one of my favorites for automation.


## So, What Exactly is n8n?


n8n (short for “node”) is an **open-source workflow automation platform**. Think of it as a more developer-friendly version of Zapier or Integromat. It lets you connect different services, APIs, and databases, and build workflows that run automatically, without needing to reinvent the wheel each time.


The best part? You can host it yourself, customize it however you want, and you’re not locked into someone else’s SaaS pricing model. For developers and teams who care about data ownership and flexibility, this is a huge plus.


## Why I Like Working with n8n


When I started tinkering with n8n, a few things immediately stood out:

- **It’s open-source and self-hostable.** You can run it locally, on a server, or even in Docker/Kubernetes. This gives you full control.
- **It comes with 350+ integrations.** Google Sheets, Slack, GitHub, AWS, databases - you name it.
- **The editor is visual, but not limiting.** You can drag-and-drop nodes, but you can also write custom JavaScript if you need more control.
- **Event-driven automation.** Workflows don’t just run on a schedule - they can trigger when something happens (like a new file uploaded, or a webhook received).

For me, it strikes the right balance between **low-code convenience** and **developer power**.


## Real-Life Use Cases


Here are a few scenarios where n8n shines:

- **Marketing automation**: A new lead fills out a form → n8n saves it to a CRM → sends a Slack notification → triggers a welcome email.
- **DevOps monitoring**: When a server goes down → log the issue → create a GitHub ticket → ping the on-call engineer.
- **Data pipelines**: Fetch data from an API → transform it → insert it into PostgreSQL or BigQuery.
- **E-commerce workflows**: Automate order tracking, payments, and shipping updates.

Basically, if you can describe a process, you can probably build it in n8n.


## Getting Started (It’s Easier Than You Think)


Setting up n8n is surprisingly straightforward. You can install it globally with npm:


```bash
npm install n8n -g
n8n start
```


Or, if you’re like me and prefer containers:


```bash
docker run -it --rm \
  -p 5678:5678 \
  -v ~/.n8n:/home/node/.n8n \
  n8nio/n8n
```


Then just head over to `http://localhost:5678` in your browser, and you’ll find a clean visual editor waiting for you. From there, it’s drag-and-drop nodes, configure credentials, and connect the dots.


## Why n8n is Worth a Try


There are plenty of automation tools out there, but what sets n8n apart is the **balance of simplicity and flexibility**. It’s approachable for non-developers, but at the same time, it doesn’t box developers in. You can go as deep as you want with scripting, custom nodes, and API integrations.


For me, it’s a tool that reduces repetitive work and lets me focus on more interesting problems. If you’re curious about automation, I’d definitely recommend giving it a try.



Technical Blog

Terraform Lifecycle Explained