Skip to content
BSWEN
Blog

Why JavaScript Promises Are a Red Flag for Junior Developers in 2026

Cowrie
Cowrie
Dev @ Bswen

Problem

I interviewed a junior developer yesterday who couldn’t explain JavaScript promises. They said “I mostly use async/await now” when I asked about promise handling. That’s when I knew this was going to be a tough interview.

This isn’t about being difficult. It’s about understanding that in 2026, promises aren’t optional knowledge - they’re fundamental to building any real JavaScript application.

The quote that stuck with me: “One of the biggest red flag for me is someone who doesn’t understand javascript promises

Why Promises Are Non-Negotiable

JavaScript Promises are a red flag because they reveal whether someone understands how modern web applications actually work.

Think about your typical day as a frontend developer:

  • Every API call uses promises
  • Database operations are async
  • File system operations require promise handling
  • User interactions involve async events
  • Frameworks like React, Vue, Angular all run on promises
// This is what happens when you click a "Save" button
async function handleSave() {
  try {
    const response = await api.saveData(formData);
    const result = await response.json();


    // Success case
    showSuccess('Data saved!');


  } catch (error) {
    // Error case
    showError('Failed to save: ' + error.message);
  }
}

Under the hood, this async/await code is just syntactic sugar over promises. If you don’t understand promises, you don’t understand how your own code works.

What Juniors Get Wrong About Promises

Misconception 1: “Promises are just syntax sugar

No. Promises solve the fundamental callback hell problem:

// OLD: Callback hell - nested and hard to read
getUser(function(user) {
  getPosts(user.id, function(posts) {
    getComments(posts[0].id, function(comments) {
      console.log('All data:', { user, posts, comments });
    });
  });
});


// NEW: Promise chaining - flat and readable
getUser()
  .then(user => getPosts(user.id))
  .then(posts => getComments(posts[0].id))
  .then(comments => console.log('All data:', { user, posts, comments }))
  .catch(error => console.error('Error:', error));

Misconception 2: “I can just use .then() and that’s it

Missing error handling is a huge red flag:

// BAD: No error handling
fetch('/api/data')
  .then(response => response.json())
  .then(data => console.log(data));


// GOOD: Comprehensive error handling
fetch('/api/data')
  .then(response => {
    if (!response.ok) {
      throw new Error(`HTTP error! status: ${response.status}`);
    }
    return response.json();
  })
  .then(data => console.log(data))
  .catch(error => console.error('Failed to fetch:', error));

Misconception 3: “Async/await replaces promises

Async/await is built on promises. Understanding the underlying mechanism matters:

// This is what async/await actually compiles to
async function fetchData() {
  try {
    const response = await fetch('/api/data');
    const data = await response.json();
    return data;
  } catch (error) {
    console.error('Error:', error);
    throw error;
  }
}


// Is equivalent to:
function fetchData() {
  return fetch('/api/data')
    .then(response => response.json())
    .catch(error => {
      console.error('Error:', error);
      throw error;
    });
}

Critical Promise Concepts Every Junior Must Master

1. Basic Promise Operations

// Creating a promise
const fetchData = new Promise((resolve, reject) => {
  setTimeout(() => {
    const success = true;
    if (success) {
      resolve({ data: 'Hello World' });
    } else {
      reject(new Error('Failed to fetch data'));
    }
  }, 1000);
});


// Using the promise
fetchData
  .then(result => console.log(result))
  .catch(error => console.error(error));

2. Promise Composition - The Real Differentiator

This is where senior-level developers shine:

// JUNIOR: Sequential operations - slow and inefficient
async function loadUserData() {
  const user = await fetch('/api/users/1').then(r => r.json());
  const posts = await fetch(`/api/posts?userId=${user.id}`).then(r => r.json());
  const comments = await fetch(`/api/posts?userId=${user.id}`).then(r => r.json());
  return { user, posts, comments };
}


// SENIOR: Parallel operations - fast and efficient
async function loadUserDataParallel() {
  try {
    const [user, posts, comments] = await Promise.all([
      fetch('/api/users/1').then(r => r.json()),
      fetch('/api/posts?userId=1').then(r => r.json()),
      fetch('/api/comments?userId=1').then(r => r.json())
    ]);
    return { user, posts, comments };
  } catch (error) {
    console.error('Failed to load user data:', error);
    throw error;
  }
}

3. Real-World Promise Patterns

// Retry pattern
async function fetchWithRetry(url, retries = 3) {
  for (let i = 0; i < retries; i++) {
    try {
      const response = await fetch(url);
      if (!response.ok) throw new Error(`HTTP ${response.status}`);
      return await response.json();
    } catch (error) {
      if (i === retries - 1) throw error;
      await new Promise(resolve => setTimeout(resolve, 1000 * (i + 1)));
    }
  }
}


// Timeout pattern
async function fetchWithTimeout(url, timeout = 5000) {
  const timeoutPromise = new Promise((_, reject) => {
    setTimeout(() => reject(new Error('Request timeout')), timeout);
  });


  return Promise.race([
    fetch(url).then(r => r.json()),
    timeoutPromise
  ]);
}

Common Interview Questions That Separate Juniors from Seniors

Basic Understanding Questions

  1. “What are the three states of a promise?

    • Pending, Fulfilled, Rejected

  2. “What’s the difference between resolve and reject?

    • Resolve = success path, Reject = error path

  3. “How do you handle errors in promise chains?

    • Use .catch() or try/catch with async/await

Practical Scenarios

Question: “Fetch data from three APIs and combine results

// JUNIOR ANSWER:
async function getData() {
  const user = await fetch('/api/users/1').then(r => r.json());
  const posts = await fetch('/api/posts').then(r => r.json());
  const comments = await fetch('/api/comments').then(r => r.json());
  return { user, posts, comments };
}


// SENIOR ANSWER:
async function getDataEfficiently() {
  try {
    const [user, posts, comments] = await Promise.all([
      fetch('/api/users/1').then(r => r.json()),
      fetch('/api/posts').then(r => r.json()),
      fetch('/api/comments').then(r => r.json())
    ]);


    return {
      user,
      posts: posts.filter(p => p.userId === user.id),
      comments: comments.filter(c => c.userId === user.id)
    };
  } catch (error) {
    console.error('Failed to fetch data:', error);
    throw new Error('Data unavailable');
  }
}

Question: “Show me how to avoid callback hell

// Callback hell
getUser(function(user) {
  getPosts(user.id, function(posts) {
    getComments(posts[0].id, function(comments) {
      console.log('All data:', { user, posts, comments });
    });
  });
});


// Promises solution
getUser()
  .then(user => getPosts(user.id))
  .then(posts => getComments(posts[0].id))
  .then(comments => console.log('All data:', { user, posts, comments }))
  .catch(error => console.error('Error:', error));


// Async/await solution
async function getData() {
  const user = await getUser();
  const posts = await getPosts(user.id);
  const comments = await getComments(posts[0].id);
  return { user, posts, comments };
}

Framework Integration Proves Promise Understanding

If you can’t work with promises in frameworks, you can’t build real applications.

React with Promises

// Component making API calls
function UserProfile({ userId }) {
  const [user, setUser] = useState(null);
  const [loading, setLoading] = useState(true);
  const [error, setError] = useState(null);


  useEffect(() => {
    // This is promise-based async handling
    const fetchUser = async () => {
      try {
        setLoading(true);
        const response = await fetch(`/api/users/${userId}`);
        if (!response.ok) throw new Error('User not found');
        const userData = await response.json();
        setUser(userData);
      } catch (err) {
        setError(err.message);
      } finally {
        setLoading(false);
      }
    };


    fetchUser();
  }, [userId]);


  if (loading) return <div>Loading...</div>;
  if (error) return <div>Error: {error}</div>;
  if (!user) return <div>No user found</div>;


  return <div>{user.name}</div>;
}

Vue with Promises

// Vue component using async data
export default {
  props: ['userId'],
  data() {
    return {
      user: null,
      loading: false,
      error: null
    };
  },
  async created() {
    await this.fetchUser();
  },
  methods: {
    async fetchUser() {
      this.loading = true;
      try {
        const response = await fetch(`/api/users/${this.userId}`);
        if (!response.ok) throw new Error('User not found');
        this.user = await response.json();
      } catch (error) {
        this.error = error.message;
      } finally {
        this.loading = false;
      }
    }
  }
}

What This Means for Hiring in 2026

Based on real discussions with hiring managers on Reddit:

Why This is a Quick Filter

  1. Predictive of on-the-job success - If someone doesn’t understand promises, they’ll struggle with basic API calls, database operations, and user interactions.

  2. Demonstrates fundamental JavaScript literacy - Promises are everywhere. Not understanding them shows you haven’t built real applications.

  3. Framework integration requirement - Every major framework relies on promises. If you can’t work with them, you can’t use the framework effectively.

The Promise Understanding Test

Hiring managers use promise questions as a quick filter:

// Tell me what this code outputs
Promise.resolve(1)
  .then(x => x + 1)
  .then(x => x * 2)
  .then(x => console.log(x))
  .catch(x => console.error(x));


// Expected output: 4
// (1 + 1 = 2, then 2 * 2 = 4)


// What about this?
Promise.resolve(1)
  .then(x => x + 1)
  .then(x => { throw new Error('Oops') })
  .then(x => x * 2)
  .then(x => console.log(x))
  .catch(x => console.error(x.message));


// Expected output: Error: Oops
// The error propagates down the chain

Trial and Error: What I’ve Seen Work

What Doesn’t Work

  • Memorizing async/await syntax without understanding promises
  • Copying code from Stack Overflow without knowing how it works
  • Thinking promises are just “newer syntax” without understanding why they exist

What Does Work

  • Understanding the callback hell problem that promises solve
  • Knowing when to use Promise.all() vs Promise.allSettled()
  • Handling race conditions and timeouts properly
  • Writing clean, maintainable promise chains
// Promise.all() vs Promise.allSettled()
const promises = [
  fetch('/api/users/1'),
  fetch('/api/posts'),
  fetch('/api/comments')
];


// Promise.all() - fails fast if any promise fails
Promise.all(promises)
  .then(results => console.log(results))
  .catch(error => console.error('One request failed:', error));


// Promise.allSettled() - waits for all, shows failures
Promise.allSettled(promises)
  .then(results => {
    const successful = results.filter(r => r.status === 'fulfilled');
    const failed = results.filter(r => r.status === 'rejected');
    console.log(`Success: ${successful.length}, Failed: ${failed.length}`);
  });

Conclusion: Understanding Promises is Entry-Level, Not Senior-Level

In 2026, understanding JavaScript Promises isn’t what makes you a senior developer - it’s what makes you a competent developer.

The promise understanding test separates:

  • Those who can build real applications from those who only know syntax
  • Developers who understand async programming from those who don’t
  • Candidates ready to contribute immediately from those who need extensive onboarding

If you’re a junior developer: master promises. It’s not optional knowledge - it’s the foundation of modern JavaScript development.

If you’re a hiring manager: promise questions aren’t about being difficult. They’re about ensuring candidates have the fundamental understanding needed to succeed in 2026.

Final Words + More Resources

My intention with this article was to help others share my knowledge and experience. If you want to contact me, you can contact by email: Email me

Here are also the most important links from this article along with some further resources that will help you in this scope:

Oh, and if you found these resources useful, don’t forget to support me by starring the repo on GitHub!

Comments

Tags: