DEV Community: sam lee

Why Instagram Adds "AI Info" to Your Photos (and a way to fix it in the browser)

sam lee — Mon, 09 Mar 2026 05:31:04 +0000

Instagram and a few other platforms are now reading metadata in your images to detect AI-generated content. They look at things like C2PA and certain EXIF fields, then add an "AI Info" label. You can’t turn it off in the app.

I ran into this after using an AI upscaler on a photo. The image was mine, but the platform still tagged it. Fair enough from their side, but not great if you only used AI for small edits and don’t want every post labeled that way.

I looked for tools that could strip the relevant metadata. A lot of options were either desktop software or sites that asked you to upload everything to their servers. I didn’t want to hand over my images.

I ended up using a browser-based tool that runs locally. You drag in the image, it removes C2PA and the related EXIF data, and you download a clean file. No uploads, no signup. I used it on a few photos before posting and the labels stopped appearing. If you’re in a similar situation, removeailabel.com does this and is free to use.

I’m also curious how different platforms handle it—Instagram vs Pinterest vs TikTok—if you’ve seen any differences.

Building a Gold Price Calculator with Next.js and a Dual-API Fallback

sam lee — Fri, 13 Feb 2026 14:04:20 +0000

When I set out to build a gold value calculator—something users could use to check melt value by weight and purity—the first thing I had to figure out was where to get live gold prices. Most financial data APIs are paid or rate-limited, and I needed something that could handle production traffic without breaking.

The API Landscape

I looked at a few options:

GoldAPI.io — straightforward REST endpoint, returns XAU (gold) price per troy ounce. Free tier: 100 requests/month. Paid plans scale from there.
MetalpriceAPI — similar concept, supports multiple metals and currencies. Also has a free tier with monthly limits.
Metals-API, Kitco, etc. — various pricing and feature sets.

I didn’t want to depend on a single provider. If one API went down or hit rate limits, the whole calculator would fail. So I designed a primary + fallback pattern: try GoldAPI first, then MetalpriceAPI if that failed.

Handling Different Response Formats

The tricky part was normalizing the responses. GoldAPI returns price per troy ounce directly. MetalpriceAPI’s “latest” endpoint uses rates.USDXAU for “1 ounce of XAU = $X” — but their docs warn that some setups return XAU (how much gold you get per $1) instead, so you have to check and use 1/XAU when needed. I ended up with a small adapter that maps both provider responses into a common structure: 24K price per gram, then derive 14K, 18K, etc. from purity ratios.

Server-Side Caching and SSR

Since gold prices don’t change every second, I used Next.js unstable_cache (or equivalent) to cache the API response on the server. That way:

The first request populates the cache.
Subsequent requests use cached data for a set TTL (e.g. 15 minutes).
The initial HTML includes real prices for SEO and fast first paint, instead of empty placeholders.

The client then hydrates and can refetch on currency change or user interaction, but the initial load is server-rendered with real data.

Timeouts and Error Handling

Both APIs can be slow or unavailable. I added a 15-second timeout per request. If the primary provider times out or returns 429, we immediately try the fallback. If both fail, we fall back to a static price (with a clear “stale data” indicator) so the UI doesn’t break. Users still get a usable calculator; they just see that the price might be outdated.

What I’d Do Differently

Rate limit awareness: On the free tier, 100 requests/month sounds like a lot until you realize server-side fetches + client refreshes can burn through that quickly. Caching is essential.
Webhook or scheduled job: For a higher-traffic app, I’d consider a cron job that fetches prices periodically and stores them (e.g. in a DB or KV store), so the app reads from storage instead of calling external APIs on every request.

If you’re working with commodity or metal price APIs, the same patterns apply: normalize responses, cache aggressively, and always have a fallback. The calculator I built is live at MyGoldCalc if you want to see the result—supports grams, troy ounces, and common purities like 10K, 14K, 18K, 22K.

A Free Chronological Age Calculator (And Why Small Utilities Still Matter)

sam lee — Tue, 10 Feb 2026 16:28:47 +0000

If you've ever had to fill in "chronological age at date of testing" on a form—assessment, IEP, or clinical report—you know the pain: count months and days by hand, watch for leap years, double-check. One wrong month and the whole thing feels off.

I stopped doing that and started using a free online chronological age calculator. Two dates in (e.g. birth date and test date), exact age out in years, months, and days. No signup, no install. It runs in the browser and handles leap years and variable month lengths correctly.

Why this matters (especially in schools and clinics)

In education and clinical settings, age often has to be exact—years, months, and days—for standardized assessments (e.g. Pearson) and paperwork. Manual counting is error-prone. A small utility that does one thing well reduces mistakes and saves time. Plus: no account and no stored data means it's safe to use and to recommend on shared devices.

The tool I use

When I need precise chronological age for forms or reports, I use Chronological Age Calculator. Free, no account, and the logic matches what assessment manuals expect so numbers stay consistent.

Takeaway

Single-purpose tools—one input, one output, no fluff—still have a place. If you regularly need "age at testing" in years, months, and days, bookmark one solid calculator and move on to the actual work.

If you have a similar "small tool" you rely on (age, date diff, units, etc.), drop it in the comments.

Building a Production-Ready Square Image Editor with Next.js: Lessons from SquareImage

sam lee — Thu, 15 Jan 2026 02:20:03 +0000

As a full-stack developer who recently built a square image editor, I want to share how Next.js enabled us to create a performant, SEO-friendly tool that handles client-side image processing efficiently.

Technical Architecture Highlights:

Next.js 14 with App Router: Leverages React Server Components for initial page load performance while maintaining client-side interactivity

Client-Side Image Processing: All image manipulation happens in the browser using Canvas API, ensuring zero server costs and maximum privacy

Dynamic Imports: Heavy components like the image editor are lazy-loaded to reduce initial bundle size

Responsive Design: Tailwind CSS with mobile-first approach ensures consistent experience across devices

Key Technical Decisions:

javascript
// Example of our dynamic import strategy
const ImageEditor = dynamic(() => import('@/components/image-editor'), {
loading: () =>
});

Why This Architecture Works:

SEO Optimization: Next.js SSR ensures our tool pages rank well for terms like "free square image maker"

Performance: Edge caching and optimized images via Next.js Image component

Scalability: Static generation for landing pages, client-side rendering for the editor

The entire project is built with TypeScript and includes comprehensive structured data markup. You can explore the live implementation at: squareimage

For developers interested in building similar tools, I recommend starting with Next.js for its excellent developer experience and production-ready features out of the box.