Deploying Your First App to AWS: A Beginner-Friendly Step-by-Step Tutorial

Deploying your first app is a huge milestone.

Locally, everything feels easy.
But the moment you try to share your app online, you hit questions like:

• Where do I host it?
• How do I make it public?
• How do I update it safely?
• How do I avoid surprise costs?

This guide is made for beginners who want a calm, practical walkthrough.

You’ll deploy a real app to AWS using a beginner-friendly platform, learn what each step does, and finish with a live public URL you can share.

✅ Key Takeaways

🧭 Quick Navigation

🧩 What You’ll Deploy

You’ll deploy a small Node.js API app that returns JSON and also shows a simple homepage.

Why this is a great first deployment:

• It’s realistic (backend apps are common)
• You can test it easily in the browser
• You learn the same workflow used by bigger apps

App features

• GET / → returns a simple “App is running” page
• GET /health → returns JSON health status
• GET /api/time → returns current server time as JSON

These routes make it easy to confirm:

✅ server is running
✅ routing works
✅ JSON responses work

🧰 Which AWS Platform Should Beginners Use?

AWS has many services. That’s great long-term, but confusing at the start.

For your first deployment, the best beginner options are:

This tutorial uses: AWS Elastic Beanstalk.
Because it teaches real backend deployment while staying beginner-friendly.

If your “first app” is a React/Vue site, Amplify is even easier — but we’ll focus on the cloud deployment skill that most beginners want: getting a backend live.

🛠️ Before You Start (Tools + Accounts)

1) Create an AWS account

You need an AWS account with billing set up.

Important beginner habit:

• Use Free Tier-friendly settings
• Don’t leave unused environments running

2) Install Node.js

Install the LTS version of Node.js.

To confirm:

node -v
npm -v

3) Use VS Code

Any editor works, but VS Code is the smoothest for learning.

4) Optional but recommended: GitHub

Not required for this path, but useful if you want version control.

🧱 Create the Sample App (Node.js + Express)

Step 1: Create a folder

mkdir aws-first-deploy
cd aws-first-deploy

Step 2: Initialize Node project

npm init -y

Step 3: Install Express

npm install express

Step 4: Create server.js

Create server.js and paste:

const express = require("express");

const app = express();
const PORT = process.env.PORT || 3000;

// Homepage
app.get("/", (req, res) => {
  res.send(`
    <div style="font-family:Arial;padding:24px;line-height:1.6">
      <h1>✅ App is running</h1>
      <p>This app is deployed to the cloud.</p>
      <ul>
        <li><a href="/health">/health</a></li>
        <li><a href="/api/time">/api/time</a></li>
      </ul>
    </div>
  `);
});

// Health check (useful for AWS)
app.get("/health", (req, res) => {
  res.json({ status: "ok" });
});

// Simple API route
app.get("/api/time", (req, res) => {
  res.json({
    serverTime: new Date().toISOString()
  });
});

app.listen(PORT, () => {
  console.log(`Server running on port ${PORT}`);
});

Step 5: Add the start script

Open package.json and ensure you have:

"scripts": {
  "start": "node server.js"
}

Step 6: Test locally

npm start

Open:

• http://localhost:3000/
• http://localhost:3000/health
• http://localhost:3000/api/time

✅ If it works locally, you’re ready to deploy.

📦 Prepare the App for Deployment

Elastic Beanstalk deploys your app by receiving a package (zip) and running npm install and npm start.

What AWS expects (simple)

• Your package.json exists
• Your start script works
• Your app listens on process.env.PORT

You already did all three.

Create a deployment ZIP (important rule)

Do not zip the parent folder itself in a weird way.

A safe method:

1. Keep these in the root:
   • server.js
   • package.json
   • package-lock.json (if it exists)
2. Delete node_modules before zipping (AWS installs dependencies again)

rm -rf node_modules

3. Zip the project contents

On Windows, select the files and zip them.
On Mac/Linux:

zip -r deploy.zip .

✅ You now have deploy.zip

🚀 Deploy to AWS Elastic Beanstalk (Step-by-Step)

We’ll deploy using the AWS Console (web UI). It’s the easiest for a first-time beginner.

Step 1: Open Elastic Beanstalk

In AWS Console, search for Elastic Beanstalk.

Step 2: Create a new application

• Application name: first-aws-app
• Platform: Node.js
• Application code: Upload your code

Step 3: Upload deploy.zip

Upload the zip you created.

Step 4: Create environment

Choose:

• Environment type: Web server environment
• Instance type: pick a Free Tier-friendly option if offered
• Keep defaults for now (beginner safe)

Then click Create.

AWS will:

• create resources
• install dependencies
• start your app
• generate a public URL

This can take several minutes (normal).

Step 5: Copy the public URL

When the environment is ready, you’ll see a URL like:

• http://something.elasticbeanstalk.com

Open it.

✅ Verify Your Live App

Test your live endpoints:

1. Homepage

• http://YOUR-URL/

2. Health

• http://YOUR-URL/health

Expected JSON:

{ "status": "ok" }

3. Time API

• http://YOUR-URL/api/time

Expected JSON:

{ "serverTime": "..." }

If all three work:

✅ Your first AWS deployment is done.

🔁 Update Your App (Redeploy)

Now you’ll learn the most important real-world skill:

deploying updates safely.

Step 1: Change something small

Edit the homepage text in /.

Example:

<h1>✅ App is running (v2)</h1>

Step 2: Recreate deploy.zip

Delete node_modules, zip again.

Step 3: Upload new version

In Elastic Beanstalk:

• Go to your environment
• Find “Upload and deploy”
• Upload the new ZIP

Step 4: Refresh your URL

You should see the updated text.

🔐 Environment Variables (Secrets Done Right)

Beginners often hardcode secrets in code.

Don’t do that.

Use environment variables.

Example: Add a “MODE” variable

Update /health:

app.get("/health", (req, res) => {
  res.json({ status: "ok", mode: process.env.MODE || "local" });
});

Locally, run:

MODE=local npm start

In AWS, set it in Elastic Beanstalk environment configuration:

• Configuration → Software / Environment properties
• Add: MODE = production

Now /health will show the correct mode.

✅ This is how you store API keys and secrets safely (without pushing them into your code).

🧯 Logs & Debugging (When Things Break)

Deployments fail sometimes. The fastest fix is always: check logs.

Common symptoms and what to do

Where to find logs

In Elastic Beanstalk console:

• Logs → Request logs / Full logs

Look for:

• “Error”
• “Cannot find module”
• “Listening on port”
• “Crash”

Practical debugging tip

Add a startup log:

console.log("Starting app...");
console.log("PORT:", process.env.PORT);

It helps you confirm the environment is correct.

💸 Cost-Safe AWS Tips for Beginners

AWS is powerful, but beginners must build cost habits early.

Cost-safe rules

✅ Rule 1: Delete what you’re not using
If you finished practicing, delete the environment.

✅ Rule 2: Don’t create random extra services
Stick to Elastic Beanstalk until you understand billing.

✅ Rule 3: Monitor billing
Enable billing alerts if available in your account.

✅ Rule 4: One environment at a time
Don’t leave 3 environments running “just in case.”

Beginner cost table

⚠️ Common Deployment Mistakes

🧪 Exercises / Mini Projects

Try It Yourself: Add a /api/echo endpoint

Goal: send a message and get it back.

Instructions

1. Create a new route GET /api/echo?msg=hello
2. Return { echo: "hello" }

 app.get("/api/echo", (req, res) => { const msg = String(req.query.msg || ""); res.json({ echo: msg }); }); 

Try It Yourself: Add a simple “build version”

Goal: show what version is deployed.

Instructions

1. Set an env var APP_VERSION in Elastic Beanstalk
2. Show it on /health

 app.get("/health", (req, res) => { res.json({ status: "ok", version: process.env.APP_VERSION || "dev" }); }); 

Try It Yourself: Create a simple “deploy notes”

Goal: build the habit of documenting changes.

Instructions

1. Add a file CHANGELOG.md
2. Write 2 lines per deploy update
3. Commit changes if you use Git

This habit makes real projects much easier.

✅ Deployment Checklist

🧠 Mini Quiz

❓ FAQ

Quick answers to common questions about deploying to AWS.

📚 Recommended Reading

• REST API Tutorial: Build and Use Your First API Step-by-Step
• GraphQL Introduction: Learn Queries and Mutations Step-by-Step
• GitHub Tutorial for Beginners: How to Use GitHub Step-by-Step
• Developer Tools Hub: Free Online Utilities for Programmers
• Frontend Basics Hub: HTML, CSS & JavaScript (Beginner Roadmap)