DEV Community: Jake Flavin

8 Final Rounds. 8 Rejections. Zero Feedback. Is This Normal?

Jake Flavin — Mon, 23 Mar 2026 15:11:59 +0000

I was laid off in January. Since then, I’ve been grinding through one of the most demoralizing job searches of my career. I need to ask, is anyone else experiencing this?

The Gauntlet

Let me paint the picture. I’ve made it to the final round of interviews 8 times. Not first-round screens. Not second-round cuts. Final rounds. Eight of them.

Each one looked something like this:

✅ Technical phone screen
✅ Hiring manager interview
✅ Observed live coding / programming challenge
✅ System design interview
✅ Cultural / values interview

We’re talking 5+ hours of interviews per company. Not counting the prep time. The LeetCode grinding. The system design review. The company research. The mock interviews. Conservatively, I’ve put hundreds of hours into this job search since January.

And every single time? Rejection.

The Response That Broke Me

I get it. Rejection is part of the process. But here’s what’s actually killing me. This is the kind of response I keep receiving:

“The team truly had a difficult decision to make, but they ultimately felt another candidate’s experience was better aligned with the project work ahead. That being said, they had positive remarks to make overall about your experience and performance, and if we had another role suited to your skills and interests, I am quite confident we would have landed at a different decision.”

Read that again. What does it tell me? Absolutely nothing.

What was the “project work ahead”?
In what way was the other candidate more aligned?
What specifically was positive about my performance?
What would I need to do differently to win next time?

It’s a corporate non-answer dressed up in warm language. It’s designed to make me feel okay while giving me zero actionable information. I wouldn’t be surprised if this was AI generated.

I’ve Pushed Back. It Doesn’t Help.

I’m not passive about this. Every time I get a rejection, I go back to the recruiter and ask directly:

“I really appreciate the opportunity. To help me grow as a candidate, could you share any specific feedback from the panel. Areas where the other candidate stood out, or anything I could improve on?”

The response is always some variation of the same non-answer. Sometimes they go quiet entirely.

I understand there are legal reasons companies avoid giving detailed feedback. I understand recruiters are juggling pipelines and don’t always have direct access to interviewer notes. I get it logically.

But emotionally? After pouring 8+ hours into a single company’s process (evenings, weekends, rescheduled plans), getting “we went with someone more aligned” feels like a slap.

The Real Cost Nobody Talks About

Here’s what the lack of feedback actually costs candidates:

You can’t improve what you can’t measure. If I bombed the system design round, I’d want to know, so I can practice. If my communication style was unclear during the coding challenge, tell me. If there was a skills gap I could close, I’ll close it. But when every door shuts with the same non-answer, you start to wonder: Am I bad at this? Or is the process just broken?

After 8 final-round rejections, I genuinely can’t tell.

I’m Not Asking for Much

I’m not asking for a detailed performance review. I’m not asking for legal liability. I’m asking for one honest sentence:

“Your system design answers lacked depth around scalability.”
“We needed someone with more hands-on experience in X.”
“The team felt the culture fit wasn’t quite right, particularly around Y.”

That’s it. One real sentence. Something I can act on.

Instead, I’m flying blind. Preparing the same way for the next final round, with no idea whether I’m making the same mistakes over and over.

Is Anyone Else Seeing This?

I can’t be alone in this. The tech job market has gotten brutally competitive, and companies have the luxury of being selective. But has the feedback loop completely disappeared?

I’d genuinely love to hear from other engineers:

Have you made it to final rounds repeatedly and been rejected without feedback?
Have you ever actually gotten useful feedback from a recruiter after a rejection?
For anyone who works in hiring, is there a way to actually get real information out of this process, or is the wall intentional?

Because right now, I’m putting in the work, making it further than most candidates, and still coming home empty-handed with nothing to show for it except a tighter LeetCode streak and a growing frustration with a hiring process that feels increasingly performative.

If you’ve been through this, or if you’re in it right now, I’d love to commiserate in the comments. And if you’ve cracked the code on getting real post-rejection feedback, please share. The rest of us need it.

OpenAI API Example in NodeJS

Jake Flavin — Thu, 02 Feb 2023 17:55:05 +0000

Back in November, OpenAI announced that developers can begin building apps with the DALL·E API. I wanted to play around with it, so I made a simple CLI for it and wanted to share how easy it is to get started using their API.

(If you don't want to read the article and just want to see the final code, you can view that here.)

Prerequisites

You must have NodeJS installed on your machine.
You should already have an OpenAI account. If you do not have an account, you can use this link to sign up.

Set Up

First lets set up a new NodeJS project for our CLI. OpenAI has conveniently made a library for us to use. We will be using that as well as Commander to help with making the CLI portion of that app. Our package.json looks like this:

  "name": "open-ai-example",
  "version": "1.0.0",
  "description": "An example application that integrates with OpenAI API.",
  "main": "generate.js",
  "keywords": [],
  "author": "Jake Flavin",
  "license": "ISC",
  "dependencies": {
    "commander": "10.0.0",
    "openai": "3.1.0"
  }
}

Using the OpenAI API

Next, lets create a folder called api and add a new file in it called openai.js. Your project structure should look like this:

open-ai-example/
├── api/
│   ├── openai.js
└── package.json

The API for creating an image needs 5 params total, which includes your API key. You can find your API key in your OpenAI account settings. For this example, we will only be accepting 2 of the params as CLI argument and the rest will be hard coded.

First, lets create a shell of a method that accepts the API key and a prompt.

const { Configuration, OpenAIApi } = require("openai");

async function createImage (prompt, key) {
    return "";
}

module.exports = {
    createImage
}

Next, we will need to create and configure our OpenAIApi object. There are a few different configuration options available, but the only required item is the API key. Our plan is to accept the API key as a CLI argument, so we just need to make sure we pass that value along here.

const { Configuration, OpenAIApi } = require("openai");

async function createImage (prompt, key) {
    const openai = new OpenAIApi(new Configuration({
        apiKey: key
    }));

    return "";
}

module.exports = {
    createImage
}

Now that we have our configuration ready, we can start to make use of the createImage method given to us. This method accepts a createImageRequest object. We will set the prompt via the input param and hard code the rest.

const { Configuration, OpenAIApi } = require("openai");

async function createImage (prompt, key) {
    const openai = new OpenAIApi(new Configuration({
        apiKey: key
    }));

    const response = await openai.createImage({
        prompt: prompt,
        n: 1, // number of images to generate, OpenAI charges per image generated
        size: "256x256", // this is the cheapest image size
        response_format: "b64_json" // the format we want the data returned
    })

    return "";
}

module.exports = {
    createImage
}

Finally, we want to return the image. We asked OpenAI for one image in base64 format, therefore we can pull out the base64 string and return it.

const { Configuration, OpenAIApi } = require("openai");

async function createImage (prompt, key) {
    const openai = new OpenAIApi(new Configuration({
        apiKey: key
    }));

    const response = await openai.createImage({
        prompt: prompt,
        n: 1, // number of images to generate, OpenAI charges per image generated
        size: "256x256", // this is the cheapest image size
        response_format: "b64_json" // the format we want the data returned
    })

    return response.data.data[0].b64_json;
}

module.exports = {
    createImage
}

Putting the CLI Together

Next, we will create a new file that will be responsible for the CLI set up that will eventually call the createImage method we just created. Lets call that file generate.js.

Your project structure should not look like this:

open-ai-example/
├── api/
│   ├── openai.js
├── generate.js
└── package.json

Now we can start setting up our CLI. We can name our program "generate".

const { Command } = require('commander');

const program = new Command();

program.name('generate')
    .description('CLI to generate products.')
    .version('1.0.0');

program.parse();

We can add a new command that will call our new createImage method. We will need to tell commander what arguments and options we want to accept. We want the propmt as the first argument and the API key as a option.

const { Command } = require('commander');
const openai = require("./api/openai");

const program = new Command();

program.name('generate')
    .description('CLI to generate products.')
    .version('1.0.0');

program.command('image')
    .description('Generate an Image (using OpenAI\'s DALL·E API)')
    .argument('<prompt>', 'The prompt to generate the image from.')
    .option('--key <key>', 'Your OpenAI API key.')
    .action(async (prompt, options) => {
        const base64Image = await openai.createImage(prompt, options.key);
        console.log(base64Image)
    });

program.parse();

We can now test by running our CLI. Make sure you use your own API key.

node generate.js image "cat in space" --key "<API_KEY>"

iVBORw0KGgoAAAANSUhEUgAAAQAAAAEACAIAAADTED8xAAAAaGVYSWZNTQAqAAAACAACknwAAgAAACkAAAAmkoYAAgAAABgAAABQAAAAAE9wZW5BSS0tYTIxYmJmNTU0YjMxZTUwNDEzOGZiYTNjYmYzMDg5MDQAAE1hZGUgd2l0aCBPcGVuQUkgREFMTC1FAAuqeMkAAQAASURBVHgBACuB1H4BCwwU/Pv6BwcJ/v8B/Pv6/f/6AQD9BgUOCgoP9PXv//7+AgIGCwoQ+fr3/f36//35/P38AQEDAgMCBAIHBgcK9vb1BAUF/Pv7AQH//v39BAIIAgEF/QD+CwkWAQH+9Pbp//4AAAEADwwd8e72Cwkc//4HAgIG///7+fj0AQEHAP8IAgIK/v0GAwANAwAP/f4GAQAHAQIGAQAFAwAP/AD9Af8DAwEQAQEIEB0PPhcZCdwBHwwAQUcFFBr98+79/QD8AwIB6OH78PkBCgwRBPn8G0QJ2OTl7dX/AN78Dfv1HRIIyern8REA+e3z//j/FAADC/oGCAAA1/PW9RMW5/TRBvrp7/33CAIEEgcIAgP4AwYU4Pj7+wfuBwED//oBBAEK//X4HAkPJwIaBfwE+f8F7v0ICQUUIBIX6+fYBgL//f//7P397f4A+gEIAf8F8gAC6gIH/AAD+QP88gD39f/n/Pvn/gL5/wEABgME///7BgUD+/v3AP8F/wH9AAH//gEB+wD0+P3s/v/3BAIBCQgYAAEJ+frs/f75//79AQMECAYOAP79BgkF/f/3Awb/BgIL9PTq/gL0/f76+/z3BQQKBwcK///++vv7AP7+/f76/f/2AwIBAAECCggNAQAD+vr4/wD/BAYDBQQH/gABAP8ACgoM+Pn5+fr4/gH8/vz8Af8FBAMI9PbvDw8J+Pfz+/v5/Pr8BAYFAwQJDgsQ/Pr58vPrAQID///8/P76AwMFBAME+/r4AAAD/v/9CQkMAAH+9/b1BAUB/fz6///9AAADAAAB////AgICAAEA/v78AP8BAgICAAEB/v79/v7+AQICAQAAAgIDAAAB///+AP///wD/AP//AQEDAQEC//8A/wD9AgEDAgIB+vr5AQIA//8BAgEB/v/+AQICAP////8ABwYI/f/9AP//+/v6AAH/Af8AAAABBQQG/Pz6AQEBAgME//79/v8BAgMDAAD/AwIDAQMC/Pv6//8AFhUg7u/p/fz5AgEEBgcF+Pn2AQAA/fz8BPv7+AAAAfz8+v//BAQEBgD8/P///fz8+fLy7gAA/....

If you see a long base64 string be printed to the console, congrats! You have successfully used OpenAI's DALL·E API.

Finally, lets write the base64 string to the file system so we can see the image that is generated. We will add a new option for the file location with a default value.

const { Command } = require('commander');
const openai = require("./api/openai");
const fs = require ("fs");

const program = new Command();

program.name('generate')
    .description('CLI to generate products.')
    .version('1.0.0');

program.command('image')
    .description('Generate an Image (using OpenAI\'s DALL·E API)')
    .argument('<prompt>', 'The prompt to generate the image from.')
    .option('--key <key>', 'Your OpenAI API key.')
    .option('--file', 'The file location you want the image to be placed.', 'image.png')
    .action(async (prompt, options) => {
        const base64Image = await openai.createImage(prompt, options.key);
        fs.writeFile(options.file, base64Image, {encoding: 'base64'}, function(err) {
            console.log('File created.');
        });
    });

program.parse();

Now we can re-run the same command and we should see a new image be created on the file system.

node generate.js image "cat in space" --key "<API_KEY>"
File created.

This is the image that was generated with this prompt. I might print it and frame it.

You can view the final result here in my github repo. Let me know what you think!

done;