Forem: Jake Flavin

Green Spaces: I Built a Community Memory Map for Earth Day 🌿

Jake Flavin — Sun, 19 Apr 2026 13:37:44 +0000

This is a submission for Weekend Challenge: Earth Day Edition

What I Built

Green Spaces is a community memory map where anyone can pin a natural space that matters to them and leave a short story about why. Trails, summits, parks, beaches, urban green spaces. Drop a pin, write something real, and it shows up for everyone in real time.

The map launches with seed data pulled from Pennsylvania locations (I'm Pittsburgh based and figured I'd start local), including a few spots from my own backpacking trips that I added personally. The idea is that over time it becomes a living record of places people actually love, not a list of "top 10 parks" some SEO article generated.

Demo

Live: Green Spaces DEMO
Add a pin and add your own memory. No account needed.

Code

jakeflavin / green-spaces

Green Spaces Memory Map

A community web app where users pin favourite natural spaces — trails, summits, parks, beaches, and urban green spaces — on a world map, attaching a photo and a short story. Anonymous contributions, no account needed.

Stack

React 19 + TypeScript + Vite — static SPA
Leaflet / react-leaflet — interactive map with custom SVG pins
Firebase — Firestore (real-time data) + Storage (photo uploads)
Tailwind CSS v3 — custom gs-* colour palette, dark mode via class strategy
exifr — EXIF GPS extraction from uploaded photos

Getting started

npm install
npm run dev

Command	Description
`npm run dev`	Start dev server with HMR
`npm run build`	Type-check + build to `dist/`
`npm run lint`	ESLint
`npm run preview`	Preview production build locally

Deploy

npm run build && firebase deploy   # Firebase Hosting
# or
npm run build && vercel --prod

Project structure

src/
  types/
    memory.ts              #

…

View on GitHub

How I Built It

I gave myself a weekend. It took about 5 hours total, working with Claude Code as my pair programmer throughout.

The stack:

React + Vite for the frontend
React-Leaflet for the map (more on this in a second)
Firebase Firestore for the real-time database
Firebase Storage for image uploads
Firebase Hosting for deployment
Tailwind CSS for styling
Google Gemini for seed data

I picked Firebase and Leaflet because I already knew them (my background is in geospatial mapping). That's the whole reason. When you have a weekend deadline, "familiar" beats "interesting" every time. No regrets.

The map interactions
This is the part I'm most happy with. Hit the pin button in the header and a panel slides in on the right with a form to upload a photo and write your story. That's it. No modal, no separate page, no typing coordinates manually.

The part I like most: when you upload a photo, the app reads the GPS EXIF data from the image and uses open APIs to reverse geocode it into a location name. Lat, lng, and location name all fill in automatically. If you took the photo there, you don't have to type anything except your story. Submit, and the pin appears on the map in real time for every user currently looking at it. No page refresh. That's Firestore's onSnapshot doing the heavy lifting.

Seed data with Google Gemini
I didn't want to launch with an empty map, so I used Google Gemini to pull together a set of Pennsylvania locations to pre-populate it. I used the chat interface to research and compile location data, then formatted it into the shape my app expected. It's a scrappy approach but it worked, and the map looks alive from day one instead of sad and empty.

I also used Gemini inside Firebase Studio to help think through my security rules. Being able to ask questions about my actual Firebase setup in context was genuinely useful. The rules are simple (public read, create-only with field validation, no updates or deletes), but having something that understood my project structure made it faster to get right.

The part that actually took the longest
Mobile layout. I knew going in that maps are annoying on small screens, and I was right. Getting the sidebar, the map, the panels, and the detail overlays to behave consistently across desktop and mobile took longer than building any individual feature. The final approach uses a responsive layout that collapses the sidebar on smaller viewports and leans into the map as the primary surface. It's not perfect but it's solid.

Personal pins
A few of the seed locations are spots from my own backpacking trips around the country. Honestly those are my favorite part of the app. There's something different about seeing a place you've actually stood on a map alongside other people's stories about places they've stood.

Prize Categories

Best Use of Google Gemini — used Gemini to research and compile the Pennsylvania seed location data that populates the map on launch, and used Gemini inside Firebase Studio to work through security rule logic against my actual project setup.

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;