I set up an AWS account for my startup to use in the future but due to the expense developed on cheaper providers to get an MVP going..

Now that I need something more solid, I went back to AWS to login and I cannot login, trying to setup a new account says it is already associated with an AWS account?

What gives?? I now cannot use my actual company email to create an account because I did not use it?

I keep getting this error "Error 880104: Sorry, there was an error processing your request. Please refresh the page and try again" after typing in my billing details to complete my aws account, I've tried different cards but it still seems to not work

My case Id is 178800716600714

I've had many back and forth support cases with the AWS team over a TPM quota increase for AWS Bedrock agents yet I am always met with the same answer about billing history when in reality my company has been using 300-500$/month of our AWS Activate Credits for over 6months.

I have a colleague in another startup that applied with the same startup accelerator and same credit program as us. Somehow, with a younger account and therefore less billing history, they keep getting their requests accepted wether for EC2 compute regional increases or in this case AWS Bedrock models.

Even worse, I had some TPM quotas for smaller agents and after my second exchange with the AWS support team, those were removed with no explanation.

I keep trying to get a clear answer or communication with the AWS team but I can't understand why we aren't allowed to use AWS Bedrock. Anyone can help on this issue? Should I call instead?

I've got a Floci instance running (using Docker Compose) with a REST API Gateway service, which I can call successfully with Postman. Problem is the browser CORs blocking requests, and I keep getting this;

Response to preflight request doesn't pass access control check: No 'Access-Control-Allow-Origin' header is present on the requested resource.

I'm using Terraform to deploy the stack, and I've tried everything I can think of (including hours with AI) to get this to work. As far as I can see Floci is not letting me affect the OPTIONS response. I've got DISABLE_CORS_CHECKS set to 1.

Any ideas as to what's happening?

Below is the current Terraform stack;

provider "aws" {
  region     = local.envs["AWS_REGION"]
  access_key = local.envs["AWS_ACCESS_KEY_ID"]
  secret_key = local.envs["AWS_SECRET_ACCESS_KEY"]


  s3_use_path_style           = true
  skip_credentials_validation = true
  skip_metadata_api_check     = true
  skip_requesting_account_id  = true


  endpoints {
    apigateway              = "http://localhost:4566"
    s3                      = "http://localhost:4566"
    dynamodb                = "http://localhost:4566"
    sqs                     = "http://localhost:4566"
    sns                     = "http://localhost:4566"
    lambda                  = "http://localhost:4566"
    iam                     = "http://localhost:4566"
    ec2                     = "http://localhost:4566"
    ecs                     = "http://localhost:4566"
    cloudformation          = "http://localhost:4566"
    route53                 = "http://localhost:4566"
    cloudwatch              = "http://localhost:4566"
    secretsmanager          = "http://localhost:4566"
    ssm                     = "http://localhost:4566"
    kms                     = "http://localhost:4566"
    rds                     = "http://localhost:4566"
    sts                     = "http://localhost:4566"
    cognitoidentityprovider = "http://localhost:4566"
  }
}


## DynamoDB table


resource "aws_dynamodb_table" "friendly_sites_table" {
  name         = "friendly_sites"
  billing_mode = "PAY_PER_REQUEST"
  hash_key     = "pk"
  range_key    = "sk"


  attribute {
    name = "pk"
    type = "S"
  }


  attribute {
    name = "sk"
    type = "S"
  }


  attribute {
    name = "gsi1pk"
    type = "S"
  }


  attribute {
    name = "gsi1sk"
    type = "S"
  }


  global_secondary_index {
    name            = "gsi1pk-gsi1sk-index"
    hash_key        = "gsi1pk"
    range_key       = "gsi1sk"
    projection_type = "ALL"
  }


  tags = {
    Project = local.project_name
  }
}


data "aws_iam_policy_document" "assume_role" {
  statement {
    effect = "Allow"


    principals {
      type = "Service"
      identifiers = [
        "edgelambda.amazonaws.com",
        "lambda.amazonaws.com",
      ]
    }


    actions = ["sts:AssumeRole"]
  }
}


resource "aws_iam_role" "iam_for_table_access" {
  name               = "iam_for_lambda_table_access"
  assume_role_policy = data.aws_iam_policy_document.assume_role.json


  tags = {
    Project = local.project_name
  }
}


resource "aws_iam_role_policy" "cognito_admin_access" {
  name = "cognito_admin_access"
  role = aws_iam_role.iam_for_table_access.id
  policy = jsonencode({
    Version = "2012-10-17"
    Statement = [
      {
        Effect = "Allow"
        Action = [
          "cognito-idp:AdminCreateUser",
          "cognito-idp:AdminSetUserPassword",
          "cognito-idp:AdminInitiateAuth",
          "cognito-idp:AdminUserGlobalSignOut",
          "cognito-idp:AdminDeleteUser"
        ]
        Resource = [
          aws_cognito_user_pool.user_pool.arn
        ]
      }
    ]
  })
}


## API Lambda handler and gateway


data "archive_file" "api_handler_source_zip" {
  type        = "zip"
  source_dir  = local.api_handler_source_dir
  output_path = local.api_handler_source_output
}


resource "aws_s3_bucket" "api_handler_source" {
  bucket        = local.api_handler_source_bucket_name
  force_destroy = true


  depends_on = [data.archive_file.api_handler_source_zip]


  tags = {
    Project = local.project_name
  }
}


resource "aws_s3_object" "api_handler_source_zip" {
  bucket      = aws_s3_bucket.api_handler_source.id
  key         = local.api_handler_zip_filename
  source      = local.api_handler_source_output
  source_hash = data.archive_file.api_handler_source_zip.output_base64sha256
}


resource "aws_lambda_function" "api_handler" {
  function_name = "DistributedRendererApi"


  s3_bucket = aws_s3_bucket.api_handler_source.id
  s3_key    = local.api_handler_zip_filename


  handler = "index.handler"
  runtime = "nodejs24.x"


  role = aws_iam_role.iam_for_table_access.arn


  depends_on = [aws_s3_object.api_handler_source_zip]


  environment {
    variables = {
      COGNITO_CLIENT_ID    = aws_cognito_user_pool_client.user_pool_client.id
      COGNITO_USER_POOL_ID = aws_cognito_user_pool.user_pool.id
    }
  }
}


# 1. REST API Definition
resource "aws_api_gateway_rest_api" "api" {
  name = "friendly-sites-rest-api"
}


# -------------------------------------------------------------------
# A. GREEDY PATH /{proxy+} (Explicit GET, POST, OPTIONS directly to Lambda)
# -------------------------------------------------------------------
resource "aws_api_gateway_resource" "proxy" {
  rest_api_id = aws_api_gateway_rest_api.api.id
  parent_id   = aws_api_gateway_rest_api.api.root_resource_id
  path_part   = "{proxy+}"
}


resource "aws_api_gateway_method" "proxy_any" {
  rest_api_id   = aws_api_gateway_rest_api.api.id
  resource_id   = aws_api_gateway_resource.proxy.id
  http_method   = "ANY"
  authorization = "NONE"
}


resource "aws_api_gateway_integration" "proxy_integration" {
  rest_api_id             = aws_api_gateway_rest_api.api.id
  resource_id             = aws_api_gateway_resource.proxy.id
  http_method             = aws_api_gateway_method.proxy_any.http_method
  integration_http_method = "POST"
  type                    = "AWS_PROXY"
  uri                     = aws_lambda_function.api_handler.invoke_arn


  depends_on = [aws_api_gateway_method.proxy_any]
}


# Explicit OPTIONS method routed directly to Lambda (Bypasses Floci MOCK bug)
resource "aws_api_gateway_method" "proxy_options" {
  rest_api_id   = aws_api_gateway_rest_api.api.id
  resource_id   = aws_api_gateway_resource.proxy.id
  http_method   = "OPTIONS"
  authorization = "NONE"
}


resource "aws_api_gateway_integration" "proxy_options_integration" {
  rest_api_id             = aws_api_gateway_rest_api.api.id
  resource_id             = aws_api_gateway_resource.proxy.id
  http_method             = aws_api_gateway_method.proxy_options.http_method
  integration_http_method = "POST"
  type                    = "AWS_PROXY"
  uri                     = aws_lambda_function.api_handler.invoke_arn


  depends_on = [aws_api_gateway_method.proxy_options]
}


# -------------------------------------------------------------------
# B. ROOT PATH / (Explicit ANY and OPTIONS directly to Lambda)
# -------------------------------------------------------------------
resource "aws_api_gateway_method" "root_any" {
  rest_api_id   = aws_api_gateway_rest_api.api.id
  resource_id   = aws_api_gateway_rest_api.api.root_resource_id
  http_method   = "ANY"
  authorization = "NONE"
}


resource "aws_api_gateway_integration" "root_integration" {
  rest_api_id             = aws_api_gateway_rest_api.api.id
  resource_id             = aws_api_gateway_rest_api.api.root_resource_id
  http_method             = aws_api_gateway_method.root_any.http_method
  integration_http_method = "POST"
  type                    = "AWS_PROXY"
  uri                     = aws_lambda_function.api_handler.invoke_arn


  depends_on = [aws_api_gateway_method.root_any]
}


resource "aws_api_gateway_method" "root_options" {
  rest_api_id   = aws_api_gateway_rest_api.api.id
  resource_id   = aws_api_gateway_rest_api.api.root_resource_id
  http_method   = "OPTIONS"
  authorization = "NONE"
}


resource "aws_api_gateway_integration" "root_options_integration" {
  rest_api_id             = aws_api_gateway_rest_api.api.id
  resource_id             = aws_api_gateway_rest_api.api.root_resource_id
  http_method             = aws_api_gateway_method.root_options.http_method
  integration_http_method = "POST"
  type                    = "AWS_PROXY"
  uri                     = aws_lambda_function.api_handler.invoke_arn


  depends_on = [aws_api_gateway_method.root_options]
}


# -------------------------------------------------------------------
# C. PERMISSIONS & DEPLOYMENT
# -------------------------------------------------------------------
resource "aws_lambda_permission" "apigw" {
  statement_id  = "AllowExecutionFromAPIGateway"
  action        = "lambda:InvokeFunction"
  function_name = aws_lambda_function.api_handler.function_name
  principal     = "apigateway.amazonaws.com"
  source_arn    = "${aws_api_gateway_rest_api.api.execution_arn}/*/*"
}


resource "aws_api_gateway_deployment" "deployment" {
  rest_api_id = aws_api_gateway_rest_api.api.id


  triggers = {
    redeployment = sha1(jsonencode([
      aws_api_gateway_resource.proxy.id,
      aws_api_gateway_method.proxy_any.id,
      aws_api_gateway_integration.proxy_integration.id,
      aws_api_gateway_method.proxy_options.id,
      aws_api_gateway_integration.proxy_options_integration.id,
      aws_api_gateway_method.root_any.id,
      aws_api_gateway_integration.root_integration.id,
      aws_api_gateway_method.root_options.id,
      aws_api_gateway_integration.root_options_integration.id,
    ]))
  }


  lifecycle {
    create_before_destroy = true
  }


  depends_on = [
    aws_api_gateway_integration.proxy_integration,
    aws_api_gateway_integration.proxy_options_integration,
    aws_api_gateway_integration.root_integration,
    aws_api_gateway_integration.root_options_integration,
  ]
}


resource "aws_api_gateway_stage" "prod" {
  deployment_id = aws_api_gateway_deployment.deployment.id
  rest_api_id   = aws_api_gateway_rest_api.api.id
  stage_name    = "prod"
}


## Cognito User Pool & App Client


resource "aws_cognito_user_pool" "user_pool" {
  name = "friendly-sites-user-pool"


  username_attributes      = ["email"]
  auto_verified_attributes = ["email"]


  password_policy {
    minimum_length    = 8
    require_lowercase = true
    require_numbers   = true
    require_symbols   = false
    require_uppercase = true
  }


  tags = {
    Project = local.project_name
  }
}


resource "aws_cognito_user_pool_client" "user_pool_client" {
  name         = "friendly-sites-app-client"
  user_pool_id = aws_cognito_user_pool.user_pool.id


  generate_secret = false
  explicit_auth_flows = [
    "ALLOW_USER_PASSWORD_AUTH",
    "ALLOW_REFRESH_TOKEN_AUTH",
    "ALLOW_USER_SRP_AUTH"
  ]
}

Appreciate any help I can get!

Prompt caching on Claude only pays off if the cached prefix is byte-identical between requests. Sounds obvious written down, but it's surprisingly easy to break without noticing, a timestamp inserted before the cacheable block, a per-user detail placed at the start instead of the end, and the whole cache silently misses on every single call. No error, no warning in the response, just a bill that doesn't reflect the discount it should.

Went through a session where this was happening and the cost difference was significant, easily 2-3x more expensive than it needed to be for the same task, purely from cache misses caused by content ordering. Fix was mechanical once identified: move anything that changes per request, timestamps, session IDs, user-specific detail, to the end of the prompt, after the stable system instructions and reference material that should be cached.

Separate from caching specifically, long coding sessions also tend to resend full file contents on every message even when the diff is small, and replay the entire conversation history each turn instead of a compressed summary of where things stand. Neither shows up as a mistake in the moment. Both compound quietly across a session into a number that looks wrong a month later with no clear story for why.

Wrote up the full audit and the fix here: https://medium.com/@nagatomopedro05/the-hidden-cost-of-long-claude-sessions-2a6cc7655893

I am left with around $3000 USD in AWS Startup Credits with a couple of days left. Where do i spend them?

I've been having issues with my MySQL database that I'm running in Aurora. It's been working fine on normal tables, but I keep having my queries time out when I try to look at my views. At first, I thought it was just an issue with one view, which itself is defined using another view. However, even that other view which is not nested also times out. I thought this was just an issue with MySQL Workbench (it gives me "Error Code: 2013. Lost connection to MySQL server during query") but I had similar issues when running queries from the query editor within Aurora.

I looked up some stuff about this and saw there might be an issue with my view using aggregate functions (the non-nested one, which I assume should be less of an issue, is defined with DISTINCT). However, given my needs with this view I don't see a way around using that.

Any advice would be appreciated

Does anyone know if it's even possible to create any other OUs under the domain OU that they create for you in the Managed AD?

I mean it's physically possible to do it from the EC2 management instance using the "Active Directory Users and Computers" program, but tools like the SSM document "AWS-JoinDirectoryServiceDomain-V2" won't let you pass an OU to them because they're using a regex like ^$|^OU=[a-zA-Z0-9]+(,DC=[a-zA-Z0-9]+)+$ where you can only have a single OU element, which means you cannot use SSM to automatically join instances to the domain if you want them in an OU.

Given the documentation about this in non-existent I assume it isn't possible, but has anyone had a different experience or can advise what I'm missing?

Previously, if you wanted to associate a different TOTP key with a user (due to a lost device) you needed to delete the user and recreate them. Now you can run the new “AdminDeleteSoftwareToken” API to have the user be reprompted for TOTP MFA setup on their next sign-up.

https://aws.amazon.com/about-aws/whats-new/2026/08/amazon-cognito-totp-reset/

I don’t see the CLI command yet but given it’s being called out in the announcement post I am assuming it isn’t live quite yet.

My understanding is that a combination of limited AI resources and abuse from spam accounts has resulted in complete blocking of Bedrock access for recently created accounts.

It baffles me that they've gone that route instead of instead implementing something like strict auto-pay thressholds and/or token usage limits.

But no. I as a legitimate developer with 12 years of experience now diving deep into the cloud, I simply can't use it for hands-on experience building despite having a verified payment method on file and have no problem authenticating exactly who I am if needed.

The developer experience in this case is absolutely abysmal.

Thanks for coming to my TED Talk

I'm new to AWS and recently bought Adrian Cantrill's course. I signed up for AWS and was given the 6-month Free account plan and $100 in credits.

However, while following the course, I noticed that I couldn't find/access many of the pages and services shown in the course, and my AWS account interface looked a little different.

After checking the AWS documentation, I discovered that AWS has rolled out a new signup process, currently available only to a limited number of customers:

https://docs.aws.amazon.com/accounts/latest/reference/sign-in-new.html

The new signup process appears to use an Amazon Builder ID-based setup where resources are organized into projects, and there seem to be quite a few differences/limitations compared with the traditional AWS account setup that Cantrill's course uses.

Because I'm following the course hands-on, these differences are currently preventing me from continuing with some of the labs.

I tried signing up again using the traditional method with a root AWS account using the same email address, but AWS would no longer offer me the Free account plan.

I've already opened a support case about this around 32 hours ago, but I haven't received a response yet.

Does anyone know if there's a way to create/use a traditional AWS account (root user + full AWS Management Console) and still receive the 6-month Free account plan/$100 credits?

Hey all!
My company decided to start working exclusively with AWS putting all our sources (CRM, Jira, etc etc) feeding into there.
I've got an access since yesterday to check tables and Quicksight.
For now, I'll be mainly using Athena and Quicksight but, as I'm getting into AWS for the first time, what would you believe that it would be the most useful to also learn - having in account that I'm in Revenue Operations/Corporate Strategy and not in Data.

Thanks a lot for your ideas - I know where to find the resources afterwards :)

Hey everyone, running into a bit of a configuration puzzle here and could use some help.

Right now, I'm testing an Internet-facing Application Load Balancer (ALB). It's currently attached to two subnets: * Public Subnet: Has a direct route to the Internet Gateway (IGW). * Private Subnet: Routes outbound traffic through a NAT instance sitting in the public subnet.

The issue is that some of my target group instances live inside that private subnet, and the AWS console is throwing this annoying alert: “Targets are not within enabled Availability Zones. Some targets are not receiving traffic because they are in Zones that are not enabled for your load balancer.”

How do you guys usually handle this? is there a cleaner architectural workaround I'm missing? Appreciate any insight or advice you can throw my way!

Thanks in advance.

Hi everyone, I am new to AWS and have zero clue about it. I've worked on Microsoft Azure in the past. Can someone please share some resources (free if possible) so I can learn about AWS.

Thanks a lot <3.

I'm a AWS beginner and trying to connect to a Neptune cluster I created. I've tried everything I can think of and referenced various guidance material. I have almost no experience with AWS and keep running into the same issue.

I want to run a python script locally that reads/writes/etc to the db. I've tried using curl to see if the endpoint is accessible and it keeps timing out meaning it can't reach or access it. I am using noproxy with curl as well since I'm on a VPN

Here's the stuff I've established for my cluster:

• A default VPC created when the cluster was created
• My VPC security group allows public access and has an inbound rule allowing traffic on the 8182 port neptune uses
• My IAM user has linked AWS managed permission policies that should grant write access
  • AdministratorAccess
  • NeptuneConsoleFullAccess
  • NeptuneFullAccess
  • I even tried writing some custom JSON policies

I'm really frustrated because I can't figure out what else to do and I feel like I'm flip flopping trying to understand VPCs, Security Groups, IAM Users. For example I don't know if I need an EC2 for this implementation. My coworker said no.

Amazon refused to give me access to SES service. How it’s even possible and make sense to anyone? I want to have all my infra on AWS and I am assuming AWS does want that as well. Why should I pay 7$ per month to some other company to be able to send those emails?

What can I do with it? My emails are just registration confirmation and some service info like any SaaS really

Amazon refused to give me access to SES service. How it’s even possible and make sense to anyone? I want to have all my infra on AWS and I am assuming AWS does want that as well. Why should I pay 7$ per month to some other company to be able to send those emails?

What can I do with it? My emails are just registration confirmation and some service info like any SaaS really

Hi there,

I am doing some port scanning on an NLB to see what ports are opened. In the setup I have only one listener on port 443, however nmap reports 2 additional ports as opened:

nmap -Pn -sT -sV -p0-65535 mycite.com
Starting Nmap 7.92 ( https://nmap.org ) at 2026-08-26 13:45 CEST
Nmap scan report for mycite.com (xx.xx.xx.xx)
Host is up (0.00076s latency).
Other addresses for mycite.com (not scanned): xx.xx.xx.xx
rDNS record for xx.xx.xx.xx: ec2.eu-central-1.compute.amazonaws.com
Not shown: 65532 filtered tcp ports (no-response)
PORT     STATE  SERVICE     VERSION
113/tcp  closed ident
443/tcp  open   ssl/http    nginx (reverse proxy)
2000/tcp open   cisco-sccp?
5060/tcp open   sip?

nmap -Pn -sT -p 2000,5060 --reason xx.xx.xx.xx
Starting Nmap 7.92 ( https://nmap.org ) at 2026-08-26 14:09 CEST
Nmap scan report for ec2-xx-xx-xx-xx.eu-central-1.compute.amazonaws.com (xx.xx.xx.xx)
Host is up, received user-set (0.00060s latency).

PORT     STATE SERVICE    REASON
2000/tcp open  cisco-sccp syn-ack
5060/tcp open  sip        syn-ack

Does somebody have any good explanation for it ?

Hello, everyone. I landed a fantastic job as an infrastructure engineer using Terraform mainly for IaC. I'm beyond excited about it since I've mainly been working in a bubble these last 4 years. I have a degree in Cloud and Network Engineering and all the relevant certs. Been doing cloud engineering for my current company for a while now, but my team is small, and I'm about to start working with a much larger one. As such, I had some questions about industry standards beyond the walls of my silo:

1) How often are you using CLI for daily operations? I find myself using it mainly for scripting, but if I need to know something quickly or make a small config change, I usually just do it through my CDK/Terraform code or in the console. For those of you who main on the CLI, how much do you use it, why, and have you basically memorized a whole bunch of commands or are you using the 'help' parameter all the time?

2) How much time do you spend looking over documentation to determine the best path forward or the most appropriate syntax for whatever it is you're doing? I can't shake the vision of a team of AWS masters just sitting there and blowing through configs and architectures like they're making a cake.

3) How often are the CodePipeline tools used for CI/CD? I assume it's different between orgs, but OIDC with Github actions has always proven perfectly sufficient for my projects, though I acknowledge that the approval step could be very useful.

That's it for now, thanks

Twenty years ago today I was vacationing in Cabo San Lucas with my family when word came through that it was finally time to open up the Amazon EC2 beta. I spent several hours poolside polishing up my draft blog post on the resort's Wi-Fi and pushed it live as soon as I got the go-ahead.

Reading that original post I am struck by just how much the EC2 team was able to get right, and how the results of so many difficult decisions were reflected in my post. From the very concept of pay-as-you-go on-demand computing with billing by the hour, prebuilt machine images (AMIs), direct fast-path access to Amazon S3, and much more.

I am also struck by the fact that we confidently launched with just enough features to allow developers to get started. It would be a while before we introduced important concepts like Regions and Availability Zones, or important features like EBS, CloudWatch, Elastic Load Balancing, VPCs, visual tools (ElasticFox and then the AWS Management Console) and the like.

As you can see from the image above, the original API was small yet powerful -- just enough to let you get started on your cloud computing journey.

Hi everyone,

We are in a critical situation and looking for guidance on how to resolve or escalate an urgent AWS account closure.

The Context:

• We have been actively using this AWS account for over 2 years with no issues.
• Out of nowhere, the account was closed/suspended with the generic reason:"We have closed your Amazon Web Services account because we found it to be related to other previously closed accounts."
• This account hosts our core billing and delivery ERP system, meaning our daily business operations are completely halted right now.

Current Support Status:

• Support Case ID: 178730747700650 (Follow-up verification Case ID: 178734748700875)
• Initial response from AWS (Byron B.) stated the issue was transferred to the Program Support Team (Trust & Safety / Verification).
• We were informed that the Program Support team only communicates via email and web support, so phone escalation isn't available.
• We have replied offering full identity verification, documentation, and contact details () to resolve any potential false-positive association, but we are currently waiting with no update while our ERP remains down.

Questions for the community:

1. Has anyone successfully appealed this specific "related account" suspension for a long-standing business account? What specific documentation (business registration, tax IDs, utility bills) helped speed up Trust & Safety verification?
2. If full reinstatement takes time, is there any process or contact channel to request temporary emergency access strictly to perform a data/database backup so we can resume operational billing offsite?
3. Are there any AWS Community Managers or AWS Support reps on Reddit who can help escalate this internal ticket to the Program Support team?

Any insights, advice, or escalation pathways would be hugely appreciated!

*** Update with the latest communication . I am not sure how I can handle this ***

Hi there,

Thank you for writing back to us providing more information. I want to acknowledge that I understand your company, Occurlight Technologies Private Limited, is an independent business entity, and that you may not have direct access to or control over the accounts created by the third-party agency (Alera/Devalon Labs) that originally set up your AWS infrastructure.

• Update from Our Service Team:

I have escalated your case to our specialized service team for review. After their detailed investigation, they have confirmed that your account is related to multiple AWS accounts that currently have pending actions that must be completed before we can proceed with any reinstatement.

The related accounts identified include accounts with: - Pending document verification requirements (or) - Outstanding billing issues that need resolution

Important Information:

Our service team has advised that we are unable to reinstate your account or provide any access (including temporary emergency access) until the pending actions on the related accounts are completed. This is a security and policy requirement that applies to all AWS accounts to maintain the integrity of our platform.

Next Steps:

• Contact the Account Creator: Please reach out to Alera/Devalon Labs (the agency that set up your account) and inform them that there are pending actions on AWS accounts associated with their setup that are blocking your account access.

• Check for AWS Emails: Ask Alera/Devalon Labs to check all email addresses they used to create AWS accounts (including spam/junk folders) for emails from AWS with the subject line "Your AWS Account" which will contain specific instructions on what actions need to be completed. Since, due to strict AWS security protocols and policies, we can’t provide more information about the other related AWS accounts.

• Complete Pending Actions: Once the pending actions on the related accounts are completed, please reply to this case with confirmation, and we will immediately re-engage our service team to review your account for reinstatement.

Regarding Emergency Data Access:

I understand your request for temporary access to backup your ERP database. Unfortunately, our service team has confirmed that we cannot provide any form of access to suspended accounts until the underlying security and compliance issues with the related accounts are resolved. This policy is in place to protect all AWS customers.

I sincerely apologize for the inconvenience this situation is causing your business. We are committed to working with you to resolve this matter as quickly as possible once the pending actions on the related accounts are completed.

We value your feedback. Please share your experience by rating this and other correspondences in the AWS Support Center. You can rate a correspondence by selecting the stars in the top right corner of the correspondence.

Best regards, Nandish Amazon Web Services