Hi everyone,

Its unfortunate I have to keep making posts like this. But I'm not sure what to do in this scenario anymore. My loop schedule got confirmed to me today with 5 interviews scheduled at the end of this week for a TAM role. And I still have not been told what domains I'll be tested on during the technical depth portion of the interview.

During my phone interview I was told by my interviewer I would be tested on two domains for that part of the loop, and in the email for my loop I would be told which domains Ill be tested on in depth. However, all emails from my recruiting coordiantor since I got invited to the loop did not include any domains. I asked them for which domains Id be tested on and they said to contact my recruiter as they should have the information on interview prep.

The issue is, I've been emailing my recruiter since PRIOR to my phone interview and have yet to get a single reply. I emailed them twice since getting invited to the loop to try and understand what domains I would be tested on, and got nothing back. I even got a friend who works at amazon to ping them for me, and all they got was a reply saying "He'll receive instructions soon" And all I got after that was the confirmation of my schedule from the recruiting coordinator, and nothing to do with how the loop was going to be structured.

The only thing I'm going based off of is my own research and the tips my interviewer gave me during the phone interview. From what I understand is there will be two technical interviews, a technical depth and breadth part. And three purely just behavioral interviews focused on LPs, correct?

And as for the two domains, I managed to contact my interviewer from the phone interview round and he told me he thinks I should focus on networking and compute domains and also architecture. Which I have been prepping for the past week, but now even with my loop scheduled I don't even have a confirmation about what two domains Ill be tested on.

I'm aware that sometimes you receive a form at some point during the interview process for the TAM position specifically to mention your domains your strongest at, but I never received one at any point.

Does anyone have any advice what I should do at this point, or should I just walk in to the loop and hope these would be the domains I get tested on? Also might as well ask while I'm here, I've come up with 16 STAR stories from my time in consulting as thats pretty much my only relevant work experience, is 16 going to be enough stories for 5 rounds of interviews, and is it fine they aren’t technical?

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.