DEV Community: Latest

Java 21 Quarkus AWS Lambda: My Production Serverless Stack

Amrendra N Mishra — Sat, 03 Oct 2026 05:58:25 +0000

The Problem With Cloud AI

Every token costs money. Every API call adds up. And your data goes to their servers.

The Local Alternative

brew install ollama
ollama pull llama3.2
ollama serve

Now you have a GPT-4 level model running on your MacBook. Free. Private. Fast.

Real Code Example

import requests

def ask_local_ai(question):
    r = requests.post(
        "http://localhost:11434/api/generate",
        json={"model": "llama3.2", "prompt": question, "stream": False}
    )
    return r.json()["response"]

# Works immediately, no API key needed
answer = ask_local_ai("Explain Docker in one paragraph")
print(answer)

Available Models

Model	Size	Best For
llama3.2	2GB	General use
codellama	4GB	Code tasks
mistral	4.4GB	Fast reasoning
phi3	2.2GB	Lightweight tasks
gemma2	5.4GB	Complex reasoning

What You Can Build

RAG systems for your documents
Voice assistants that work offline
Code reviewers on every git commit
Content generators at zero cost
Personal AI that remembers you

My Setup

I built 45 tools using this stack. All free. All local. All open source.

github.com/amrendramishra/ai-tools

VP at JPMorgan Chase. Building AI tools at amrendranmishra.dev

Backlink Monitoring and SEO Audits in Practice

Victor Disouza — Sat, 03 Oct 2026 05:58:17 +0000

Backlinks are still one of the strongest signals a search engine uses to judge a page — a link from another site is, in effect, a vote of confidence. But votes can be lost, redirected or turn toxic, so monitoring them is an ongoing job, not a one-off task. Here is how backlink monitoring and SEO audits work in practice.

What an SEO audit actually checks

A practical SEO audit looks at three layers:

Technical health — broken links, redirect chains, missing meta descriptions, mobile usability, and indexation status.
On-page content — title tags, heading structure, thin or duplicate content, and keyword coverage.
Backlink profile — who links to you, the quality of those linking domains, anchor text distribution, and whether links you once had have quietly disappeared.

Data from Google Search Console and Bing Webmaster Tools feeds the audit — clicks, impressions and indexing issues straight from the source — while PageSpeed data adds real performance numbers so you can see whether slow pages are costing you rankings.

Backlink monitoring: the daily watch

Monitoring is really about change detection. The events that matter:

Lost backlinks — a linking page is removed or the link is dropped. If it carried traffic or authority, you want to know quickly so you can ask for it back or reclaim it with a redirect.
New backlinks — fresh links to verify. Are they genuine editorial links, or low-quality spam you should disavow?
Anchor text drift — too much exact-match anchor text looks unnatural and can attract penalties.
Linking domain quality — a sudden flood of low-quality links can signal a negative SEO attack.

A daily or weekly report of gained and lost links turns this from guesswork into a routine you can act on.

What you do with the findings

A good audit produces a prioritised list of missions: fix the 404s, compress the images dragging down PageSpeed, write outreach emails to reclaim lost links, create content targeting gaps competitors already cover. When daily missions are generated from audit data, the work becomes a checklist instead of an overwhelming spreadsheet.

Outreach and content generation close the loop: you need linkable content before anyone will link to you, and you need systematic outreach to earn the links.

Doing this on a budget

You don't need an enterprise subscription. Start free: connect Google Search Console, run an audit, fix the technical issues first (they're free to fix), then build a weekly habit of reviewing gained and lost links. Freemium tools bundle this work for solo founders and side projects — RankRoot's Starter plan, for example, is free, with paid tiers (Solo $19/mo, Pro $29/mo, Agency $49/mo) as you grow.

Where tools fit

Services like RankRoot — an AI link-building and SEO copilot — combine SEO audits, daily missions, outreach and content generation, backlink monitoring, and Google Search Console / Bing / PageSpeed integrations, with a Chrome extension and WordPress plugin so the data is available where you work.

I work on RankRoot, an AI SEO copilot for link-building: SEO audits, daily missions, outreach and content generation, backlink monitoring, and GSC / Bing / PageSpeed integrations. Chrome extension + WordPress plugin; free Starter plan.

How Daily Gold Karat Prices Are Tracked and Calculated

Victor Disouza — Sat, 03 Oct 2026 05:57:30 +0000

Gold is one of the few things most people buy priced by purity. Walk into a jewellery shop in Riyadh or Dubai and the board behind the counter lists prices for 24K, 22K, 21K and 18K gold — each updated daily, often shown in both English and Arabic. But where do those numbers actually come from? Here is how daily gold karat prices are tracked and calculated.

It starts with the spot price

Every calculation begins with the international spot price of pure gold — the 24K benchmark quoted in US dollars per troy ounce. It is derived from continuous trading on global markets and moves around the clock, so the baseline never sits still.

Karat maths: from 24K down to 18K

A karat is a purity ratio out of 24. 24K gold is 99.9% pure gold. Every lower karat is a simple fraction of that price:

22K = 22/24 = 91.6% of the 24K price
21K = 21/24 = 87.5% of the 24K price
18K = 18/24 = 75% of the 24K price

So if a gram of 24K gold costs X, a gram of 18K gold is worth roughly 0.75 × X before anything else is added. These fractions are fixed maths — only the spot price moves.

Converting to local currency

The spot price is quoted in US dollars per troy ounce (31.1035 grams), so publishing a daily local price takes two conversions:

Ounce to gram: divide by 31.1035.
USD to SAR or AED: multiply by the prevailing exchange rate. Both the Saudi riyal and the UAE dirham are pegged to the US dollar, which keeps this step stable.

This is why the daily number can move even when the dollar price of gold is flat — any shift in the exchange rate shows up in the local price.

Why it updates daily

Because gold trades continuously across global markets, the spot price changes overnight while Gulf markets are closed. Daily updates capture all of that movement, so the morning board in a souk reflects last night's trading in New York and Asia.

What the board doesn't show

The published karat price is the metal's value. A shop's selling price adds VAT, the shop's margin and making charges — so two shops can quote slightly different retail numbers from the same base price. Knowing the base price first puts you in a much stronger position to negotiate.

Checking the daily number

Services like KaratIndex publish these daily karat prices — 24K, 22K, 21K and 18K — for Saudi Arabia and the UAE, in English and Arabic, so you can compare the day's base price before you shop.

I work on KaratIndex, a daily gold-price reference for Saudi Arabia and the UAE with karat prices in English and Arabic.

The test that passed on Windows and failed on Linux

pm25coder — Sat, 03 Oct 2026 05:56:58 +0000

My CI went red on a pull request that was, as far as I could tell, correct.

The change was small and boring: an OAuth helper in a CLI tool used to discover a free port by binding it, reading the number, and closing the socket — which leaves a window in which any other process can take the port before the callback server binds it. The fix binds once and hands the already-bound socket to the HTTP server, so there is no window. I measured it on my machine: with the old helper another process could take the port; with the new one it could not. I added a test, ran it, and pushed.

Then CI came back: Test 3.12, 3.13, Canary — all failed, on the Linux legs, while the identical suite was green on Windows on the same commit. The one failing test was the one I had just written:

OSError: [Errno 98] Address already in use
809 passed, 1 failed

The fix was fine. The test I shipped with the fix was not.

The test that broke

The test asked a simple question: after the OAuth flow finishes, is the redirect port released? And it answered it in the most obvious way — by trying to bind the port again:

def _port_is_free(port: int) -> bool:
    with socket.socket() as s:
        try:
            s.bind(("127.0.0.1", port))
            return True
        except OSError:
            return False

If a fresh listener can bind, the port is free. That is the intuitive phrasing. It is also the wrong instrument, and the reason is entirely about which states of a TCP connection a rebind is willing to forgive.

Attempt one: blaming TIME_WAIT

My first hypothesis was the classic one: the server has closed, but the connection sits in TIME_WAIT, and TIME_WAIT blocks a rebind. The standard fix for that is SO_REUSEADDR, so I set it on the probe socket and pushed again.

CI went red again — with a new signal that killed the hypothesis. The probe now returned False even with SO_REUSEADDR set. If TIME_WAIT were the cause, SO_REUSEADDR is exactly what would have forgiven it. It didn't, so the port was not merely in TIME_WAIT.

The tell was sitting right next to it. There were two tests: one where the flow completes (the failing one) and one where it does not. The sibling, which also rebinds the port, passed. The only difference between them was that in the failing test a client had actually connected and received a response. That points at a lingering accepted connection — a socket in FIN_WAIT_2 or ESTABLISHED — and SO_REUSEADDR deliberately does not forgive those. It forgives TIME_WAIT because a timed-out connection is genuinely gone from the application's point of view; it does not forgive a live connection because that would let two listeners fight over the same 4-tuple.

So the failure had two independent halves:

the probe used an instrument (bind) that is sensitive to connection state I did not control;
the test's fake client never closed its response, so a connection really was left hanging — a genuine leak in the test itself, the same kind of leak the production fix was about.

Attempt two: change the question, not the port

The fix was to stop asking "can something bind here" and start asking "is anything still listening here":

def _nothing_is_listening(port: int) -> bool:
    with socket.socket() as s:
        try:
            s.connect(("127.0.0.1", port))
            return False          # something answered
        except (ConnectionRefusedError, OSError):
            return True           # nothing there

A connect() that is refused tells you there is no listener — and it does not care what state some old connection is in, because it never touches that connection's 4-tuple. That is the property I actually wanted to assert: "the server is gone", not "the kernel will let me rebind". I also closed the response in the fake client, removing the leak underneath.

CI returned 5/5 green.

Proving the probe isn't vacuous

A negative assertion has a failure mode that a positive one does not: it can be vacuously true. A probe that always says "nothing is listening" would pass the test perfectly and tell you nothing. So I added a control arm that runs the same probe against three states:

state	`_nothing_is_listening`
a listener is up	`False`
listener just closed, cleanly	`True`
a connection lingers, no listener	`True`

The first row is the one that matters: the probe can return False, so the True in the test means something. Without that row, "nothing is listening" is an unfalsifiable claim.

What generalises

Three things, and none of them are about OAuth or Python.

A fix's own test is part of the fix. The pull request was not "the socket handoff"; it was "the socket handoff and a test that verifies it on every platform the suite runs on". A green local run on one OS is a sample, not a verdict — and when a CI leg fails where you did not look, the bug is often in the instrument, not the code.

For a negative assertion, choose an instrument that is insensitive to the state you do not control. "The port is released" is a claim about the server being gone. bind-succeeds smuggles in an assumption about kernel connection bookkeeping; connect-refused does not. Pick the phrasing that says only what you mean.

Give every negative probe a control arm. A probe that cannot fail is not evidence. One extra case — the state in which it must return the other answer — is what turns "the test passed" into "the property held".

The second attempt was smaller than the first and took less time to write. The expensive part was not the fix; it was noticing that the instrument, not the code, was the thing that needed changing.

How Voice AI Is Making the Internet More Accessible

VoiceDeveloper — Sat, 03 Oct 2026 05:56:34 +0000

Why Voice AI Matters for Accessibility

The web was built to be a universal information highway, but for many people—those with visual impairments, dyslexia, or motor challenges—reading text on a screen isn’t always feasible. Voice AI bridges that gap by turning written content into natural‑sounding speech and, increasingly, by letting users speak to applications instead of typing.

From screen readers that read articles aloud to voice‑driven assistants that let you browse hands‑free, developers now have a toolbox that makes the internet genuinely inclusive. In this post we’ll explore the core pieces of voice AI, see how text‑to‑speech (TTS) and voice cloning are reshaping accessibility, and walk through a quick Python example using ElevenLabs—a modern TTS platform that delivers high‑fidelity, customizable voices.

The Building Blocks of Voice AI

Component	What It Does	Why It Helps Accessibility
Text‑to‑Speech (TTS)	Converts written text into spoken audio.	Gives sight‑impaired users instant auditory access to content.
Automatic Speech Recognition (ASR)	Turns spoken words into text.	Enables hands‑free navigation and input for users with motor limitations.
Voice Cloning	Replicates a specific speaker’s timbre from a short audio sample.	Allows personalized audio experiences, such as reading in a familiar voice for people with cognitive challenges.
Voice Activity Detection (VAD)	Detects when a person is speaking vs. silent.	Improves the responsiveness of voice‑controlled interfaces, reducing false triggers.

When you combine these pieces, you can build applications that listen, understand, respond, and speak—all in real time. The result is a more inclusive web experience where the barrier between a user and the content is a single voice command away.

ElevenLabs: A Developer‑Friendly TTS Engine

If you’ve tried older TTS services, you know the trade‑off between voice quality and flexibility. ElevenLabs (https://try.elevenlabs.io/kr07zfuqn1bp) offers a cloud API that produces ultra‑realistic speech while giving you granular control over tone, speed, and even speaker style.

Key reasons developers love it:

Neural‑level quality – The generated speech sounds like a human narrator, not a robot.
Voice cloning – Upload a 30‑second sample and get a custom voice you can reuse across projects.
Simple REST API – Works with any language that can make HTTP calls, plus official Python and JavaScript SDKs.

Below we’ll see how to integrate ElevenLabs into a tiny Flask app that reads any article aloud with a single endpoint.

Quick Start: Turning Text into Speech with Python

First, sign up for an API key at the ElevenLabs affiliate link: https://try.elevenlabs.io/kr07zfuqn1bp. Keep the key safe; you’ll need it for every request.

1. Install the SDK

pip install elevenlabs

2. Basic TTS Script

import os
from elevenlabs import generate, play, set_api_key

# Set your API key (never hard‑code in production!)
set_api_key(os.getenv("ELEVENLABS_API_KEY"))

def text_to_speech(text: str, voice_id: str = "EXAVITQu4vr4xnSDxMaL"):
    """
    Sends `text` to ElevenLabs and returns the audio bytes.
    """
    audio = generate(
        text=text,
        voice=voice_id,          # Use a default voice or a cloned voice ID
        model="eleven_monolingual_v1"
    )
    return audio

if __name__ == "__main__":
    sample = "Welcome to the future of web accessibility. With voice AI, everyone can consume content effortlessly."
    audio_data = text_to_speech(sample)
    play(audio_data)  # Plays back locally; you could stream to a client instead

voice_id can be any of the pre‑built voices listed in the ElevenLabs docs, or the ID of a cloned voice you created earlier.
model selects the neural model; the default eleven_monolingual_v1 works great for English.

3. Adding a Flask Endpoint

from flask import Flask, request, jsonify, send_file
from io import BytesIO

app = Flask(__name__)

@app.route("/speak", methods=["POST"])
def speak():
    payload = request.get_json()
    text = payload.get("text", "")
    voice_id = payload.get("voice_id", "EXAVITQu4vr4xnSDxMaL")

    if not text:
        return jsonify({"error": "Missing 'text' field"}), 400

    audio = text_to_speech(text, voice_id)
    audio_io = BytesIO(audio)

    return send_file(
        audio_io,
        mimetype="audio/mpeg",
        as_attachment=False,
        download_name="speech.mp3"
    )

if __name__ == "__main__":
    app.run(debug=True)

Now any client—browser, mobile app, or assistive device—can POST JSON like:

{
  "text": "Your article content goes here.",
  "voice_id": "EXAVITQu4vr4xnSDxMaL"
}

and receive an MP3 stream that can be played back instantly. This pattern is the backbone of many accessibility tools: fetch the article, send it to /speak, and let the user listen.

Voice Cloning in Action

Imagine a user with a cognitive disability who benefits from hearing information in a familiar voice—perhaps a family member’s. With ElevenLabs, you can create a personalized voice in under a minute:

Record a 30‑second sample of the target speaker (clear, noise‑free).
Upload it via the ElevenLabs dashboard or the /v1/voices/add endpoint.
Receive a voice_id you can plug into the text_to_speech function above.

from elevenlabs import clone_voice

voice_id = clone_voice(
    name="Grandma",
    audio_file_path="grandma_sample.wav"
)
print(f"New voice ID: {voice_id}")

Now any article read aloud will sound like Grandma, making the experience more comforting and easier to understand. This level of personalization is what sets modern voice AI apart from the generic, monotone TTS of the past.

Best Practices for Building Accessible Voice Experiences

Provide a fallback – Not every user wants audio. Keep a visual version of the content alongside the voice option.
Allow user control – Let users pause, skip, adjust speed, and change voice. A simple UI with a speed slider and a voice selector covers most needs.
Respect privacy – When using ASR or voice cloning, store audio only as long as necessary and be transparent about data handling.
Test with real assistive tech – Run your app through screen readers (NVDA, VoiceOver) and voice assistants (Google Assistant, Siri) to catch edge cases.

By following these guidelines, you ensure that your voice‑enabled features truly enhance accessibility rather than becoming another hidden layer.

Looking Ahead: Multimodal Accessibility

Voice AI is just the first step. Combine it with image captioning, real‑time translation, and gesture recognition, and you’ll have a web that adapts to any user’s preferred modality. The APIs are getting better, and platforms like ElevenLabs are pushing the envelope on naturalness, making it easier than ever to embed high‑quality speech into everyday apps.

Ready to Give Your Users a Voice?

If you’re looking for a plug‑and‑play solution that delivers studio‑grade audio, supports voice cloning, and comes with clear documentation, give ElevenLabs a spin today: https://try.elevenlabs.io/kr07zfuqn1bp.

Add the endpoint to your existing services, let your users pick a voice they love, and watch your app become a lot more inclusive. Happy coding!

🛑 Stop Writing Code Like It's 2025: How I Built an Autonomous Agent Pipeline That Actually Works

ℋℐ𝒵ℬ𝒜 (✿◠‿◠)⭐ — Sat, 03 Oct 2026 05:56:03 +0000

"The biggest innovation in software engineering isn't new JavaScript framework - it's the shift from syntactic development to orchestrating intent".

⚡ The Cognitive Shift

Recall the days when we spent 3 hours debugging CORS issues or writing custom router middleware for a particular use case? Adorable.

In this era of development, if you're still thinking about artificial intelligence as a copilot for syntax completion you're wasting 10x your time. We have entered the age of agentic delegation - systems that don't merely answer questions but perform work.

Today, we'll be exploring how to build production grade multistep automation pipelines using n8n, Google AI Studio, and API routing patterns that abstract away the heavy lifting.

🛠️ The Development Stack

Orchestration: n8n / Make.com for bulletproof webhook workflows
Intelligence Layer: Google AI Studio (Gemini API) for context parsing
Interface: React + Tailwind CSS implementation with dark mode
Protocol: Event driven architecture + JSON payload standard

🚀 Implementing The Architecture

Rather than writing monolithic backend services that collapse at the first sign of production traffic, we'll be designing our system in modular nodes:


javascript
// Example implementation of core agent event dispatcher
async function dispatchAgentEvent(userInput, contextToken) {
const endpoint = "[https://api.hooklabs.ai/v1/orchestrate](https://api.hooklabs.ai/v1/orchestrate)";

const payload = {
sender: "client_node",
intent: userInput,
security_tier: "bounded_autonomy",
timestamp: Date.now()
};

let response = await fetch(endpoint, {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify(payload)
});

return await response.json();
}

Heirloom: Grandpa's Voice-to-Recipe Kitchen Companion https://ai.studio/apps/04d39775-f526-4776-8963-abcd37504ff6

Shaik Mohseen — Sat, 03 Oct 2026 05:52:48 +0000

This is a submission for the Hacktoberfest Weekend Challenge: Build for a Friend

What I Built

Demo

Code

How I Built It

Why Does Open Innovation Matter?

My Agent Session

Prize Categories

opus 5.5 video guide: Debug Destinations, Cues, and Narration in Tidy’s Dark Tech Launch Film

朱峰 — Sat, 03 Oct 2026 05:52:11 +0000

Start here: prepare a Tidy debugging brief through H3Max.

Use the author artifact for tracing Tidy’s sorting behavior, or the matching Feishu archive for inspecting the reference. Tidy is fictional: this is a code-animated launch film, not desktop footage, SaaS verification, or evidence of H3Max performance.

The upstream project’s account of its author and model credits Claude Opus 5.5. Those sessions have not been independently verified. These commands are reader instructions, not our run log; the entry page does not establish local-terminal access.

LemoLab author-film frame at approximately 5.04 seconds, also the cover.

1. Diagnose the destination before changing the easing

Preserve the reference unchanged. Watch the story, then inspect cursor movement, reading holds, and sound. Compare the intended layout and dark-stage hierarchy with the documented relationship between elements and sorting cues.

The generator contains 264 mixed-category elements, not 264 application windows. Fictional product figures are not measured benchmarks.

Separate wrong destinations, mistimed cues, and obscured narration. Record the timestamp and source before editing. These are diagnostic categories, not reported failures.

2. Preserve an identifiable environment

Prepare Git, Node 20+, FFmpeg/ffprobe, and Python 3.11–3.13 or uv. Use a new directory, without overwriting existing work:

git clone https://github.com/lemomo-ai/lemo-opuscar.git tidy-case
cd tidy-case
export LEMO_OPUSCAR_HOME="$PWD"
sh plugin/skills/lemo-opuscar/scripts/setup.sh deps voice
sh tools/fetch.sh instruments vcsl
mkdir -p evidence
D=styles/dark-keynote/demo
git rev-parse HEAD > evidence/tidy-commit.txt
npm ls --depth=0 > evidence/tidy-dependencies.txt

Keep locks/Python versions; check fonts, source, Kokoro/transcription and VCSL samples. Separate reference and output. Setup is not acceptance.

3. Give the agent a testable reproduction brief

New prompt—not the author’s original instructions:

Reproduce and debug LemoLab's Room to Think from existing dark-keynote source.
Read commit, locks, STYLE.md, DEMO.md, demo/CREDITS, core/README.md, build.sh,
reference and assets. Report missing dependencies; otherwise follow the
documented build without extra approval gates.

Preserve fictional Tidy, dark staging, original mixed-category elements,
cursor-led sorting, shared sound cues and credits. The 264 items are not
264 windows. No real screenshots, fabricated benchmarks, desktop-success
claims or external media-generation APIs.

Inspect timeline.js, world.js, film.js, engine, voice lines, score and mix.
Verify 42 seconds/24 fps from source; record release differences without
silent retiming. Use absolute render(t), fixed seeds, stable identities
and destinations, and shared note/event tables. No wall-clock state.

Test forward, reverse and arbitrary seeks. Save repeated-time comparisons
separately so a later capture cannot overwrite the earlier evidence.
Check destinations, cue alignment, click, flights, landing, captions,
reading holds, narration, intentional silence and complete ending.
Save actual model/provider/effort/session records, prompts, dependencies,
diffs and genuine checks. Do not infer success from the author film,
publish, or identify the reproduction as an H3Max original.

Original-release frame at approximately 20.16 seconds; not a local debugging capture.

4. Build, isolate, and repeat the same check

Run the checked-in implementation of Tidy’s full build:

sh styles/dark-keynote/demo/build.sh
node core/render/still.mjs "$D" 0 14.9 16.45 26 41.9 \
  --out evidence/tidy-stills

The script builds narration, score, events, checks, mix, subtitles, and a 24 fps/two-worker render, then muxes. Still arguments are seconds; inspect press/landing neighbors. Do not mix renderer flags.

Revisit a time after seeking elsewhere. Changed destinations suggest playback-history dependence; inspect shared state, not camera tricks. Restore missing fonts before adjusting coordinates.

Read the final ASR spot-check and listen: its failure need not stop the script. Resolve Chromium or missing voice/sample dependencies explicitly; never silently remove audio.

Repair only the observed destination, cue, caption or narration defect.
Preserve the fictional case and source timing. Show the responsible data
and code diff, repeat the original seek/frame/audio checks, and replay the
whole action. Do not conceal jumps with cuts or report untested fixes as passed.

5. Validate the complete artifact

OUT=styles/dark-keynote/dark-keynote.mp4
ffprobe -v error -count_frames -show_streams -show_format -of json "$OUT"
ffmpeg -v error -i "$OUT" -f null -

Unchanged 42-second/24 fps settings imply 1,008 picture frames. Check dimensions, rate, audio, and ending; watch and listen throughout. Decoding does not certify cue alignment, and web/local encodes need not be byte-identical.

LemoLab reference frame at approximately 34.02 seconds.

Archive source, inputs, versions, prompts, session records, edits, checks, and MP4. Retain the credited origins of Tidy’s lettering, samples, and voices: MIT code, OFL fonts, CC0-credited VCSL samples, and separate voice licenses.

DUNS Number for Google Play: What It Is and How to Get One

vmzavas — Sat, 03 Oct 2026 05:50:08 +0000

Here's the tradeoff in one line: a DUNS number costs you paperwork and waiting time up front, and in return an organization account skips the 12 testers for 14 days that personal accounts have to get through. Whether that's a good deal depends on one question. Do you already have a registered business?

If you do, getting a DUNS number is mostly a form and some patience. If you don't, you'd be setting up a company just to avoid a two-week test, and that's rarely worth it for one app.

What a DUNS number actually is
DUNS stands for Data Universal Numbering System. It's a nine-digit number that Dun & Bradstreet assigns to a business so it can be identified in their database. It isn't a tax number and it isn't a business license. It's closer to a public ID card for a company, used by governments, large suppliers and platforms like Google and Apple to check that a business is real.

Google Play uses it during developer account verification. When you create an account as an organization, Google asks for your DUNS number and checks your organization's name and address against what Dun & Bradstreet has on file.

Why it matters for closed testing
The 12-tester requirement applies to personal developer accounts created on or after November 13, 2023. Organization accounts are currently exempt. That's the whole reason this topic keeps coming up.

When I wrote about PeerPlay on Indie Hackers, one of the most useful replies pointed out exactly this: an organization account with a DUNS number skips the 12-tester rule altogether. It's true, and for some developers it's the better route. It's just not free of friction, and Google's rules for both account types can change, so check Play Console Help before you commit.

Who can get one
You need a legal business entity. Depending on your country that might be a limited company, an LLC, or in many places a registered sole trader. What you can't do is register a hobby project with no legal form behind it.

Before you request anything, search for your company first. Dun & Bradstreet may already have created a record for your business from public registers, in which case you only need to look up the existing number and make sure the details are current.

How to request it
Dun & Bradstreet offers a free DUNS request. Google Play's own help pages link to the lookup and request flow, and that's the safest place to start, because it routes you to the right form for your country instead of a paid service with a similar name.

Fill in the legal name exactly as it appears in your business registration, plus the registered address, phone number and a contact person. Small differences cause problems later. If D&B has "Example Apps d.o.o." and you type "Example Apps" in Play Console, verification can stall.

Then wait. The free route can take weeks; Dun & Bradstreet's own guidance has mentioned up to 30 business days, and in some countries it's faster. They also sell expedited options. I'd only pay for those if a launch date truly depends on it, since closed testing on a personal account takes about two weeks anyway.

After you have the number
Use it when creating the organization developer account, or when your existing organization account asks you to verify. Google may ask for additional documents, and it also verifies a contact email and phone number. Keep the business details identical everywhere: D&B, Play Console and your public developer profile.

One practical note: an organization account shows your organization's details to users on Google Play. If your business is registered at your home address, think about whether you're comfortable with that before you go down this path.

So which route should you take?
If you already run a registered business, get the DUNS number and open an organization account. You'll skip the tester requirement and look more established on the store.

If you're a solo developer with one app and no company, I'd stay with a personal account and run the closed test. Two weeks of testing with real people is less work than forming a company, and you'll come out of it with actual feedback. That's the situation PeerPlay was built for: developers swap testing in tracked 14-day rounds, so you're not stuck trying to find 12 people on your own.

AI Wasn't the Beginning. We Had Already Started Outsourcing Parts of Ourselves to Smartphones

nocklock — Sat, 03 Oct 2026 05:49:53 +0000

People worry that we're becoming too dependent on AI.

It writes for us.

Searches for us.

Helps us code.

And increasingly, we ask it what we should do next.

I understand the concern.

I think about it too.

But recently I started wondering:

Did this really begin with AI?

The more I thought about it, the less it seemed that way.

We've been outsourcing small parts of ourselves to technology for a long time.

AI is just making it much easier to notice.

I used to memorize phone numbers

When I was younger, I knew several phone numbers by memory.

Family.

Friends.

Sometimes even friends' home numbers.

You needed to know the number if you wanted to call someone.

I barely do that anymore.

I search for a name and tap it.

The phone remembers for me.

And honestly, this doesn't feel like a loss most of the time.

It's convenient.

There is very little reason for me to store dozens of phone numbers in my head when a device can do it better.

So I stopped.

Not because someone forced me to.

Because the technology made remembering unnecessary.

I stopped memorizing routes too

Something similar happened with navigation.

If I visited the same place often enough, I used to remember the route.

Which station.

Which street.

Which building meant I needed to turn.

Today, I can visit somewhere completely unfamiliar without thinking much about it.

I open a map.

If I take the wrong turn, it recalculates.

If traffic changes, it finds another route.

Again, this is better in almost every practical way.

I don't want to go back.

But there is a difference between:

I know how to get there.

and:

My phone knows how to get there.

I notice that difference whenever my battery gets low in an unfamiliar place.

Discovery changed too

Restaurants are another example.

There was a time when finding a place meant remembering somewhere you'd visited, hearing about it from someone, or just walking past it.

Now I usually search first.

Ratings.

Reviews.

Photos.

Maps.

Social media.

Recommendation algorithms.

The chance of making a bad choice goes down.

But something else goes down too:

the number of times I discover something without already knowing that other people liked it.

Technology didn't remove choice.

It changed how I arrive at the choice.

Then AI arrived

Contacts remember phone numbers.

GPS remembers routes.

Search engines retrieve information.

Recommendation systems decide what might be worth our attention.

Now generative AI is moving into a slightly different layer.

It doesn't just remember or retrieve.

It participates in the process of thinking.

How should I structure this?

What am I missing?

How could I implement this?

What are the alternatives?

That might be why AI feels different.

Previous tools outsourced pieces of memory and navigation.

AI can outsource pieces of reasoning.

I'm not arguing that we should stop using it

I use AI constantly.

I use it while developing.

I use it to explore ideas.

I use it to find gaps in my own thinking.

I use it when writing.

I'm not interested in pretending that avoiding useful tools somehow makes the work more authentic.

I don't carry a paper map just to prove I can navigate without GPS.

But I do think there is a useful question hidden underneath all of this:

What do I still want to keep as mine?

I don't care that I can't remember everyone's phone number.

I don't care that Google Maps remembers streets better than I do.

But I do care whether I can explain why I made a decision.

I care whether I understand the code I'm shipping.

I care whether an opinion is actually mine or something I accepted because a system gave me a convincing answer.

Convenience has always had a trade

Smartphones didn't suddenly make us incapable.

They made certain abilities less necessary.

And when an ability becomes unnecessary often enough, we naturally practice it less.

AI may be another step in the same direction.

Only this time the thing becoming less necessary might not be remembering a number or memorizing a route.

It might be parts of the thinking process itself.

That doesn't automatically make AI bad.

But it does make the boundary worth noticing.

Technology rarely arrives and says:

Give me this part of yourself.

It gives us something useful.

Something convenient.

Something we quickly stop wanting to live without.

And little by little, we decide what we no longer need to do ourselves.

So when people ask whether AI is making us too dependent on technology, I'm starting to think the answer didn't begin with ChatGPT.

AI wasn't the beginning.

We've been making this trade for a long time.

AME vs Aeronautical vs Aerospace Engineering After 12th PCM: Courses, Eligibility, Career Scope & Salary in India

Garvit Rajput — Sat, 03 Oct 2026 05:49:32 +0000

Students who complete Class 12 with Physics, Chemistry and Mathematics (PCM) have several options in the aviation and aerospace sector. Among the popular choices are Aircraft Maintenance Engineering (AME), Aeronautical Engineering and Aerospace Engineering. Although all three are connected with aircraft and aviation technology, their course structure, work profile, eligibility requirements and career pathways are different.
Choosing the right course after 12th PCM depends on whether a student is interested in aircraft maintenance, aircraft design, aviation technology, space systems or aerospace research.
What Is AME After 12th PCM?
AME stands for Aircraft Maintenance Engineering. It is a specialized aviation programme focused on the maintenance, inspection, servicing and airworthiness of aircraft.
AME students learn about aircraft systems, engines, avionics, maintenance practices, aviation regulations and safety procedures. The training is designed around the requirements of aircraft maintenance and aviation safety.
AME is particularly suitable for students who want to build a career in the aircraft maintenance and technical aviation sector rather than primarily focusing on aircraft design.
What Do AME Students Study?
Depending on the training category and institute, subjects may include:
Aircraft Structures
Aircraft Systems
Aircraft Engines
Aerodynamics
Aircraft Maintenance Practices
Aviation Safety
Avionics
Electrical Systems
Maintenance Procedures
Aviation Regulations
AME Career Areas
After completing the required training, examinations and applicable licensing requirements, career opportunities can include roles related to:
Aircraft maintenance
Aircraft inspection
Aircraft servicing
Aviation technical operations
Maintenance, Repair and Overhaul (MRO)
Airlines
Aircraft maintenance organisations
Aviation support organisations
Important: AME is a regulated aviation pathway, so students should check the current DGCA requirements, approved training organisation status and applicable licensing requirements before taking admission.
What Is Aeronautical Engineering After 12th PCM?
Aeronautical Engineering focuses primarily on aircraft that operate within the Earth's atmosphere.
Students learn how aircraft are designed, developed, tested and operated from an engineering perspective.
The course generally covers areas such as:
Aerodynamics
Aircraft Structures
Propulsion
Flight Mechanics
Aircraft Design
Materials
Avionics
Aircraft Manufacturing
Control Systems
Aeronautical Engineering can be suitable for students interested in the engineering and technological aspects of aircraft.
Career Areas in Aeronautical Engineering
Graduates may explore opportunities in areas such as:
Aircraft design
Aircraft manufacturing
Aerospace companies
Aviation engineering
Aircraft testing
Production engineering
Maintenance-related engineering support
Research and development
Government and private engineering organisations
What Is Aerospace Engineering After 12th PCM?
Aerospace Engineering is a broader field covering both aeronautics and astronautics.
While aeronautical engineering primarily deals with aircraft operating in the atmosphere, aerospace engineering can also cover spacecraft, satellites, launch vehicles and other systems associated with space technology.
Typical areas of study include:
Aerodynamics
Propulsion
Aerospace Structures
Flight Mechanics
Spacecraft Systems
Rocket Propulsion
Avionics
Satellite Technology
Computational Methods
Aerospace Materials
Students interested in aircraft as well as space technology may consider aerospace engineering as a pathway.
AME vs Aeronautical vs Aerospace Engineering
Factor
AME
Aeronautical Engineering
Aerospace Engineering
Full Form
Aircraft Maintenance Engineering
Aeronautical Engineering
Aerospace Engineering
Main Focus
Aircraft maintenance and airworthiness
Aircraft engineering and technology
Aircraft and space technology
Main Orientation
Maintenance/technical aviation
Engineering/design
Engineering/design + space
Aircraft Systems
Strong focus
Strong focus
Strong focus
Aircraft Maintenance
Core area
Supporting/related area
Supporting/related area
Aircraft Design
Limited focus
Major area
Major area
Space Technology
Limited
Limited
Major area
Suitable Interest
Aircraft maintenance
Aircraft engineering
Aircraft + space technology
Career Environment
Airlines, MRO, maintenance organisations
Aviation/aerospace engineering organisations
Aerospace, space and engineering organisations

The three pathways are related but not interchangeable. The appropriate choice depends on the student's career interest and the specific qualification or licence they want to pursue.
Eligibility After 12th PCM
For students completing 12th PCM, eligibility varies according to the programme and institution.
AME Eligibility
AME admission requirements can vary by approved training organisation and programme. Students should check:
10+2 or equivalent qualification
Physics and Mathematics requirements
Applicable minimum marks
Age requirements, where applicable
Medical requirements, where applicable
Current DGCA requirements
Aeronautical Engineering Eligibility
For undergraduate engineering programmes, students generally need:
10+2 with Physics and Mathematics
Chemistry/another eligible subject as specified by the institution
Required minimum marks
Applicable entrance examination requirements
Aerospace Engineering Eligibility
Eligibility for undergraduate aerospace engineering programmes generally includes:
10+2 with Physics and Mathematics
Required qualifying subjects
Minimum marks prescribed by the institution
Applicable entrance examination requirements
Students should always verify the latest admission criteria of the particular college or university because requirements can differ.
Which Course Is More Suitable After 12th PCM?
Instead of choosing a course only because it has the word aviation or aerospace in its name, students should first identify their preferred career direction.
Choose AME if you are interested in:
Aircraft maintenance
Aircraft inspection
Aircraft systems
Aviation safety
Technical aviation operations
Airline and MRO environments
Consider Aeronautical Engineering if you are interested in:
Aircraft design
Aerodynamics
Aircraft structures
Aircraft manufacturing
Engineering and testing
Aviation technology
Consider Aerospace Engineering if you are interested in:
Aircraft technology
Spacecraft
Satellites
Launch vehicles
Propulsion
Aerospace research and development
Career Scope After AME, Aeronautical and Aerospace Engineering
The aviation and aerospace sectors include multiple technical and engineering career areas. However, career opportunities depend on factors such as qualification, licensing, practical training, technical skills, employer requirements and experience.
AME Career Scope
AME professionals can work toward careers involving:
Aircraft maintenance
Line maintenance
Base maintenance
Aircraft inspection
MRO operations
Aviation technical services
Aeronautical Engineering Career Scope
Aeronautical engineering graduates can explore:
Aircraft engineering
Aircraft design
Manufacturing
Testing
Production
Research and development
Aviation technology
Aerospace Engineering Career Scope
Aerospace engineering graduates can explore areas such as:
Aircraft systems
Spacecraft systems
Satellite technology
Propulsion
Aerospace manufacturing
Research and development
Defence and space technology
Salary After AME, Aeronautical and Aerospace Engineering
Salary is not fixed by the course name alone. It depends on the employer, job role, location, technical skills, experience, licensing status and industry segment.
Factors That Can Affect Salary
Educational qualification
AME licence or applicable certification
Type of organisation
Technical specialisation
Practical experience
Job location
Employer
Aircraft or aerospace systems expertise
Students should therefore avoid selecting a course solely on the basis of advertised salary figures.
AME vs Aeronautical vs Aerospace: Course Selection Guide
A simple way to understand the difference is:
Aircraft Maintenance → AME
Aircraft Engineering → Aeronautical Engineering
Aircraft + Space Engineering → Aerospace Engineering
However, these fields can overlap in subjects such as aerodynamics, propulsion, aircraft systems and materials. The major difference is the professional direction and depth of specialisation.
Why 12th PCM Students Consider Aviation and Aerospace Courses
Physics and Mathematics provide a strong academic foundation for understanding aircraft and aerospace technology. Chemistry can also support the study of engineering materials and related technical subjects.
Students who enjoy:
Physics
Mathematics
Aircraft technology
Machines and systems
Engineering
Space technology
Problem-solving
may find aviation and aerospace-related education relevant to their interests.
Conclusion
After 12th PCM, AME, Aeronautical Engineering and Aerospace Engineering offer different pathways into the aviation and aerospace ecosystem.
AME is primarily focused on aircraft maintenance, inspection and airworthiness. Aeronautical Engineering focuses on aircraft engineering and related technologies, while Aerospace Engineering provides a broader engineering scope that can include both aircraft and space systems.
Before taking admission, students should compare the course curriculum, eligibility, institute recognition/approval, practical training, licensing requirements, career pathway and total fees rather than selecting a programme based only on its name or expected salary.

An AI hardware advisor that walks every path — and gets its math checked by the rules in Sanity

Helgard — Sat, 03 Oct 2026 05:49:32 +0000

This is a submission for the Sanity Challenge, Path One: Ship an Agent That Queries Real Content

What I Built

An agent that answers "what computer do I need to run this AI model?" — including "don't buy, rent" and
"you already have enough". It reads a Sanity dataset of criteria, not a catalog: laws (formulas for weights
memory, KV cache, speed ceiling, own-vs-rent breakeven), machine-checkable rules, 11 solution paths
(keep what you have · upgrade · used · one GPU · multi-GPU · unified memory · MoE experts in system RAM ·
CPU-only small model · smaller model · cloud API · rented GPU), run reports and reference hardware.
New models appear every week, so anything not in the base is looked up on the web by the base's own checklist.

Sanity project: onwa0wvs, public dataset v2 (200 documents), Studio: https://hw-for-ai-lab-v2.sanity.studio
Agent connection: Sanity Context MCP on the full dataset with embeddings enabled (/context/mcp/onwa0wvs/v2); all numbers below are measured through this connection
Second entry: a Knowledge Base (kbW7wsbtJQkl, built from the core 138 documents of the same dataset, refreshed weekly) behind its own Context MCP endpoint in KB mode — created and connected, not measured separately
Demo — try it with your own agent: https://hw-advisor.helgardorlm.tech (MCP https://hw-advisor.helgardorlm.tech/mcp, no login) · Replay of all 27 measured runs: https://helgard-orlm.github.io/sanity-ai-hardware-advisor/
Repo: https://github.com/helgard-orlm/sanity-ai-hardware-advisor

Demo

Live — bring your own agent (no login, no keys): https://hw-advisor.helgardorlm.tech · MCP endpoint https://hw-advisor.helgardorlm.tech/mcp
Replay of all 27 measured runs: https://helgard-orlm.github.io/sanity-ai-hardware-advisor/

Code

https://github.com/helgard-orlm/sanity-ai-hardware-advisor (the public proxy with check_answer is in public_mcp/)

Sanity Project Details

Project ID onwa0wvs, public dataset v2 — 200 documents, 15 types (law, rule, solutionPath, aiModel, gpu, cpu, runReport, offer, cloudOffer, situationTemplate, …)
Query it directly: https://onwa0wvs.api.sanity.io/v2025-01-01/data/query/v2?query=*[_type=="law"]
Studio: https://hw-for-ai-lab-v2.sanity.studio

Try it with your own agent (no keys, no login)

The demo is a public MCP endpoint, not a hosted chatbot: you bring the agent, the base brings the knowledge and the checking.
Add https://hw-advisor.helgardorlm.tech/mcp to ChatGPT (developer mode), Claude, Claude Code, Codex, Cursor or VS Code.
There are one-click buttons for Cursor and VS Code on the page. Or paste one line into any agent that can run commands:
"Read https://hw-advisor.helgardorlm.tech/setup.md and follow it."

Behind it is a ~230-line stdlib proxy. It passes the four Sanity Context MCP tools through unchanged and keeps the token
server-side. It puts today's date and the advisor's work order in front of initial_context. It adds one tool, check_answer,
which is the same validator the app uses: it recomputes every calculation with the law.formula stored in Sanity.
In the first outside test (Codex, its own subscription), check_answer rejected the first draft with 4 errors. The second draft passed:
5 calculations recomputed, 11/11 solution paths walked. A test from ChatGPT (developer mode) also went through to a passing check. Agents that can only browse get the same tools as plain HTTPS links
(/api/context, /api/query?q=…, /api/check), listed in /llms.txt.

Known limit: the check covers numbers, completeness, sources and identity. It does not cover whether a verdict makes sense. In one test an agent said yes to "MoE experts in RAM" for a dense model, and the check passed.

How I Used Sanity

Sanity Context MCP tools the agent calls: initial_context, groq_query, schema_explorer, array_field_reader (plus our check_answer). What it does with the content it retrieves — the structure is used, not just searched:

Paths are data. The agent must give a yes/no/maybe with a number for every solutionPath document. Before this, the same model answered a 321B-MoE question with "4×H200" and never mentioned the one-GPU + large-RAM path.
Rules are the search checklist. For any model/card/CPU that is not in the base, the app requires the fields that the base's rule documents test for that type (e.g. cpu.instructionSets, aiModel.variants.fileGb).
Laws are recomputed by code. The agent writes every calculation with its inputs into a hidden check block; the app evaluates the law.formula from Sanity and sends the answer back if the number is wrong.
The person's situation is stored, not remembered: country, budget, existing PC survive a change of mind.

The same code checks the base itself: every law variable and rule path must be a real schema field
(coverage check), and laws get property tests. That caught the filler model writing an own-vs-rent formula that
added electricity instead of subtracting it and billed rent for 24 h/day — 12.3 vs 110 months on the same inputs.

A real trace (GLM-5.3-Flash, not in the base) — open it in the replay

GROQ over the base → no aiModel document → 8 web searches by the base's own checklist: the model card and config.json (layers, KV heads, head dim), file sizes, and the GPU fields the base's rules test (slots, bandwidth, compute capability).
Laws from Sanity: weights 320 × 4 / 8 = 160 GB (NVFP4), KV for 8k context 22.5 GiB (flagged as rough for hybrid attention).
Validator round 1 sent the answer back: the speed ceiling was written as 19.91 tok/s — code evaluated the law.formula from Sanity with the agent's own inputs and got 199.1 (a 10× slip); plus three entities missing fields that the base's rules check (e.g. variants.fileGb, slots).
Round 2: no errors. All 11 solution paths get a verdict — multi-GPU = yes, MoE-in-RAM / unified memory = maybe, cloud = no (the person ruled it out) — and the build is 3 × RTX PRO 6000 (288 GB) with the numbers above.

Other catches by the same recomputation in the measured run: KV cache 0.949 → 6.75 GiB (A4), monthly electricity cost 0.675 → 2.025 (A5).

Measured, honestly

Blind grader (a different model, sees only the dialogue and a frozen checklist), 9 scenarios × 3 runs,
78 checklist items, same base state for all arms:

version	score	median time
v2: base + instructions	47/78	62 s
v3: + solution paths, validator	53/78	104 s
v3.1 via Sanity Context MCP: + rules-as-checklist, recomputed laws, dated prices	59/78	181 s

What this does not show: that structured retrieval beats plain text for reading. The same 200 documents
pasted as text notes scored the same as v3 (53/78) — at this size the model reads either. Where structure
mattered in our runs is checking: fewer first answers rejected by the validator with structured queries
(8/27 vs 14/27), and the gains of v3.1 are exactly in the scenarios where code recomputes Sanity's laws
(KV for 8 users 7/9 → 9/9, own vs rent 5/12 → 7/12, "don't buy" 4/6 → 6/6, v2 → v3.1). The price: answers take ~3× longer.
An earlier full run of v3.1 scored 62/78 with two bugs in my own checker (nested fields, European number format) that sent
correct answers back for rework; after fixing them the clean run scored 59/78 — with N=3 per scenario, 59 vs 62 is noise.

How it was built

Architect method: a risk catalog (16 classes of agent failure seen in earlier sessions) → acceptance scenarios
written before changes → build → blind grading. The base was filled by a model (GPT Luna) from an empty schema and
two prompts; I never wrote data by hand. An independent judge model watched the session and corrected the method
several times (frozen checklist, snapshot baseline, text control).

Known limits

Answers are slow (minutes) because the validator can send them back up to twice.
Ratings N=3 per scenario; differences of 1–2 points are noise.
"unknown after search" is allowed and can be abused for vague entities.
In the measured run 12 of 27 answers came out in Russian to English questions (an account language setting leaked in); the app now checks the answer's language in code and sends it back (3/3 English on a re-test).