It is not a replacement for promises. It is just promises wearing a cleaner outfit. Here is how that clicked for me.

If you have already understood promises — what they are, why they exist, and how errors travel through a chain — then async/await is genuinely one step away. Not a big step. One small step.

The problem is most explanations treat it like an entirely new concept. It is not. Once I understood that, everything fell into place.

What promises already solved
Before getting into async/await, it helps to remember what promises fixed. Callbacks nested badly and errors stayed isolated — each function had no idea when something else in the chain failed. Promises fixed both of those things.

But promises still had their own friction. Every step needed a .then. Reading a chain of five operations still required some mental effort to follow. It worked, but it did not feel natural.

async/await did not come to fix a broken system. It came to make an already good system easier to read.

Two keywords. One job each.
async does one thing — it marks a function as one that contains waiting inside it. And it makes that function always return a promise, even if you return a plain value.

await does one thing — it pauses that line, waits for the promise to resolve, and hands you the actual value directly. Then moves to the next line.

That is the entire feature. Two keywords, two jobs.

The moment it clicks
Look at these two blocks of code. They do the exact same thing.

promises
fetchUser()
.then(user => fetchPosts(user))
.then(posts => fetchComments(posts))
.catch(err => handleError(err))
async/await
async function getData() {
try {
const user = await fetchUser()
const posts = await fetchPosts(user)
const comments = await fetchComments(posts)
} catch(err) {
handleError(err)
}
}
Same logic. Same behavior. Same error handling. The second one just reads like normal top to bottom code. No chaining, no callbacks, no mental gymnastics.

JavaScript is converting your async/await into promises behind the scenes anyway. You are not writing something different. You are writing something cleaner.

A question I had about async functions
When I first saw this:

example
async function greet() {
return "hello"
}

greet().then(val => console.log(val)) // "hello"
My first question was — does console.log actually print "hello" here? Yes it does. The async keyword secretly wraps your returned value in a resolved promise. The .then just unwraps it and gives you the value back.

In real code you would never write it that way. You would just use await inside another async function to get the value cleanly. But that example showed me something important — async functions always return a promise, even when it does not look like they do.

Error handling is just try/catch
With promises you used .catch at the end of a chain. With async/await you use the same try/catch you already know from regular JavaScript.

error handling
async function getData() {
try {
const user = await fetchUser()
const posts = await fetchPosts(user)
} catch(err) {
console.log(err) // catches anything that fails
}
}
Same behavior as .catch on a promise chain. If anything inside the try block fails, the error travels straight to catch. Nothing isolated, nothing silent.

The one performance mistake worth knowing early
Because await pauses execution, it is easy to accidentally write slow code without realizing it.

slow — runs one by one
const user = await fetchUser()
const posts = await fetchPosts()
const photos = await fetchPhotos()
If these three do not depend on each other, you are making them wait in a queue for no reason. The fix is Promise.all — it runs all of them at the same time and waits for all of them together.

fast — runs all at once
const [user, posts, photos] = await Promise.all([
fetchUser(),
fetchPosts(),
fetchPhotos()
])
Same result. Much faster. This is the one thing worth keeping in the back of your mind as you start building real projects.

The one line summary
async/await is just promises, written so it reads like normal top to bottom code. Nothing new underneath. No new mental model required. If promises made sense, this is just the cleaner version of the same thing.

The syntax will become muscle memory as you build things. What matters now is knowing you are not learning something entirely new — you are just learning a better way to write something you already understand.