The Ultimate Handbook: Hosting a Dynamic Portfolio on AWS (S3, Lambda, API Gateway)

Introduction: Building Your Digital Home the Modern Way

Welcome, aspiring cloud architect! If you are reading this, you are likely standing at a crossroads. On one path, you have the traditional route: drag-and-drop website builders that handle everything for you but limit your freedom and creativity. On the other path, you have the "old school" route: renting a server, installing an operating system, configuring a web server like Apache or Nginx, and worrying about security patches every week.

But there is a third path. A modern path. The Serverless path.

You want a portfolio that feels alive—one that can process contact forms, fetch real-time data, display live visitor counts, or maybe even say "hello" back to your visitors. But you typically don't want to pay for expensive servers that sit idle 99% of the time, and you definitely don't want to manage infrastructure. You want to write code, push it, and have it run at a global scale instantly.

You have come to the right place.

Today, we are going to do something special. We are not just "uploading files" to the internet. We are going to architect a professional-grade serverless application. Think of it like building a house where you don't have to worry about the plumbing, the electricity, or the foundation—it just works, and you only pay for the water you actually drink.

In this massive guide, we will use three magical tools from Amazon Web Services (AWS), the same cloud provider used by Netflix, NASA, and huge enterprises:

1. Amazon S3 (Simple Storage Service): This is the land where your house sits. It holds your static assets—your HTML, CSS, JavaScript, and images. It is infinitely scalable and incredibly durable (AWS promises 99.999999999% durability).
2. AWS Lambda: This is the brain of your house. It thinks. It runs code only when you need it (like processing a "Contact Me" form submission or calculating a value). It sleeps when no one is visiting, costing you absolutely nothing.
3. Amazon API Gateway: This is the front door. It takes requests from your visitors' browsers and securely passes them to the brain (Lambda). It handles the traffic control, ensuring your brain isn't overwhelmed.

And the best part? We are going to do this Step-by-Step. I mean really step-by-step. I'm writing this guide as if I am sitting right next to you, looking at your screen, and pointing my finger at exactly where to click. We will not skip a single detail. From the moment you log in to the moment you see your site live, I will hold your hand.

Grab a large cup of coffee. We are about to learn how to walk in the clouds.

Phase 0: The Setup (Getting Your Key to the Cloud)

Before we can build our skyscraper, we need access to the construction site. If you already have an AWS account, you can skip to Step 2, but I recommend reading through to ensure your security settings are correct.

Step 1: Sign Into (or Create) the AWS Console

1. Open your preferred web browser (Chrome, Firefox, Safari, or Edge).
2. Type aws.amazon.com into the address bar and press Enter.
3. Look at the top right corner of the page. You will see an orange button that says "Sign In to the Console". Click it.
4. Root User vs. IAM User:
   • You will see two radio buttons. If this is your personal account that you created yourself, select "Root user".
   • Explanation: The "Root user" is the god-mode account. It can do anything, including deleting the billing information. In a professional setting, you would use an "IAM User" (Identity and Access Management) with limited permissions, but for setting up your own account, Root is fine.
5. Email Address: Type the email address you used to sign up for AWS. Click Next.
6. Password: Type your password. Be careful with caps lock! Click Sign in.

Note: If you are asked for a "Captcha" (those weird distorted letters), type them in carefully. AWS is very strict about security and wants to ensure you are a human, not a bot trying to break in.

Step 1.5: A Note on Security (MFA)

If you have just logged in, I want you to do one tiny detour before we start. This is the "eat your vegetables" part of the tutorial.

1. In the top right corner, click on your account name.
2. Click "Security Credentials".
3. Look for "Multi-factor authentication (MFA)".
4. If it says "Not assigned", please assign one. Use an app like Google Authenticator or Authy on your phone.
   • Why? If someone hacks your password, they can spin up 100 super-expensive servers to mine Bitcoin and leave you with a $50,000 bill. MFA prevents this. Do it now. I'll wait.

Done? Great. Click the AWS logo in the top left corner to go back to the main dashboard.

You are now in the AWS Management Console. It looks like a dashboard with lots of icons, numbers, and links. It can be overwhelming—"EC2", "Lightsail", "DynamoDB"—thousands of services. Don't panic! We only need three specific tools today. Ignore the noise.

Phase 1: The Foundation (Amazon S3)

Your website needs a place to live. In the cloud world, we call this a "Bucket."

Think of a bucket like a folder on your laptop, but this folder is stored on Amazon's hard drives in a massive data center. Unlike a Google Drive folder, an S3 bucket can be configured to act like a Web Server. It can serve your HTML files directly to the internet.

Step 2: Finding S3

1. Look at the top left of the screen. You’ll see a search bar that says "Search" (Shortcut: Alt+S).
2. Click inside that box and type: S3.
3. The first result will simply say "S3" with the description "Scalable Storage in the Cloud."
4. Click on "S3".

Step 3: Creating Your Bucket

You are now in the S3 dashboard. If you have never been here, the list will be empty. That’s okay.

1. Look for the bright orange button on the right side that says "Create bucket". Click it.
2. General Configuration:
   • Bucket Name: Find the text box under "Bucket name".
   • Type a name. CRITICAL RULE: This name must be unique across the entire planet. No two users in AWS can have the same bucket name.
   • Bad Name: my-portfolio (Taken by someone 10 years ago).
   • Good Name: john-doe-portfolio-2025-v1 (Likely available).
   • Pro Tip: If you plan to use a custom domain later (like www.yourname.com), you must name the bucket exactly the same as your domain: www.yourname.com. For this tutorial, any unique name works.
3. AWS Region:
   • Scroll down slightly to "AWS Region".
   • Click the dropdown menu.
   • Choose the region closest to your target audience.
   • If you are in New York, choose "US East (N. Virginia) us-east-1".
   • If you are in London, choose "Europe (London) eu-west-2".
   • Why? The closer the physical data center is to your users, the faster your website loads. Speed is everything in 2025.
4. Object Ownership:
   • Scroll down. You will see "ACLs enabled" and "ACLs disabled".
   • Leave "ACLs disabled" (Recommended) selected. This is the modern, secure way to manage permissions using Policies instead of legacy Access Control Lists.
5. Block Public Access settings for this bucket:
   • STOP! Pay attention here.
   • By default, AWS is paranoid (in a good way). It locks everything down to keep your private data safe. But this is a website. We want the public to see it.
   • Uncheck the box that says "Block all public access".
   • You will see four inner checkboxes automatically uncheck. This is correct.
   • A yellow warning box will appear at the bottom. It says "I acknowledge that the current settings might result in this bucket and the objects within becoming public."
   • Click the check box inside that yellow warning to confirm. You are telling AWS, "Yes, I know what I'm doing, I want people to see my files."
6. Bucket Versioning:
   • Scroll down. Leave it "Disabled" for now.
   • Context: Versioning keeps every version of a file you upload (like a backup). It costs more money because you store more data. For a simple portfolio, we don't need it yet.
7. Encryption:
   • Leave as default ("Server-side encryption with Amazon S3 managed keys (SSE-S3)"). AWS encrypts your files at rest automatically.
8. Finalize:
   • Scroll to the very bottom.
   • Click the orange "Create bucket" button.

Did it work? If yes, you will be taken back to the list of buckets, and you will see a green banner at the top saying "Successfully created bucket". If you got an error, it likely means your bucket name was taken. Try adding some random numbers to the end of the name and try again.

Step 4: Enabling Static Website Hosting

Your bucket exists, but right now it's just a secure storage box. We need to flip the switch that tells AWS: "Hey, treat this box like a website server."

1. In the buckets list, click on the blue name of the bucket you just created (e.g., john-doe-portfolio-2025-v1).
2. You will see a row of tabs at the top: Objects, Properties, Permissions, Metrics, Management, Access Points.
3. Click on the "Properties" tab.
4. Scroll ALL the way to the bottom. Seriously, keep scrolling until you hit the footer.
5. You will see a section called "Static website hosting". It probably says "Disabled".
6. Click the "Edit" button on the right of that section.
7. Enable It:
   • Select "Enable".
8. Hosting Type:
   • Ensure "Host a static website" is selected.
9. Index Document:
   • In the text box, type: index.html.
   • This is the entry point. When someone types your website URL, the browser looks for this specific file to load first.
10. Error Document (Optional but recommended):
    • Type: error.html or 404.html.
    • This is what users see if they type a broken link (like your-site.com/banana).
11. Save:
    • Click the orange "Save changes" button at the bottom.

Look closely! After saving, stay in that "Static website hosting" section at the bottom. You will now see a URL under "Bucket website endpoint". It looks like: http://john-doe-portfolio-2025-v1.s3-website-us-east-1.amazonaws.com Copy this URL. Save it in a notepad or a sticky note. This is the temporary address of your new home on the web!

Step 5: The Permission Policy (The VIP List)

Even though we unchecked "Block Public Access" in Step 3, we still haven't explicitly allowed people to read the files. We removed the "padlock," but we didn't open the door. We need to write a "Policy" that basically says: "Anyone on the internet is allowed to DOWNLOAD (Read) files from this bucket."

1. Scroll back up to the top tabs.
2. Click on "Permissions".
3. Scroll down past "Block public access (bucket settings)" to the "Bucket policy" section.
4. Click "Edit".
5. You will see a big text editor called "Policy editor". It looks blank or has empty curly braces {}. This is where we write valid JSON (JavaScript Object Notation).
6. Copy and Paste this code exactly into the editor:

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Sid": "PublicReadGetObject",
            "Effect": "Allow",
            "Principal": "*",
            "Action": "s3:GetObject",
            "Resource": "arn:aws:s3:::YOUR-BUCKET-NAME/*"
        }
    ]
}

7. CRITICAL FIX:
   • Look at the code you just pasted.
   • Find where it says YOUR-BUCKET-NAME.
   • You must replace that text with your actual bucket name that you created in Step 3.
   • Example: If your bucket is john-doe-portfolio-2025-v1, the line should look like:
   • "Resource": "arn:aws:s3:::john-doe-portfolio-2025-v1/*"
   • Don't forget the /* at the end! It is not a typo. /* creates a wildcard that means "Apply this rule to ALL files inside this bucket". Without it, the policy applies to the bucket folder itself, but not the files inside, and your site won't load.
8. Save:
   • Click "Save changes" at the bottom.

If successful, you will see a little badge near the top of the Permissions tab that says "Publicly accessible" in bright red/orange letters. This is good! It means your website is properly open to the world.

Phase 2: The Brain (AWS Lambda)

Now we have a place for files (S3). But a portfolio is about communication. Let's say you want to display the current server time dynamically, or handle a "Contact Me" form submission. S3 is "static"—it can't run logic or calculations. It just hands over files.

To add intelligence, we need AWS Lambda. Lambda lets you run code without provisioning or managing servers. You send it data, it runs your function, returns an answer, and disappears.

Step 6: Navigate to Lambda

1. Go back to the top of the page.
2. Click the Services icon (top left, looks like squares) or use the search bar (Alt+S).
3. Type: Lambda.
4. Click on "Lambda" (Run code without thinking about servers).

Step 7: Create Your First Function

1. You are now in the Lambda dashboard.
2. Click the loud orange button: "Create function".
3. Choose an option:
   • Keep the default selected: "Author from scratch".
4. Function Name:
   • Give it a name. Let's call it: myPortfolioBackend.
5. Runtime:
   • This is the language the brain speaks. Lambda supports Python, Java, Go, Ruby, etc.
   • Click the dropdown.
   • Choose Node.js 20.x (or whatever the latest Node.js version is). JavaScript/Node.js is great because it matches the language we use on the frontend.
6. Architecture:
   • Leave as x86_64 (Standard Intel/AMD architecture).
7. Finalize:
   • Click the orange "Create function" button (bottom right).

Wait a moment. AWS is spinning up a tiny, invisible computer just for you, installing Node.js on it, and prepping it for your code.

Step 8: Write the Code

You will land on your function's configuration page.

1. Scroll down to the tab that says "Code source".
2. You will see a file explorer on the left (index.mjs) and a code editor in the middle.
3. Double-click index.mjs to make sure it's open.
4. Delete everything in that file. Wipe it clean.
5. Paste this new code. This code simulates a dynamic backend. It generates a specialized "Hello" message and calculates the exact server time:

export const handler = async (event) => {
  // Let's create a dynamic message
  // In a real app, you might save data to a database here
  const currentTime = new Date().toISOString();
  
  const response = {
    statusCode: 200,
    headers: {
        "Content-Type": "application/json",
        // These headers are crucial for CORS (Cross-Origin Resource Sharing)
        // They tell the browser "It allows this website to talk to me"
        "Access-Control-Allow-Origin": "*",
        "Access-Control-Allow-Methods": "OPTIONS,POST,GET"
    },
    body: JSON.stringify({
      message: "Hello from your Serverless Brain!",
      timestamp: currentTime,
      dynamic_data: "This text came from the cloud (Lambda), not a static file."
    }),
  };
  return response;
};

6. Deploy:
   • Important! Just typing the code isn't enough. It's like typing a document but forgetting to hit save.
   • Look at the tab above the code editor. You see buttons: Test, Monitor, Deploy.
   • Click "Deploy".
   • A green banner "Successfully updated the function" will appear at the top. Your brain is now live.

Phase 3: The Front Door (Amazon API Gateway)

Our Lambda brain is ready, but it's isolated inside AWS's secure network. The outside world (your website visitors) cannot talk to it directly. We need a secure "Front Door" that accepts visitors and guides them to the brain. This is Amazon API Gateway.

Step 9: Navigate to API Gateway

1. Go to the search bar at the top.
2. Type: API Gateway.
3. Click on "API Gateway".

Step 10: Create the API

1. Scroll down the list of API types. You will see "HTTP API", "WebSocket API", and "REST API".
2. Find "REST API".
   • Note: There is "REST API" (public) and "REST API Private". Pick the Public one.
   • Why REST? "HTTP API" is newer and cheaper, but "REST API" gives us explicit control over things like CORS and Throttling, which are great for learning how the web works.
3. Click the orange "Build" button for REST API.
4. Choose the protocol: REST (selected).
5. Create new API: Select "New API".
6. Settings:
   • API name: PortfolioAPI.
   • Description: "Gateway for my portfolio website".
   • Endpoint Type: Regional.
7. Click "Create API".

Step 11: Create a Resource and Method

You currently have an empty API shell. Use the "Resources" column on the left to define your URL structure.

1. Create Resource (Think of this as a URL path, like /hello):
   • Click on the / (root) in the "Resources" column to select it.
   • Click the "Create resource" button.
   • Resource Name: hello.
   • Resource Path: /hello (auto-filled).
   • Enable API Gateway CORS: CHECK THIS BOX!
     • What is CORS? Cross-Origin Resource Sharing. It's a security guard in every web browser. If your website (mysite.com) tries to talk to your API (aws-api.com), the browser blocks it unless the API explicity says "I allow mysite.com to talk to me." Checking this box sets up those permissions automatically.
   • Click "Create resource".
2. Create Method (The action, like GET or POST):
   • In the sidebar, make sure you have the /hello resource selected.
   • Click "Create method".
   • Method type: Select GET. (Since we are just retrieving data).
   • Integration type: Select Lambda function.
   • Lambda function:
     • Make sure the region matches where you created your Lambda (e.g., us-east-1).
     • Click in the execution box and start typing myPortfolio. You should see myPortfolioBackend appear. Select it.
   • Lambda Proxy integration: Leave it off (or on, but for this simple example, off is fine. If you turn it on, the code structure changes slightly, but let's stick to the default). actually, enable Lambda Proxy integration is usually better for full control in code, but our code snippet above generates the full statusCode and body object, so TURN ON Lambda Proxy Integration.
   • Correction: Check the box "Lambda Proxy integration". This ensures the full request is sent to Lambda and Lambda's response is sent back exactly as we wrote it.
   • Click "Create method".

Step 12: Deploy the API

Your door is installed, but it's not "Open for Business" yet. You need to deploy it to a "Stage".

1. Look at the top right of the resources panel. Click on the orange button "Deploy API".
2. Stage:
   • It will ask you to select a stage. You don't have one yet.
   • Select "New Stage" from the dropdown.
   • Stage name: prod (short for production).
3. Click "Deploy".

The Magic Key: You will be redirected to the "Stages" dashboard. Look at the top. You will see a section called "Invoke URL". It looks like: https://xyz123.execute-api.us-east-1.amazonaws.com/prod Copy this URL. This is the public address of your backend API.

Phase 4: Connecting the Dots (The Frontend Code)

Now we tie it all together. We will create a simple HTML file that lives in S3 but uses JavaScript to "phone home" to your API Gateway.

Step 13: Create Your Website Files locally

1. On your own computer, create a new folder called my-portfolio.
2. Open a text editor (Notepad, TextEdit, VS Code, Sublime Text).
3. Create a file named index.html.
4. Paste this code. I have added comments to explain what every part does:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>My Serverless Portfolio</title>
    <style>
        /* Simple CSS just to make it look decent */
        body { font-family: 'Segoe UI', Arial, sans-serif; background-color: #f0f2f5; display: flex; justify-content: center; align-items: center; height: 100vh; margin: 0; }
        .card { background: white; padding: 3rem; border-radius: 12px; box-shadow: 0 10px 25px rgba(0,0,0,0.1); text-align: center; max-width: 450px; width: 100%; }
        h1 { color: #232f3e; margin-bottom: 10px; }
        p { color: #666; line-height: 1.6; }
        button { background-color: #FF9900; color: white; border: none; padding: 12px 24px; font-size: 16px; font-weight: bold; border-radius: 5px; cursor: pointer; transition: background 0.3s; margin-top: 20px; }
        button:hover { background-color: #e68a00; }
        #api-response { margin-top: 30px; padding: 15px; background: #f1faff; border-left: 4px solid #0073bb; text-align: left; display: none; border-radius: 4px; }
        .timestamp { color: #888; font-size: 0.8em; margin-top: 5px; display: block; }
    </style>
</head>
<body>
 
<div class="card">
    <h1>Hi, I'm [Your Name]</h1>
    <p>Welcome to my dynamic serverless portfolio.</p>
    <p>This page is hosted on <strong>S3</strong>, but the button below triggers a standard <strong>GET request</strong> to a serverless backend.</p>
    
    <button onclick="callBackend()">Ping Server via API Gateway</button>
    
    <div id="api-response">Loading...</div>
</div>
 
<script>
    // ------------------------------------------------------------------
    // CONFIGURATION SECTION
    // ------------------------------------------------------------------
    
    // REPLACE THIS URL WITH YOUR API GATEWAY INVOKE URL + /hello
    // Example: "https://xyz123.execute-api.us-east-1.amazonaws.com/prod/hello"
    const API_URL = "https://YOUR-API-ID.execute-api.us-east-1.amazonaws.com/prod/hello";
 
    // ------------------------------------------------------------------
    // THE LOGIC
    // ------------------------------------------------------------------
 
    async function callBackend() {
        const displayDiv = document.getElementById('api-response');
        
        // Show loading state
        displayDiv.style.display = 'block';
        displayDiv.innerHTML = "📡 Contacting Lambda Brain...";
 
        try {
            // The Fetch API sends a request to your API Gateway
            const response = await fetch(API_URL);
            
            if (!response.ok) {
                throw new Error(`HTTP error! status: ${response.status}`);
            }
 
            // Convert the response stream into JSON
            const data = await response.json();
            
            // Update the UI with the data from the cloud
            displayDiv.innerHTML = `
                <strong>Server Says:</strong> "${data.message}"<br>
                <div style="margin-top:10px;"><em>${data.dynamic_data}</em></div>
                <span class="timestamp">Generated at: ${data.timestamp}</span>
            `;
        } catch (error) {
            console.error("Error:", error);
            displayDiv.innerHTML = `<span style="color:red">Error connecting to backend: ${error.message}</span><br><br>Check the Console (F12) for details.`;
        }
    }
</script>
 
</body>
</html>

5. CRITICAL STEP:
   • Find the line const API_URL = ... in the script.
   • Replace the URL with the Invoke URL you copied in Step 12.
   • IMPORTANT: Add /hello to the end of it. The Invoke URL only gets you to the door (root). You need to walk to the specific room (/hello).
   • Correct Example: https://xyz123.execute-api.us-east-1.amazonaws.com/prod/hello
6. Save the file.

Step 14: Upload to S3

1. Go back to your S3 Bucket tab in AWS Console.
2. Click on the "Objects" tab.
3. Click the orange "Upload" button.
4. Click "Add files".
5. Select your index.html file from your computer.
6. Click "Upload" at the bottom.
7. Wait for the green "Upload succeeded" bar.
8. Click "Close".

Phase 5: The Grand Reveal

Step 15: Visit Your Live Site

1. Go to the "Properties" tab of your S3 bucket.
2. Scroll to the bottom "Static website hosting" section.
3. Click your Bucket website endpoint URL.
4. The Moment of Truth:
   • You should see your white card with "Hi, I'm [Your Name]".
   • Click the "Ping Server via API Gateway" button.
   • Success: A blue box should appear instantly saying "Hello from your Serverless Brain!" with the exact timestamp.
   • Each time you click it, the timestamp changes. That proves it's dynamic! No static file could do that without client-side math, but here the server is generating the time.

Phase 6: Going Professional (HTTPS and Custom Domains)

Hosting on s3-website-us-east-1.amazonaws.com is fine for testing, but if you want a job, you want yourname.com. Also, S3 website endpoints are HTTP (insecure) by default. Google hates insecure sites. We need HTTPS (secure).

To do this, we use Amazon CloudFront (AWS's Content Delivery Network or CDN).

Step 16: Setting up CloudFront

1. Search for "CloudFront" in the AWS console.
2. Click "Create distribution".
3. Origin Domain:
   • Click the box. It will suggest your S3 bucket. DO NOT SELECT THE SUGGESTION.
   • Why? The suggestion uses the S3 API endpoint. We want the S3 Website Endpoint.
   • Go back to S3 -> Properties -> Static Website Hosting. Copy that URL (without http://).
   • Paste that URL into "Origin Domain".
4. Protocol: Select HTTP only (CloudFront talks to S3 bucket over HTTP, but talks to users over HTTPS).
5. Viewer Protocol Policy: Select "Redirect HTTP to HTTPS". This forces security.
6. Web Application Firewall (WAF): Select "Do not enable security protections" (unless you want to pay extra).
7. Finalize: Click "Create distribution".

It takes about 5-10 minutes to deploy. Once done, you will get a https://d12345.cloudfront.net URL. This URL is secure, fast, and cached globally!

Step 17: Connecting a Domain (Route 53)

If you bought yourname.com on GoDaddy or Namecheap:

1. Go to Route 53 in AWS.
2. Create a Hosted Zone for yourname.com.
3. AWS gives you 4 nameservers (ns-xxx.awsdns.com).
4. Go to GoDaddy/Namecheap and replace their nameservers with the AWS ones.
5. Back in Route 53, create an "A Record".
6. Toggle "Alias" to ON.
7. Choose "Alias to CloudFront distribution".
8. Select your distribution.
9. Save.
10. Wait 30 minutes. Boom. You are live at https://yourname.com.

Troubleshooting Checklists

Things break. That's part of the job. Here is how to fix them.

Problem: 403 Forbidden AccessDenied

• Symptom: You see an XML error saying "Access Denied" when visiting your S3 URL.
• Fix 1: Did you uncheck "Block Public Access"? Go to Permissions tab.
• Fix 2: Did you add the Bucket Policy? Check the code. specifically /* at the end of the resource ARN.

Problem: 404 Not Found

• Symptom: "The specified key does not exist."
• Fix: Did you name the file Index.html (capital I)? Linux/Cloud is case-sensitive. It must be index.html.

Problem: Fetch Error / Network Error on Button Click

• Symptom: The red text appears "Error connecting to backend".
• Fix 1: Open Chrome DevTools -> Console. Do you see "CORS"?
  • Go to API Gateway -> Resources -> /hello.
  • Click "Enable CORS".
  • Re-deploy the API to the prod stage. (Crucial step everyone forgets).
• Fix 2: Check the URL in your index.html. Does it end in /hello?

Cost Analysis: Is It Really Free?

Yes, but let's be precise. AWS is "Pay-as-you-go".

AWS Free Tier (First 12 Months):

• S3: 5GB standard storage (plenty for a portfolio).
• S3 Requests: 20,000 GET requests/month.
• Lambda: 400,000 GB-seconds of compute time per month (millions of executions).
• API Gateway: 1 million calls per month.

What if I exceed the Free Tier?

• S3 Storage: $0.023 per GB (pennies).
• Lambda: $0.20 per 1 million requests.
• API Gateway: $3.50 per 1 million requests (this is the "expensive" part, but only if you are viral).

For 99% of personal portfolios, your bill will be $0.00. I recommend setting up a Billing Alarm in AWS Budgets to alert you if your bill goes over $1.00, just for peace of mind.

Conclusion

You did it. You didn't just key in a credit card to Squarespace. You built a cloud-native, serverless, globally distributed, dynamic web application.

You learned:

1. IAM & Security: Configuring accounts.
2. Cloud Storage: Managing public S3 buckets.
3. Serverless Compute: Writing and deploying Lambda functions.
4. API Management: routing traffic with API Gateway.
5. Frontend Integration: Connecting vanilla JS to cloud APIs.

This is exactly the same stack used by Netflix, Uber, and Airbnb for parts of their innovative platforms. You are in good company. Now, go fill that index.html with your actual projects and show the world what you built!