DEV Community: wayknow

I shipped my first iOS app solo — App Store Connect was harder than the app

wayknow — Wed, 23 Sep 2026 06:48:41 +0000

I just shipped SnapCal, a barcode calorie tracker I built solo in about two weeks: SwiftUI, iOS 17+, zero third-party dependencies, 85 unit tests. Building it was fine. Getting it out the door taught me things no tutorial covers.

This is the list of what actually bit me — five traps, with the code and the commands.

1. The 404 that made my app look broken

SnapCal scans a barcode, asks Open Food Facts about it, then lets you log it. My HTTP layer was the standard shape:

private static func validateResponse(_ response: URLResponse) throws {
    guard let httpResponse = response as? HTTPURLResponse else {
        throw APIError.invalidResponse
    }
    guard (200...299).contains(httpResponse.statusCode) else {
        throw APIError.httpError(statusCode: httpResponse.statusCode)
    }
}

And APIError.httpError rendered as "Server error (404)".

Here's the thing: Open Food Facts returns HTTP 404 with {"status":0,"status_verbose":"product not found"} for any barcode that is well-formed but not in the database. That's not a failure — it's the most common answer you'll get. Coverage is heavily skewed by country:

Region	Products in OFF	Have calorie data (sample of 100)
Global	4,759,550	—
France	1,268,282	92
USA	972,695	90
Japan	44,641	—
China	1,683	51

So the expected outcome for a random package is "no data", and my app was greeting users with a red "Server error (404)". A tester told me: "some barcodes work, some say something went wrong — your server logic is broken." He was right, but not the way he thought: the API was fine, my error taxonomy was wrong.

The fix is one early return, before validation:

let (data, response) = try await withRetry { try await session.data(for: request(for: url)) }

// OFF returns 404 for "well-formed barcode, not in the database" — that's
// "nothing found", not "something is wrong". Return nil so the UI can offer
// manual entry instead of a scary server error.
if let httpResponse = response as? HTTPURLResponse, httpResponse.statusCode == 404 {
    return nil
}

try validateResponse(response)

And in the view, "not found" gets its own state with a way forward:

if let food = await store.searchByBarcode(barcode) {
    scannedFood = food
} else if store.errorMessage == nil {   // nil meaning: no error, just no data
    showNotFoundAlert = true            // "Product not found" + [Add Manually]
}

Then I went one step further: when you type in a food that isn't in the database, SnapCal stores it under that barcode in a dictionary of its own (userFoodsByBarcode, kept separate from the API cache so it never gets evicted). Scan the same product again and it resolves instantly, offline.

Takeaway: a "not found" is a state, not an error. If your empty state is dressed up as a failure, users will conclude your app is broken — and they'll be right about the experience even if they're wrong about the cause.

2. New developer accounts get asked for homework (Guideline 2.1)

The morning after I submitted 1.0, I got "Information Needed — Guideline 2.1". No bug, no rejection of the app itself. Apple wanted:

a screen recording on a physical device, running the latest OS, starting from app launch
purpose and target audience
setup instructions / demo credentials
every external service the app talks to
regional differences
anything regulated or third-party-licensed

If your app has accounts, UGC or paid content, the recording must show those flows — including account deletion, which is a hard requirement.

What I'd do differently: record that video before you submit. Mine was 3 minutes on an iPhone 15 Pro, and it was the only thing that took real time to produce after the fact. Everything else is copy: "no accounts, no login, no UGC, no IAP, so those flows don't exist; the only external service is Open Food Facts; nutrition data is ODbL v1.0."

Reply in the App Review conversation and paste the same text into App Review Information → Notes — Apple asks for both, and the notes carry over to future submissions. No new build is needed for a 2.1 reply; you just resubmit.

3. "Approved" is not "live", and my check was lying to me

I released 1.0, and then… nothing appeared. So I "verified" the store page by fetching it.

https://apps.apple.com/us/app/snapcal-barcode-calorie-log/id6812662105  → HTTP 200 ✅

It was not the app page. My IP geolocates to a storefront where the app wasn't distributed yet, and instead of 404ing, Apple quietly serves that storefront's Today home page. The status code tells you the server answered — it doesn't tell you which page you got. Read the title and the content, or ask Apple's lookup endpoint about your bundle ID:

curl -s "https://itunes.apple.com/lookup?bundleId=tech.wayknow.snapcal&country=us"

Even then, treat any single response as a hint rather than a fact — that index lags behind the storefronts and can be noisy. The ground truth for availability is App Store Connect → Pricing and Availability: mine listed 174 of 175 territories, with mainland China the only exception.

4. The app was missing from all of Europe, and nothing warned me

A couple of days after release, App Store Connect was still showing a banner I'd scrolled past: the EU Digital Services Act requires Apple to verify and display trader contact information for apps distributed in the EU, and an app with no declared trader status isn't distributed there at all. SnapCal simply wasn't reachable in any EU storefront.

The declaration lives at Business → Agreements → Compliance → Digital Services Act. Two choices:

"This is a trader account" — you enter address, phone and email, they get published on your App Store product page in the EU, you upload a document proving your business name and address, and you verify both email and phone with 2FA.
"This is not a trader account" — no contact information, click Done, you're finished.

SnapCal 1.0 is free, has no ads and no in-app purchases, so "not a trader" is the honest answer, and it's reversible. But the moment you sell anything — even a one-time unlock — you are a trader, and your address goes public across the EU. Worth deciding before you monetize, not after.

The storefronts came back within a day of declaring, and they came back on their own — no resubmission, no new build. SnapCal is now available in every storefront except mainland China, which needs an ICP filing.

5. Two submission-day traps

A pending agreement silently blocks every submission. Apple updated the Developer Program License Agreement. There's a banner about it on the Business page, and until the account holder reviews and accepts it, you cannot submit a new version. No error on the version page — the submit just isn't available. Fix: Business → Agreements → the "Free Apps" row → Review and Accept Terms.

Xcode Organizer can't see your archive. I built 1.0.1 with:

xcodebuild archive -project SnapCal.xcodeproj -scheme SnapCal \
  -destination 'generic/platform=iOS' -archivePath build/SnapCal.xcarchive

Organizer only lists archives in ~/Library/Developer/Xcode/Archives/. So when I opened Distribute App → Upload, the only archive on offer was the old 1.0 build, and Apple rejected it:

This bundle is invalid. The value for key CFBundleShortVersionString [1.0.0]
must contain a higher version than that of the previously approved version [1.0.0]  (90062)
Invalid Pre-Release Train. The train version '1.0.0' is closed for new build submissions  (90186)

Copy the archive into the folder Organizer watches, or just archive to the default location. And always confirm the version/build number Organizer shows before you hit Upload.

What I'd tell my past self

Treat 404 as data, not failure — and give "not found" a real UI.
Record the App Review video before submitting; new accounts get asked.
Verify launch by reading the page, not the status code — and check availability in App Store Connect, not in a public API that lags.
Declare the DSA trader status before launch; "not a trader" is reversible, "no declaration" costs you the EU.
Accept pending agreements and double-check which archive you're uploading.

None of this is in the app. All of it decided whether anyone could install it.

SnapCal is free: barcode scanning, no ads, no account, and everything stays on your device. It's available in every storefront except mainland China. 1.0.1 (recently- logged foods in Quick Add, one-tap delete, better "not in the database" handling) shipped on 2026-09-23; 1.0.2 followed on 2026-09-24 and only adds a one-time rating prompt (after 3 days and 5 logged items, once per version). If you want to poke holes in it, I'm around — the App Store link is here.

This post also lives on the WayKnow blog.

Building a Privacy-First Cookie Editor: CHIPS, Interceptors & Auto-Cleanup in MV3

wayknow — Mon, 24 Aug 2026 06:27:15 +0000

CrumbKit is a free, open-source cookie editor for Chrome. We released v1.2 in August 2026 with three features that required non-obvious Manifest V3 implementation work: CHIPS partitioned cookie support, a Set-Cookie response interceptor, and scheduled auto-cleanup rules. Here's how we built each one — and what we learned.

Full disclosure: I built CrumbKit. Everything below is from the actual codebase — no marketing fluff, no hand-waving.

1. CHIPS Partitioned Cookies — The New Third-Party Cookie

Chrome is phasing out third-party cookies in favor of CHIPS (Cookies Having Independent Partitioned State). A partitioned cookie is scoped to a specific top-level site — two different websites can each have their own cookie with the same name and domain, but they're completely isolated from each other.

This is a big deal for cookie editors because it means the traditional dedup key — name + domain + path — is no longer unique. Without handling partitionKey, you'd silently overwrite or lose cookies.

How we implemented it

The change touched four layers:

Cookie normalization: We added partitionKey to the normalized cookie object:

function normalizeCookie(cookie) {
  return {
    name: cookie.name,
    value: cookie.value,
    domain: cookie.domain,
    path: cookie.path,
    // ... other fields
    partitionKey: cookie.partitionKey || null
  };
}

Deduplication: The dedup key now includes the partition key. Two cookies with the same name/domain/path but different top-level sites are treated as distinct:

const key = `${c.name}|${c.domain}|${c.path}|${c.partitionKey || ''}`;

Export formats: All six export formats had to be updated. JSON includes the full partitionKey object. CSV serializes it as a JSON string. Set-Cookie headers add the Partitioned attribute. Puppeteer scripts pass the partitionKey through. The key principle: partition data is never silently dropped.

UI: Partitioned cookies show a blue "P" badge in the cookie list. The edit form displays the top-level site as read-only text with a hint: "(CHIPS — set by server)". Users can't edit the partition key because it's determined by the browser, not the cookie itself.

What we learned

Chrome's chrome.cookies API returns partitionKey on partitioned cookies, but most cookie editor tutorials and existing tools don't handle it. CookieJar was the only competitor we found with full CHIPS support. The lack of awareness around partitioned cookies is a real gap — as Chrome rolls out CHIPS more broadly, tools that don't handle it will silently produce incorrect exports.

2. Set-Cookie Interceptor — Watching the Network

One thing we noticed: developers often want to see what cookies a server is setting via Set-Cookie response headers, but Chrome's DevTools buries this in the Network tab. We wanted a one-click way to see, inspect, and add intercepted cookies.

The MV3 challenge

In Manifest V3, you can't use chrome.webRequest.onHeadersReceived to modify requests. But you can use it to observe them. The key is the extraInfoSpec parameter:

chrome.webRequest.onHeadersReceived.addListener(
  (details) => {
    // details.responseHeaders contains Set-Cookie headers
    for (const header of details.responseHeaders) {
      if (header.name.toLowerCase() === 'set-cookie') {
        // Parse and store the intercepted cookie
      }
    }
  },
  { urls: ['<all_urls>'] },
  ['responseHeaders']
);

The ['responseHeaders'] extraInfoSpec tells Chrome to include response headers in the event. Without it, you only get the request.

Data storage

We store intercepted cookies in chrome.storage.session — a volatile store that's cleared when the browser restarts. This is intentional: intercepted cookies are transient data (they're what the server tried to set, not what's actually in the browser). The store is capped at 50 entries to prevent bloat.

The service worker runs as a persistent-ish background script (MV3 service workers can be terminated), so we use a keep-alive port pattern to maintain the interceptor connection when the popup is open.

What we learned

The chrome.webRequest API is read-only in MV3, which is fine for an interceptor — you're watching, not modifying. But there's a gotcha: service workers can be killed by Chrome at any time. The interceptor needs to re-register its listener when the service worker starts up, not just when the extension is installed. We handle this with a chrome.runtime.onStartup + chrome.runtime.onInstalled double-registration pattern.

3. Scheduled Auto-Cleanup — Chrome Alarms as a Cron Job

The auto-cleanup feature lets users set rules like "delete all advertising cookies every hour" or "delete cookies older than 30 days every Sunday." Rules run in the background via chrome.alarms.

How it works

Each rule has a schedule (in minutes), a target (domain, category, or age), and a list of matching cookies. When the user creates a rule, we call chrome.alarms.create() with the interval. When the alarm fires, the service worker:

Gets all cookies via chrome.cookies.getAll({})
Filters by the rule's target (domain pattern, category, or age threshold)
Deletes matching cookies via chrome.cookies.remove()
Optionally sends a chrome.notifications notification

Classification in the service worker

Here's the tricky part: the popup's cookie classification uses a bundled tracking-domains.json file loaded via chrome.runtime.getURL(). But service workers can't access the DOM, so chrome.runtime.getURL() doesn't work the same way.

Our solution: the service worker uses inline classification — the same regex patterns as the main classification module, but hardcoded into the service worker. This avoids loading the JSON file in the background context. Domain-based matching (checking if a cookie's domain appears in the tracker list) is available when creating rules in the options page, where the DOM is accessible.

What we learned

chrome.alarms is Chrome's built-in cron job. It's reliable, survives service worker restarts, and is exactly the right tool for background tasks. The minimum interval is 1 minute, which is fine for cookie cleanup. One caveat: alarms don't fire while Chrome is closed. If the user has a "daily" rule and doesn't open Chrome for a week, it only fires once when they open the browser. This is acceptable for cookie cleanup — the cookies will still be there waiting to be deleted.

4. Six Export Formats — The Keyword Spam Trap

This isn't a technical challenge, but it's a lesson we learned the hard way. CrumbKit supports six export formats: JSON, Netscape, cURL, CSV, Puppeteer, and Set-Cookie headers.

When we submitted v1.2 to the Chrome Web Store, the listing was rejected for keyword spam. The automated审核 system flagged the enumeration of six format names in two places — even though every format name corresponds to a real feature. The system interpreted the comma-separated list of technical terms as SEO keyword stuffing.

Fix: reduce any format enumeration to three names maximum, use "and more" for the rest, and never repeat the same list in two places within the description. The CWS automated审核 treats repeated lists of technical terms as spam, regardless of whether they're real features.

The Bigger Picture: Why Free Matters

Every cookie editor on the market is either abandoned (EditThisCookie), paid (CookieJar at $4.99/month), or has ads (Cookie Editor). None of them hit all three: free, open source, and actively maintained.

CrumbKit is free because it's an acquisition tool for our product family. We make money from SnapMark and ClearJSON. CrumbKit is how developers discover WayKnow. The cookie editor market has no validated paid demand — EditThisCookie had 3M free users for a decade, Cookie-Editor has 2M free users. Making CrumbKit free maximizes reach.

The entire extension is under 85KB of pure vanilla JavaScript. Zero frameworks, zero build step, zero dependencies. The chrome.cookies API hasn't changed since 2016. This thing will run for years without maintenance.

Try It

CrumbKit is free, MIT open source, and on the Chrome Web Store and Edge Add-ons:

If you're building a Chrome extension and run into MV3 issues — especially with service workers, chrome.webRequest, or chrome.alarms — the CrumbKit codebase is a working reference. MIT licensed, so steal freely.

CrumbKit is part of the WayKnow product family — privacy-first browser tools with zero tracking and no sign-up required.

EditThisCookie Was Removed. A Malware Clone Took Its Name. Here's What to Use

wayknow — Thu, 13 Aug 2026 06:44:17 +0000

EditThisCookie had millions of users. It was the default answer to "how do I edit cookies in Chrome?" for a decade. Then Chrome's Manifest V2 platform was retired, the extension never migrated, and in late 2024 it disappeared from the Chrome Web Store.

What happened next is the part nobody warned anyone about: a malicious clone took its name.

The clone

An extension called "EditThisCookie®" — note the ®, the dead giveaway — appeared on the store and got downloaded by tens of thousands of people searching for the original. Security researchers confirmed it was malware: obfuscated code, phishing and ad-injection mechanisms, and the ability to steal sensitive data, especially when you were logged into Facebook.

Google eventually removed it. But think about what that means: people who just wanted to edit a cookie — the most innocuous developer task imaginable — installed malware, because the tool they'd trusted for years vanished without a farewell and the search results were a minefield.
That's the real lesson of the MV2 migration: a cookie editor is a session-instrument tool. It has access to your cookies on every site. When an unmaintained cookie editor dies, its name becomes a honeypot. Whatever you install next needs to be auditable.

The checklist I now apply to any cookie editor

MV3-native — if it's not built for Manifest V3, it's already dead, just not buried
Open source — a cookie editor that you can't audit is a liability you're choosing
Recent updates — check the store's "last updated" date
No lookalike branding — any extension that brands itself as "the replacement for the dead original" deserves extra scrutiny
The right permissions — cookies is expected; broad host permissions without a clear reason are not

What to actually use in 2026

I tested the current field so you don't have to re-run this gauntlet. Full disclosure: I built one of these (CrumbKit), so take my ranking with that in mind — I've flagged where mine is genuinely weak.

Chrome DevTools — the zero-install baseline. Right-click → Inspect → Application → Cookies. Fine for the occasional edit, painful as a daily workflow. No search across domains, no. export/import.

CookieMate — open source (MIT), MV3-native, and the one feature that matters most for ex-EditThisCookie users: it imports EditThisCookie's JSON backups directly. If you have an old export, this is the smoothest migration. Simple editor, no fancy extras.

CookieJar — the feature-rich contender: cookie classification, per-site privacy scores, profiles (dev vs. prod cookie sets), multiple export formats, CHIPS partitioned-cookie support.
Free tier plus a paid Pro tier. Honestly the closest thing to "EditThisCookie with a 2026 paint job."

CrumbKit — the one I built: everything free, MIT open source, zero network requests. Where it genuinely beats the others: a Set-Cookie interceptor that shows you which cookie a server just set (in the response headers) and adds it with one click — no other tool in this list does that. Plus scheduled auto-cleanup, 6 export formats (JSON, Netscape, cURL, CSV, Puppeteer, Set-Cookie headers), batch editing, profiles, and a privacy score. Where it loses: it's younger than the alternatives and I'm a solo maintainer — if you only edit a cookie once a month, DevTools is genuinely enough.

Migrating your old backups

If you still have an EditThisCookie export: CookieMate imports its JSON format directly, and CrumbKit imports JSON and Netscape. If you don't have a backup, re-login to your sites — the old cookies are gone either way.

The takeaway

The MV2 migration didn't just break extensions — it created a trust vacuum that scammers filled within weeks. The defense isn't "find the most popular replacement." It's "find the one you can audit." Open source, zero telemetry, and a recent update date beat a familiar name every time.

If you've got a horror story from the EditThisCookie aftermath — or a cookie workflow you can't live without — drop it in the comments. I'm building feature lists off those answers.

# CSS Scan Has 20,000 Users — Here's the Opportunity Everyone's Missing

wayknow — Fri, 07 Aug 2026 08:34:43 +0000

I spent last week digging into the CSS inspection tool market. I wanted to understand why the most recommended paid extension in this category — CSS Scan — has 20,000+ users despite charging a premium price for what is, at heart, a single-purpose utility.

Here's what I found.

The Numbers

CSS Scan is a Chrome extension that lets you hover over any element on a page and instantly copy its computed CSS. It's the tool front-end developers recommend on Hacker News, in blog roundups, everywhere.

Version: 4.5, last updated April 2026 (actively maintained)
Users: 20,000+ professional developers (their claim)
Price: $120 one-time license (list price — frequently discounted; 42% off at the time of writing, bringing it to $69), limited to 3 browsers simultaneously

So we have a category leader that's actively maintained, has real paying users, and a price tag that feels detached from what the tool actually does. That's the pattern I look for.

What Users Actually Complain About

The recurring theme across the store reviews is price, not bugs. The functionality is praised — hover-to-copy genuinely saves hours when you're trying to match a design or reverse-engineer a layout. But a one-time payment in the $69–120 range, license-activated with a 3-browser device limit, creates exactly the "do I really want to pay this much" hesitation that kills impulse conversions.

A browser extension that reads computed styles with a standard API — no server, no infrastructure, no recurring cost — priced like a design tool suite. That's the mismatch.

The Free Alternatives: Why None of Them Won

If the price is the problem, why hasn't a free alternative taken the crown? I looked at all of them.

| Tool | Price | The Problem |
|------|-------|-------------|
| CSSViewer | Free | The classic hover-view tool. Old, minimal updates — styles can break on modern pages |
| CSS Peeper | Free | The original big name in this space. Now ad-supported; users have turned on it |
| CSS Peek | Free | Nice and tiny, but no momentum — a curiosity, not a category player |
| Tailwind CSS Scan & Copy | Free | Focused on Tailwind conversion only, almost no distribution |
| ExtractCSS | Free | A newer free option with component extraction, but it's early — no track record |
| CSS Scanner (not Scan) | Free | A handful of users. Effectively dead on arrival |
| SuperDev Pro | Free tier | 50+ tools in one sidebar — a Swiss army knife, not a focused CSS tool |

The pattern is clear: everyone competing with CSS Scan is either free-but-neglected, ad-driven, or a side feature of a bigger product. Nobody has done what CSS Scan did — a focused, polished, paid hover-to-copy tool — at a price that doesn't feel insulting.

The One Weird Gap

Here's the thing that stood out to me most: the two paid players in this niche are CSS Scan at $69–120 (depending on the promo) and UI-Ray at $39. Both are one-time purchases. Both are locally processed. Both are functionally similar to each other.

Neither has moved down-market. There's no $15–19 version of this tool with modern polish, no-subscription, local-only. The demand is validated — 20K users proves developers pay for this. The price anchoring is proven — the $69–120 band is "established." That leaves the $19 band completely open.

And if you've ever shipped a Chrome extension, you know hover-detection + overlay + computed-style extraction is a weekend project with a good foundation — not a six-month engineering effort. The barrier to entry is low, which makes the fact that nobody's done it yet more surprising.

So I Built It

Update: this article got a bit of attention, and I decided to stop analyzing and actually ship it.

Full disclosure: I built the thing I described. CSSPick is live on the Chrome Web Store now — a hover-to-copy CSS inspector at $19 one-time, no subscription, everything computed locally in your browser. Same core interaction as CSS Scan: hover, click, copy — with
the CSS grouped into Color / Typography / Spacing / Size & Box / Background / Border & Shadow / Layout so you can grab just what you need.

Why $19? Because the pricing itself is the objection — and a one-time purchase at $19 hits the "sure, why not" range where utility tools actually convert. I'd rather have 500 paying users at $19 than 100 at $69, and so would the market, apparently.

It also asks for minimal permissions — activeTab + storage + scripting, no "access to all your data on all websites" warning when you install it. Free version is genuinely useful (inspect + copy single properties); Pro unlocks Copy All CSS and Copy Selector.

If you try it and the analysis was wrong somewhere — or the tool is missing something — tell me in the comments. Especially tell me: what's the CSS property or workflow you copy by hand every single day? That's the feature list I want to hear about next.

Build update

This article identified an opportunity: CSS Scan has 20K users but a 3.5★ rating, and users complain about the $95 price. I built
CSSPick to fill that gap.

$19 one-time (vs $95)
Free tier: view + copy single properties
Pro: Copy All CSS + Selector
100% local, minimal permissions, no tracking

Product Hunt launch today · Chrome Web Store
website

I Tested Every JSON Viewer After the Formatter Scandal. Here's What I Found.

wayknow — Thu, 06 Aug 2026 07:25:53 +0000

Remember JSON Formatter? The Chrome extension with 200K+ users that auto-formatted JSON in your browser? In mid-2026 it went closed-source, partnered with GiveFreely, and started injecting geolocation tracking plus donation popups into checkout pages. The developer's defense was "it's for charity." The community's response was a collective "uninstall immediately."

I'm a developer. I look at JSON all day — API responses, config files, debug dumps. I needed a replacement. So I tested every major JSON viewer on the market.

The Contenders

JSON Formatter (arnav-kr) — The spiritual successor

This is the most popular open-source fork. 60+ themes, collapsible toolbar, keyboard shortcuts for everything.

Good: Truly open source. Actively maintained. Works offline. The free tier is generous.

Catch: No large file support. Above ~5MB it starts to struggle. No JWT decoding, no advanced export formats. If you just need basic formatting, it's perfect. If you work with bigger data, keep reading.

JSON Viewer Pro (PatilWeb) — Power user's choice

300K+ users, 4.7 stars. Tree view, chart view, JSONPath with autocomplete, custom CSS. It's the most feature-rich free option.

Good: Breadcrumb navigation is genius. Chart visualization for numeric data. Active development (v7.1 as of October 2025).

Catch: Closed source. Smart UI is cool but sometimes doesn't trigger when you expect it to. Heavy — noticeably slower page loads on large JSON.

JSON Alexander (Wes Bos) — The celebrity pick

Built by Wes Bos specifically in response to the Formatter scandal. Clean, minimal, trustworthy by association.

Good: Dead simple. Interactive tree, path inspection, dark/light/auto themes. Built by someone the community trusts.

Catch: Feature-light compared to others. No search. No export. No large file handling. It's a formatter, not a toolkit.

JsonDiscovery — The different one

Instead of adding a toolbar, it transforms the entire page into an interactive explorer. Tree, table, and list views. Right-click context menus for copying paths and objects.

Good: Highest rated (4.88). Innovative UX. JORA query language with autocomplete.

Catch: Takes over the entire page — no way to see raw JSON side-by-side. Learning curve for the query syntax. Closed source.

Firefox Built-in — The one you already have

If you use Firefox, you already have a JSON viewer. Collapsible tree, syntax highlighting, search. It's fine.

Good: Zero install. Zero trust issues (it's the browser). Always there.

Catch: Chrome users are out of luck. No themes. No copy-to-path. No export. It's a viewer, not a tool.

The Pattern

Dealbreaker	arnav-kr	PatilWeb	Wes Bos	JsonDiscovery	Firefox
No large file support	✅		✅		✅
Closed source		✅		✅
Heavy / slow		✅
Too minimal	✅		✅		✅
Phones home?	❌	?	❌	?	❌

No tool was: fully open source + handles large files + privacy-guaranteed + feature-complete.

So I Built One

After two weeks of switching between tools depending on what I was doing, I built ClearJSON.

What it does

Formatting & Viewing:

Auto-detects JSON, JSON-LD, JSON:API, NDJSON — any JSON-like content type
Collapsible tree view with indent guides, element counts, and depth indicators
Syntax highlighting for all 7 JSON token types (strings, numbers, booleans, null, keys, punctuation, links)
10 free themes with automatic dark/light system following
Click-to-copy values, right-click for JSONPath or subtree
Auto-detected clickable links, hover-to-preview images (PNG/JPG/GIF/SVG/WebP)
Line numbers in raw view, status bar with node count/max depth/file size/parse time

Privacy — the reason I built it:

Zero network requests for free users. Not one. The extension has no analytics, no tracking, no accounts, no ads.
The Pro license verification is the ONLY network call, and only when activating a key.
All processing (parsing, formatting, rendering, search) happens on your device.

Pro features ($2.99/month, cancel anytime):

Virtual scrolling for 500 MB+ JSON files (Web Worker + streaming parser)
JWT auto-decode — detects eyJ... tokens, inline displays header + payload, highlights expiry
Regex search with match navigation and full-document highlighting
Multi-format export: CSV, TSV, YAML, TypeScript type definitions (recursive inference)
20 additional premium themes (Monokai, Dracula, Nord, One Dark, Solarized, Catppuccin, Tokyo Night, Gruvbox, and more)
Custom keyboard shortcuts

The Tech Stack (for the curious)

Vanilla JS + IIFE module pattern. Zero frameworks, zero build steps. 28 files, ~59KB zipped.
CSS variable-driven theming. 30 themes defined as key-value pairs, injected at runtime via <style> tag.
Streaming parser (Pro): Web Worker receives raw text in chunks, builds a flat node array, main thread renders only visible rows via virtual tree. 10,000+ nodes renders in under a second.
JWT decode: Regex match → Base64Url decode (handles - → +, _ → /, missing padding) → JSON.parse header/payload → inline render in tree view.
TypeScript type generation: Recursive inference with duplicate structure deduplication. Generates proper interface blocks for nested objects.
License server: Cloudflare Workers + D1 (SQLite). 7-day cache + offline fallback. Only called during key activation/verification.

Honest Limitations

Chrome/Edge only. No Firefox version yet (Manifest V3 vs V2 differences).
Free tier limited to 2MB files. This is a deliberate choice — virtual scrolling is complex infrastructure, and it's how the Pro tier makes money.
No JSONPath query. JSON Query Tool and JSON Viewer Pro already do this well for free. I'm not going to build a worse version just to check a box.
No JSON Diff. Same reason — Just JSON and JsonKing do it better, for free.
Still early. ~43 installs as of writing. The product is solid, the user base is not.

Why $2.99/month?

JSON viewers have exactly zero marginal cost. No servers, no storage, no API calls — which is precisely why an honest subscription works: the money funds maintenance and new features, never servers and never data harvesting. I spent two years selling ClearJSON as a one-time purchase and watched the market move past it — lifetime plans have quietly disappeared from paid extensions, and subscription is what users actually support. $2.99/month, cancel anytime, free tier stays fully functional.

Try it: ClearJSON on Chrome Web Store | Microsoft Edge Add-ons

Source: github.com/wayknow/clearjson (MIT)

What are you using to view JSON? Did I miss a good one?

I Tested Every Chrome Screenshot Extension. Here's Why I Built My Own.

wayknow — Tue, 04 Aug 2026 09:02:28 +0000

I Tested Every Chrome Screenshot Extension. Here's Why I Built My Own.

I take a lot of screenshots. Bug reports, design feedback, tutorial steps, competitor research — easily 20+ a day. So I went looking for the perfect Chrome screenshot extension. What I found was surprising.

The Contenders

I tested every major screenshot extension with 10,000+ users on the Chrome Web Store. Here's what I found:

GoFullPage — Great at one thing, useless at everything else

GoFullPage does exactly what the name says: full-page screenshots. It scrolls, stitches, and spits out a long image. 10/10 for that one feature.

But you can't capture just the visible area. You can't select a region. There are no annotation tools on the free tier. Want to draw an arrow? Pay up. It's a one-trick tool in a category that demands versatility.

Price: $1/month. Seems cheap, but over 3 years that's $36 for something that can't even draw a rectangle.

Awesome Screenshot — Awesome features, concerning privacy

Feature-wise, Awesome Screenshot is the most complete. Screenshots, screen recording, annotations, cloud sharing. It does everything.

But here's the catch: your screenshots go to their cloud. You need an account. The free tier nags you constantly. And the price? $72/year. For a screenshot tool. Over 3 years you're paying $216 — more than a Microsoft Office subscription.

Also, the extension is heavy. Like, noticeably-slows-down-your-browser heavy. No thank you.

FireShot — The one that broke my heart

FireShot was the closest to what I wanted. Full-page capture, annotation tools, PDF export, one-time purchase. I almost bought it.

Then I noticed: the paid version still has a watermark. "Captured by FireShot" sits at the bottom of every screenshot. You paid $40 and they still stamp their brand on your work.

Also: their PDF output is bizarrely bloated. A 3-page document hit 2.9MB. Their tech is aging, and there are rumors they're killing the lifetime option to go subscription-only.

Lightshot — The ticking time bomb

Lightshot is simple and fast. Click, drag, annotate, done. 3.2★ on the Web Store.

The problem? Screenshots uploaded to their server are automatically deleted after a few months. Their privacy policy is vague about what "deleted" means. Also, it completely breaks on Google Docs. If you're a heavy Docs user, Lightshot is unusable.

Nimbus — Feature overload

Nimbus has everything: screenshots, screen recording, video editing, cloud storage, team collaboration. It's trying to be an entire creative suite inside a browser extension.

The result? A cluttered interface that takes 10 clicks to do what should take 2. The free version adds a watermark. The paid version is $60/year. It's overengineered for what most people need.

The Pattern

After testing all five, a pattern emerged:

Dealbreaker	GoFullPage	Awesome	FireShot	Lightshot	Nimbus
Missing core modes	✅			✅
Cloud upload forced		✅		✅	✅
Paid still watermarked			✅		✅
Subscription only	✅	✅			✅
Bloat / performance		✅			✅

No single tool was: fully-featured + local-first + watermark-free + one-time purchase.

So I Built One

I'm a developer. I know my way around the Chrome extension APIs. How hard could it be?

Turns out: harder than expected. But also extremely satisfying. Here's what I built:

SnapMark — Screenshots + Annotation, 100% Local

7 capture modes:

Visible area (one click, instant)
Full page (auto-scroll with overlap blending for seamless stitches)
Region selection (drag to select, real-time W×H display)
Smart element selection (hover to detect DOM elements, click to capture)
Timer capture (3/5/10 second countdown — for dropdowns and tooltips)
Clean & Capture (remove ads, banners, cookie popups before capturing)
Batch capture (paste URLs, auto-capture up to 20 pages)

8 annotation tools:

Arrow, Rectangle, Ellipse, Text, Freehand, Blur/Mosaic, Step Numbers (①②③), Crop
Full IME support for Chinese, Japanese, and Korean text input
17 system fonts, 9 font sizes (12–144px)

What makes it different:

Zero data leaves your browser. Screenshots, annotations, exports — all local.
No account, no sign-up. Install and go.
Free tier is genuinely complete. 4 capture modes, all annotation tools, PNG export. No watermark on screenshots.
Pro is $39 one time. No subscription. One payment, lifetime access.

The Tech Stack (for the curious)

Vanilla JS + ES modules. Zero frameworks, zero build steps. The entire extension is ~80KB zipped.
Canvas 2D annotation engine. Full-resolution rendering (canvas.width = image.naturalWidth), CSS handles display scaling. Mouse coordinates are transformed from CSS space to canvas space.
Full-page stitching: 50px overlap between segments + Canvas gradient blending (destination-in composite) to eliminate visible seams.
IME text input: Transparent <textarea> overlaid on canvas during text editing. Same approach Figma and Excalidraw use. Handles CJK composition events natively.
PDF export: Hand-rolled Uint8Array builder. No PDF library. Minimal output size.
License server: Cloudflare Workers + D1 (SQLite). Optional — only for Pro verification. Free users never make a network request.

Honest Limitations

Chrome-only right now. Firefox and Edge versions are on the roadmap.
No screen recording. (Competing with Loom is a different product category.)
No cloud sharing by design. If you need team collaboration with shared links, this isn't your tool.
Still early. v1.4.0 just shipped. There will be bugs.

Why $39 Lifetime?

I hate subscriptions. Every screenshot tool charging $5-10/month is extracting way more value than they provide. The marginal cost of a screenshot tool is essentially zero — no servers, no storage, no API calls. Charging monthly for it feels dishonest.

$39 once, use it forever. If the math works, great. If not, the free tier is genuinely useful and I'll keep improving it regardless.

Try it: SnapMark on Chrome Web Store

Website: wayknow.tech/snapmark

Feedback welcome — especially on the annotation UX. What would make you switch from your current tool?

I Built a JSON Formatter After the Original Started Injecting Ads — Here's What I Learned

wayknow — Thu, 30 Jul 2026 07:57:39 +0000

A few months ago, the most popular JSON formatter Chrome extension (2M+ users) was sold. The new owners immediately closed the source, injected affiliate ads, and started tracking user
geolocation.

HN exploded. Developers fled. Five open-source alternatives appeared within a year.

But here's the thing that bothered me: all of them are free, and none of them have a business model.

This is exactly how we got here. A maintainer burns out, sells to the highest bidder, and 2 million users wake up to ads in their browser. The cycle just repeats.

So I built ClearJSON (https://wayknow.tech/clearjson.html). Not because the world needed another JSON formatter — but because it needed one that wouldn't betray its users.

What makes it different

100% local, verifiable in DevTools. Open the Network tab — there's nothing. Never connects to a server, never sends data anywhere. I can't track you even if I wanted to.

Handles 100MB+ JSON files without freezing. Every free alternative calls JSON.parse() on the main thread. That works fine at 2MB, not at 100MB. ClearJSON does the parsing in a Web Worker so
the browser stays responsive. This was the hardest part to build and the reason most alternatives skip it.

JWT auto-decoding. Half the reason I open JSON is to inspect JWTs. Click a token and it decodes the header + payload inline.

MIT license. Even if I disappear tomorrow, anyone can fork it. The license actually protects users this time.

The business model question

I charge $29 one-time for Pro (large files, JWT, exports, more themes, custom shortcuts). The free tier has everything most people need.

A few people have asked: "Why not just make it free? There are five free alternatives."

Because "free" is how the last one got sold. A one-time purchase with no recurring server costs means there's no incentive to sell out. No investors to please, no data to monetize. Just a
tool that works.

The MCP server (npx -y clearjson-mcp) is also MIT licensed — so AI agents can format and validate JSON directly, including large files that would crash other MCP tools.

What I'd do differently

Start marketing before shipping. I built the whole thing, launched, and then started thinking about distribution. Should have been building an audience in parallel.
The "betrayal" story is a hook, not a business. People upvote the drama, but they don't automatically buy the product.
CWS organic discovery is slow. Without reviews and installs, you rank on page 10. External traffic (blog, Reddit, HN) is the only way to bootstrap.

Links

Chrome Web Store (https://chromewebstore.google.com/detail/clearjson/bgcicghmdpefapfdeghgealacphkgobk)
GitHub (https://github.com/wayknow/clearjson) (MIT)
MCP Server on npm (https://www.npmjs.com/package/clearjson-mcp)
Full comparison of JSON Formatter alternatives (https://wayknow.tech/blog/json-formatter-alternatives.html)

Building privacy-first developer tools — no accounts, no tracking, one-time purchase

wayknow — Tue, 28 Jul 2026 06:12:25 +0000

Hey DEV! I'm building the WayKnow family of developer tools after getting frustrated with the state of browser extensions.

The origin story: The most popular JSON Formatter extension (2M users) was sold and started injecting ads + tracking geolocation. EditThisCookie (3M users) got killed by Manifest V2. I realized there was a gap for tools that are genuinely private, open source, and don't force subscriptions.

So far I've shipped:

ClearJSON — JSON viewer that handles 100MB+ files without crashing, $29 lifetime
SnapMark — Screenshot + annotation tool, $39 lifetime (vs competitors at $72/year)
CrumbKit — Free cookie editor, MIT licensed, minimal permissions
ColorPeek — macOS color picker for developers, $19 lifetime

Everything is local-first, MIT licensed, one-time purchase. No backend, no user accounts, no telemetry.

Happy to answer questions about building Chrome extensions, dealing with CWS review, or the buy-once business model!