Show HN for January 13, 2026

Reddit's API is effectively dead for archival. Third-party apps are gone. Reddit has threatened to cut off access to the Pushshift dataset multiple times. But 3.28TB of Reddit history exists as a torrent right now, and I built a tool to turn it into something you can browse on your own hardware.

The key point: This doesn't touch Reddit's servers. Ever. Download the Pushshift dataset, run my tool locally, get a fully browsable archive. Works on an air-gapped machine. Works on a Raspberry Pi serving your LAN. Works on a USB drive you hand to someone.

What it does: Takes compressed data dumps from Reddit (.zst), Voat (SQL), and Ruqqus (.7z) and generates static HTML. No JavaScript, no external requests, no tracking. Open index.html and browse. Want search? Run the optional Docker stack with PostgreSQL – still entirely on your machine.

API & AI Integration: Full REST API with 30+ endpoints – posts, comments, users, subreddits, full-text search, aggregations. Also ships with an MCP server (29 tools) so you can query your archive directly from AI tools.

Self-hosting options: - USB drive / local folder (just open the HTML files) - Home server on your LAN - Tor hidden service (2 commands, no port forwarding needed) - VPS with HTTPS - GitHub Pages for small archives

Why this matters: Once you have the data, you own it. No API keys, no rate limits, no ToS changes can take it away.

Scale: Tens of millions of posts per instance. PostgreSQL backend keeps memory constant regardless of dataset size. For the full 2.38B post dataset, run multiple instances by topic.

How I built it: Python, PostgreSQL, Jinja2 templates, Docker. Used Claude Code throughout as an experiment in AI-assisted development. Learned that the workflow is "trust but verify" – it accelerates the boring parts but you still own the architecture.

Live demo: https://online-archives.github.io/redd-archiver-example/

GitHub: https://github.com/19-84/redd-archiver (Public Domain)

Pushshift torrent: https://academictorrents.com/details/1614740ac8c94505e4ecb9d...

I’ve been building and selling software since the early 2000s, starting with classic shareware. In 2011, I moved into the App Store world and built an iOS budget app because I needed a simple way to track my own expenses.

At the time, my plan was to replace a few larger shareware projects with several smaller apps to spread the risk. That didn’t quite work out — one app, MoneyControl, quickly grew so much that it became my main focus.

Fifteen years later, the app is still on the App Store, still actively developed, and still used by people who started with version 1.0. Many apps from that era are long gone.

Looking back, these are some of the things that mattered most:

Starting early helped, but wasn’t enough on its own. Early visibility made a difference, but long-term maintenance and reliability are what kept users.

Focus beat diversification. I wanted many small apps. I ended up with one large, long-lived product. Deep focus turned out to be more sustainable.

Long-term maintenance is most of the work. Adapting to new iOS versions, migrating data safely, handling edge cases, and keeping old data usable mattered more than flashy features.

Discoverability keeps getting harder. Reaching users on the App Store today is much more difficult than it was years ago. Prices are higher than in the old 99-cent days, but visibility hasn’t improved.

I’m a developer first, not a marketer. I work alone, with occasional help from freelancers. No employees, no growth team. The app could probably have grown more with better marketing, but that was never my strength.

You don’t need to get rich to build something sustainable. I didn’t build this for an exit. I’ve been able to make a living from my work for over 20 years, which feels like success to me.

Building things you actually use keeps you honest. Every product I built was something I personally needed. That authenticity mattered more than any roadmap.

This week I released version 10 with a new design and a major technical overhaul. It feels less like a milestone and more like preparing the app for the next phase.

Happy to answer questions about long-term app maintenance, indie development, or keeping a product alive across many iOS generations.

I built Nogic, a VSCode extension currently, because AI tools make code grow faster than developers can build a mental model by jumping between files. Exploring structure visually has been helping me onboard to unfamiliar codebases faster.

It’s early and rough, but usable. Would love feedback on whether this is useful and what relationships are most valuable to visualize.

This is hyTags, a programming language embedded in HTML for building interactive web UIs.

It started as a way to write full-stack web apps in Swift without a separate frontend, but grew into a small language with control flow, functions, and async handling via HTML tags. The result is backend language-agnostic and can be generated from any server that can produce HTML via templates or DSLs.

Hi HN, I’m the creator of SnackBase.

I built this because I work in Healthcare and Life Sciences domain and was tired of spending months building the same "compliant" infrastructure (Audit Logs, Row-Level Security, PII Masking, Auth) before writing any actual product code.

The Problem: Existing BaaS tools (Supabase, Appwrite) are amazing, but they are hard to validate for GxP (FDA regulations) and often force you into a JS/Go ecosystem. I wanted something native to the Python tools I already use.

The Solution: SnackBase is a self-hosted Python (FastAPI + SQLAlchemy) backend that includes:

Compliance Core: Immutable audit logs with blockchain-style hashing (prev_hash) for integrity.

Native Python Hooks: You can write business logic in pure Python (no webhooks or JS runtimes required).

Clean Architecture: Strict separation of layers. No business logic in the API routes.

The Stack:

Python 3.12 + FastAPI

SQLAlchemy 2.0 (Async)

React 19 (Admin UI)

Links:

Live Demo: https://demo.snackbase.dev

Repo: https://github.com/lalitgehani/snackbase

The demo resets every hour. I’d love feedback on the DSL implementation or the audit logging approach.

Hi HN,

I built Ayder — a single-binary, HTTP-native durable event log written in C. The wedge is simple: curl is the client (no JVM, no ZooKeeper, no thick client libs).

There’s a 2-minute demo that starts with an unclean SIGKILL, then restarts and verifies offsets + data are still there.

Numbers (3-node Raft, real network, sync-majority writes, 64B payload): ~50K msg/s sustained (wrk2 @ 50K req/s), client P99 ~3.46ms. Crash recovery after SIGKILL is ~40–50s with ~8M offsets.

Repo link has the video, benchmarks, and quick start. I’m looking for a few early design partners (any event ingestion/streaming workload).

Hi! I've built this because I kept reaching for Celery for simple scheduled tasks and it felt like overkill. I just needed "run this function every hour" or "daily at 9am", not distributed workers.

So it's decorators for scheduling (@scheduler.every(5).minutes, @scheduler.daily.at("09:00")), state saves to JSON so jobs survive restarts, and there's an optional FastAPI dashboard if you want to see what's running.

No Redis, no message broker, runs in-process with your app. Trade-off is it's single process only — if you need distributed workers, stick with Celery.

Hi HN — I built Microwave, a native iOS app for browsing and posting short-form videos, similar to TikTok, but implemented as a pure client on top of Bluesky / AT Protocol.

There’s no custom backend: the app reads from and publishes to existing ATproto infrastructure. The goal was to explore whether a TikTok-like experience can exist as a thin client over an open social protocol, rather than a vertically integrated platform.

Things I’d especially love feedback on:

  - Whether this kind of UX makes sense on top of ATproto

  - Client-only tradeoffs (ranking, discovery, moderation)

  - Protocol limitations I may be missing

  - Any architectural red flags

TestFlight: https://testflight.apple.com/join/cVxV1W3g

Hi HN! I built Timberlogs because I was tired of console.log in production and existing logging solutions requiring too much setup.

Timberlogs is a drop-in structured logging library for TypeScript:

    npm install timberlogs-client

    import { createTimberlogs } from "timberlogs-client";
    
    const timber = createTimberlogs({
      source: "my-app",
      environment: "production",
      apiKey: process.env.TIMBER_API_KEY,
    });
    
    timber.info("User signed in", { userId: "123" });
    timber.error("Payment failed", error);

Features: - Auto-batching with retries - Automatic redaction of sensitive data (passwords, tokens) - Full-text search across all your logs - Real-time dashboard - Flow tracking to link related logs

It's currently in beta and free to use. Would love feedback from the HN community.

Site: https://timberlogs.dev Docs: https://docs.timberlogs.dev npm: https://npmjs.com/package/timberlogs-client GitHub: https://github.com/enaboapps/timberlogs-typescript-sdk

Hi HN, In most codebases I’ve worked on, temporary hacks (“TODO: remove later”, “just for this release”) slowly become permanent. Nobody remembers why they exist, but they keep shipping to production. I built a small CLI called DebtBomb to make that explicit. Instead of free-form TODOs, you attach an expiry date to temporary code. When the date passes, CI fails until the code is removed or the expiry is intentionally extended. Recently I added integrations so expired debt bombs don’t just fail CI — they become visible and owned: When a debt bomb expires, DebtBomb can automatically create a Jira ticket with file path, owner, reason, and code snippet. It can also notify Slack, Discord, or Microsoft Teams. You can configure “expiring soon” warnings (e.g., 7 days before) so it’s not just a surprise break. Repo: https://github.com/jobin-404/debtbomb This is still early and I’m mainly trying to validate whether this actually improves how teams handle “temporary” code compared to TODOs, linters, or just creating tickets manually. I’d especially love feedback from people who’ve dealt with tech debt in long-lived codebases or CI-heavy environments. Thanks for reading.

Hi, as the LLM models are getting smarter in coding tasks, we will soon be using agents as co workers, as current tools like github copilot and cursor are not optimized for team collaboration, we began building PhantomX, please give your feedback, if you think we are in the right direction or what should be changed for finding the optimized development workflow which works for both humans and agents.

Built this RSS aggregator based on the 2025 HN Popularity Contest rankings by Refactoring English [1]. If there's interest in other slices (top 10, top 200, etc.), happy to add them.

[1] https://news.ycombinator.com/item?id=46478377

Fun module on Thales of Miletus—the beginning of philosophy

Hi HN — I’m sharing an empirical, long-term dataset from a DIY energy-storage project that ended up testing a common assumption in battery design.

Conventional advice says never mix battery brands. That guidance is well-founded for series strings, but there’s surprisingly little data on purely parallel configurations.

I built a 12 V, 500 Ah LiFePO₄ battery bank (1S5P) using mixed-brand cells and instrumented it for continuous monitoring over 73+ days, including high-frequency voltage sampling. The goal was to see whether cell-level differences actually manifest over time in a parallel topology.

What the data shows

No progressive voltage divergence across the observation period

Voltage spread remained within ~10–15 mV

Measured Peukert exponent ≈ 1.00

Thermal effects were small relative to instrumentation noise

In practice, the parallel architecture appears to force electrical convergence when interconnect resistance is low. I’ve been referring to this as “architectural immunity” — the idea that topology can dominate cell-level mismatch under specific conditions.

This is not a recommendation to mix batteries casually, and it’s not a safety guarantee. It’s an attempt to replace folklore with measurements and to define the boundary conditions where this does or does not hold.

Everything is public:

Raw CSV data

Analysis scripts

Full PDF report

Replication protocol

Repo: https://github.com/wkcollis1-eng/Lifepo4-Battery-Banks

I’m posting this to invite critique — especially around failure modes, instrumentation limits, or cases where this model would break down (e.g., higher C-rates, aging asymmetry, thermal gradients, different chemistries).

Happy to answer technical questions.

I've been researching blockchain-based capital markets and developed a framework for tokenized equity with separated economic, dividend, and governance rights. Core idea: Instead of bundling everything into one share, issue three token types: - LOBT: Economic participation, no governance - PST: Automated dividends, no ownership - OT: Full governance control

Key challenge: Verifying real-world business operations on-chain without trusted intermediaries. I propose decentralized oracles + ZK proofs, but acknowledge significant unsolved problems.

This is research/RFC seeking technical feedback on oracle architecture, regulatory viability, and which verticals this makes sense for.

Thoughts?

I started using Facebook at the age of 13, for many hours every day. The same happened with other social media apps. I recently found that Facebook alone made around 14K from my daily usage over the years. I paid with my time and attention, and they made money from it. Seeing the number made me less addicted and more careful. It showed me that my time is actually expensive.

Open source maintainers are drowning in low effort PRs.

Someone sees a help wanted issue, pastes it into an AI, submits without testing, loops through review comments without understanding the code. The PR looks plausible at first glance but falls apart under review. Maintainers waste 30 minutes before realizing it's garbage.

This is happening at scale now. And it's worst in projects with bounty programs or GSoC where there's incentive to “contribute.”

GitHub tells you if someone is a first-time contributor to your repo. It doesn't tell you anything about their history elsewhere.

I built a Chrome extension that shows contributor reputation right on the PR page: merge rates across repos, spray-and-pray patterns, red flags.

Not sure I got the signals right. Would love feedback from maintainers.

Client-side Markdown viewer built for reading and sharing documents with diagrams and math.

It supports GitHub-flavored Markdown, Mermaid diagrams, and LaTeX rendering directly in the browser. The scope is intentionally narrow: viewing Markdown clearly, without turning it into a full editor.

Feedback is welcomed

Gitmore (https://gitmore.io) – makes Git activity accessible to people who don't use Git.

Every commit has a message. Every PR has a title and description. The status update already exists. It's just locked in GitHub.

*Who this is for:*

- Founders updating investors - PMs writing release notes - CEOs who want visibility without standups - Anyone who asks "what shipped?" and waits for an engineer to respond

*What it does:*

Connect your repos. Ask questions: - "What shipped this month?" - "Who worked on the billing feature?" - "Which PRs are stuck?"

Or schedule automated reports to Slack or email. Weekly, monthly, whatever.

*How it works:*

We register webhooks. Git platforms push event metadata – commit messages, PR titles, descriptions, authors, timestamps, file counts.

Every event gets normalized into a structured schema. The AI queries structure, not raw text.

*What we don't do:*

We don't do code review. We don't analyze diffs. We don't compete with Coderabbit or Greptile. Those are for engineers inside the PR workflow.

This is for people outside that workflow who need visibility.

*Security:*

Webhooks only. We never clone repos or access source code.

- Token encryption: Fernet (HMAC-SHA256 + AES-128-CBC) - Webhook verification: HMAC-SHA256 - 2FA support

Works with GitHub, GitLab, and Bitbucket.

Free for 1 repo: https://gitmore.io

How do non-technical people at your company stay informed on dev progress?

I wanted to print out some vocabulary flashcards to hand out at my local Esperanto club, so I built this static webapp which converts .apkg files to a printable grid of cards.

Anki decks are a little complicated (XML inside a sqlite database inside a zstd archive), so getting this working in-browser was a bit tricky.

Let me know if it's useful to you!

y0 is different because the agents actually do things — they don't just chat.

You describe what you want in natural language. Then y0 spins up a sandboxed environment and the agent gets to work: browsing websites, writing code, managing files, running shell commands. It streams progress in real-time so you can watch it work.

Unlike chatbots, y0 agents have real execution capabilities. They can navigate complex websites, fill forms, extract data, create documents, run scripts, and chain multiple steps together autonomously. When the agent finishes, you get the actual output — files, data, reports — not just a text response.

The sandboxing means agents can't mess with your local machine. Each session runs in an isolated container with its own filesystem, browser, and shell. You can give agents access to specific tools and APIs without worrying about side effects.

We built y0 because we got tired of copying code from ChatGPT and manually running it. We wanted an AI that could just do the work end-to-end.

There's a free tier to try it out. Would love feedback on what workflows you'd want agents to handle.

Yooo!

Papercuts lets you deploy AI agents that flow through your production app like a real user. Just provide a URL and get notified when something breaks.

Modern apps are way too complex for brittle selectors. Honestly, I think the only way to feel safe is to test in production with AI agents that actually perceive and navigate like a human.

help me to get prime to my stream , hackathon kick off!!

I’m organizing hybrid hackathon: “AI Vibe Coding Hackathon”. It’s happening online on Devpost: (https://vibe.devpost.com/). And will be in-person in multiple cities (we’re currently finalizing it).

- Sponsors: ElevenLabs, Daytona, Nord Security (NordVPN, NordPass, NordProtect, Saily eSim, Incogni, NexsoAI), .cvDomains, Cursor (finalizing discussions), Replit (finalizing discussions), Bolt (finalizing discussions). - Educational Partners: MUBL, YapsGG, The Earth Foundation (finalizing discussions). - Media partner: ANORA Labs

Hi HN,

I built a CLI tool that generates documentation from Drizzle ORM schema definitions.

The problem: Drizzle ORM doesn't have built-in schema documentation or ER diagram generation. While drizzle-dbml-generator exists for DBML output, I needed something that could also extract JSDoc comments and generate human-readable documentation.

What it does: - Extracts JSDoc comments from your schema and includes them in the output - Generates DBML (compatible with dbdocs.io and dbdiagram.io) - Generates Markdown documentation with Mermaid ER diagrams - Supports PostgreSQL, MySQL, and SQLite - Works with both Drizzle v0 (relations()) and v1 beta (defineRelations()) APIs - Watch mode for development

Example: drizzle-docs ./src/db/schema.ts -o schema.dbml drizzle-docs ./src/db/schema.ts -f markdown -o ./docs

The key differentiator is JSDoc extraction. If you document your schema like this:

  /** User account information */
  export const users = pgTable("users", {
    /** Unique identifier */
    id: serial("id").primaryKey(),
    /** User's email address */
    email: varchar("email", { length: 255 }).notNull(),
  });

These comments become Notes in DBML or descriptions in Markdown output.

Built with TypeScript, uses the TS Compiler API for comment extraction. MIT licensed.

Would love feedback on what output formats or features would be most useful.

Hi, I built the first version of Soklet back in 2015 as a way to move away from what I saw as the complexity and "magic" of Spring (it had become the J2EE creature it sought to replace). I have been refining it over the years and have just released version 2.0.0, which embraces modern Java development practices.

Check it out here: https://www.soklet.com

I was looking for something that captured the spirit of projects like Express (Node), Flask (Python), and Sinatra (Ruby) but had the power of a "real" framework and nothing else quite fit: Spark/Javalin are too bare-bones, Quarkus/Micronaut/Helidon/Spring Boot/etc. have lots of dependencies, moving parts, and/or programming styles I don't particularly like (e.g. reactive).

What I wanted to do was make building a web system almost as easy as a "hello world" app without compromising functionality and I feel I have accomplished this goal.

Other goals - support for Server-Sent Events, which are table-stakes now in 2026 and "native" integration testing (just run instances of your app in a Simulator) are best-in-class in my opinion. Servlet integration is also available if you can't yet fully disentangle yourself from that world.

If you're interested in Soklet, you might like some of its zero-dependency sister projects:

Pyranid, a modern JDBC interface that embraces SQL: https://www.pyranid.com Lokalized, which enables natural-sounding translations (i18n) via an expression language: https://www.lokalized.com

I think Java is going to become a bigger player in the LLM space (virtual threads now, forthcoming Vector API/Project Panama/etc.) If you're building agentic systems (or just need a simple REST API), Soklet may be a good fit for you.

I've been optimizing ternary operations for BitNet 1.58b and found significant overhead in the current implementation.

I wrote a dependency-free C kernel (sparse-ternary-fma) using 2-bit encoding and AVX-512 instructions.

Benchmarks on Intel Xeon (N=4096):

Throughput (Dense): 2.38x faster (8.21 GFLOPS vs 3.45 AVX2)

Throughput (Sparse 80% zeros): 26.12x faster (23.25 GFLOPS vs 0.89 Scalar)

Memory: 4x denser (2-bit vs 8-bit standard)

This approach packs 4 trits per byte and leverages sparsity-aware FMA to skip zero-valued weights, which is critical for 1.58-bit quantization efficiency.

PR is pending on the Microsoft BitNet repo. Code is open source here:https://github.com/microsoft/BitNet/pull/365

Hi HN,

  I built a grade calculator that runs entirely in your browser with no sign-up or data collection.                     
                                                                                                                        
  Key features:                                                                                                         
  - Real-time weighted grade calculation with automatic normalization                                                   
  - What-If simulator: calculate what score you need on finals to hit your target grade                                 
  - Multi-course support with localStorage persistence                                                                  
  - Grade breakdown charts                                                                                              
  - Dark mode                                                                                                           
                                                                                                                        
  Tech stack: Next.js 14, TypeScript, Zustand, Recharts. Fully open source (MIT).                                       
                                                                                                                        
  Built this because existing grade calculators either require accounts, show ads, or have clunky UX. Wanted something fast and privacy-respecting.                                                                                             
                                                                                                                        
  Live: https://ezgrade.me                                                                                                                                                                                       
                                                                                                                        
  Would love feedback on the UX and any features you'd find useful!

I built a TypeScript CLI for LeetCode that goes beyond basic problem fetching.

Key features:

Interview timer with difficulty-based defaults (Easy: 20min, Medium: 40min, Hard: 60min) Solution snapshots to save/compare different approaches Collaborative coding with room-based sessions Workspaces for isolating contexts (interview prep, contests, daily practice) Git sync for automatic solution backup Visual debugging with ASCII visualization for arrays/trees The goal was to stay in the terminal and practice under interview-like conditions.

GitHub: https://github.com/night-slayer18/leetcode-cli

Built with TypeScript, uses cookie-based auth (you paste session tokens from browser DevTools).

Hi HN!

I created this web app (with PWA support) because the official Bluesky app lacks the one thing I want: to start me at the place I left off in the chronological timeline.

This is intended as a reader, not a full Bluesky client. I use it in conjunction with the Bluesky app or website. Tap the timestamp of a post to open it in Bluesky.

I’ve tried my best to display stable timeline updates that match what the Tweetie app pioneered so long ago: keeping your visual place in the timeline when refreshing. This was tricky to do in a web app… I wrote more about it here[0].

0: https://memalign.github.io/p/memsky.html

The motivation for the project is to be able to deploy containerized workflows from GitHub to AWS with fully serverless infrastracture without worrying about CI/CD and be able to download the computed output to local machine with ease using a CLI tool.

Anthropic just dropped Cowork today – a nicer way to let Claude act as your agent on files without wrestling the CLI.

I've been building something in the same spirit but open-source, cross-platform, and multi-model: AionUi. It's a free desktop GUI (Electron-based) that turns popular command-line AI tools into a unified "Cowork" workspace: Supports Claude Code, Gemini CLI, Codex, Qwen Code, Goose CLI, Auggie, etc. (auto-detects installed CLIs)

- Custom LLMs – Full support for customizable third-party LLMs. - Multi-session chats with independent contexts, stored locally in SQLite (data never leaves your device) - Real-time preview & editing panel for 9+ formats: PDF, Word, Excel, PPT, code diffs, Markdown, images, HTML... - AI image generation/editing (Gemini-powered, with recognition) - Smart file management: batch rename, auto-organize, classify, merge - Parallel multi-tasking (sessions don't interfere) - WebUI mode: remote access from phone/browser, still local data - Cross-platform: macOS, Windows, Linux - Fully customizable UI via CSS

Just like Claude Cowork simplifies Claude Code for non-devs, AionUi aims to do the same for all your CLI AI agents.

GitHub: https://github.com/iOfficeAI/AionUi (3.5k stars, Star if it looks useful – no pressure!)

I wanted to share a TikTok without my username going with it and popping up to the receiver, or TIkTok's advertising backend. What started as a simple question turned into a rabbit hole.

TikTok's links embed referrer parameters that identify who shared the link. Facebook's share link wrapper includes session hashes. YouTube's `si=` parameter likely logs the share against your profile. Etc. Etc. Etc. Etc.

Each platform implements this differently, and they change their schemes regularly. So I built a secure modular cleaner with a constantly updating database, after carefully inspecting the behavior of each platform.

The app uses a deny-by-default security model. If it doesn't recognize a parameter, it gets stripped. Behavior is configurable, and I tried to make it as self-explanatory as possible, and hopefully educational about exactly what the app does on your behalf and exactly what the platforms are doing with their parameters.

I feel like there's a kind of "physics" to internet interaction we used to understand intuitively. Click a link, go to a page. Share a link, send a URL. But platforms have been eroding this. Now sharing means sending a URL + your identity + session context + attribution metadata, all encoded in ways we can't read.

I built PrivateLink to scratch my own itch for that transparency, paired with one-touch sharing integration. The app shows you what's in the link, what gets stripped, and why. The goal isn't just "clean URLs" — it's understanding what happens when sharing from any app.

Available on iOS and Android, with a free version that cleans TikTok and Facebook shortlinks specifically, and a $0.99 pro unlock for any website.

Any and all feedback greatly appreciated!

I built proc because I was tired of: - Googling "how to find process using port" every time - The cognitive load of lsof -i :3000 | grep LISTEN | awk '{print $2}' - Forgetting which flag does what in ps aux

proc uses natural patterns: proc on :3000 # What's on port 3000? proc kill node # Kill all Node processes proc ps --in # Processes in this directory proc tree -a 1234 # Where did this process come from?

Written in Rust, works on macOS/Linux/Windows.

GitHub: https://github.com/yazeed/proc Install: brew tap yazeed/proc && brew install proc

Happy to answer questions!

I built this because with AI-assisted coding I spend much more time reading unfamiliar code than writing it.

The main friction was comments written in a non-native language: using external translators breaks focus, and many editor tools translate whole lines or buffers rather than actual comments.

This plugin uses Tree-sitter to detect comment nodes precisely and translates them inline on hover, so code reading stays uninterrupted.

I had problems scheduling company get together. 3 days in next 3 months, 12 people, whats the best date for that? I've build the solution to my problem (human coded haha) and recently is started getting traction which is nice, so we added Slack integration (Claude coded).

WhenNOT flips the question: instead of "when are you available?", we ask "when are you NOT available?"

It's completely free - no premium tiers, no limits. I built it because I needed it for my own team.

Update on the StatefulSet Backup Operator - a lightweight Kubernetes operator for automated backups using native VolumeSnapshot APIs. What's new in v0.0.3:

VolumeSnapshotClass is now configurable (was hardcoded before) Improved PVC deletion stability with proper wait logic Enhanced test coverage for edge cases Redis StatefulSet backup/restore fully tested end-to-end Code quality improvements: clean linting, better error handling

Why this exists: Velero is great for full-cluster DR, but sometimes you just need fast, snapshot-based backups for StatefulSets without the overhead of external object storage or complex setup. This operator focuses on:

Scheduled snapshots with cron expressions Pre/post backup hooks (e.g., database flush before snapshot) Per-replica retention policies Point-in-time recovery via CRDs 100% declarative, GitOps-friendly

Current limitations: Still alpha (v0.0.3). No cross-cluster restore yet, no webhook validation, container selection for hooks needs work. Velero is still the production choice for serious DR needs. What I'm curious about: Is there actual demand for this kind of focused tool, or does Velero's flexibility already cover these use cases well enough that alternatives don't make sense? Tested successfully on Minikube, Kind, and now Redis workloads. Planning to test on GKE/EKS next. Feedback welcome!

Hi HN!

I’m the creator of Gridfy. I built it because I was frustrated with what I call the "No-Code Tax."

Whenever I wanted to publish structured data from Airtable or Notion, I felt trapped between two bad options: spending hours writing custom frontend code, or paying for expensive subscriptions like Softr or Airtable’s premium embeds. Most of these platforms get pricey fast and the customization is often too limited to match a professional brand.

I wanted something in the middle: the speed of no-code but with the flexibility of a custom component. With Gridfy, you connect your data source and get a performant, embeddable widget with search and filtering that actually looks like part of your site.

Key points for fellow builders: - Customization: Fully tweakable via CSS variables to avoid that "generic widget" look. - Performance: Lightweight script optimized for Core Web Vitals (no slow-loading blocks). - Efficiency: Designed for indie hackers who need professional results without the enterprise price tag.

The builder is ready to use so you can see exactly how your data looks. It does require a signup to save your work, but you can get a widget live in under 2 minutes.

I’m curious: Have you felt limited by the pricing or design of current no-code tools? What’s the one feature that would make you switch your current stack to something like this?

Would love to hear your thoughts!

Something I have been working on for a while. Pet project for my own use that a bunch of people asked me if they could play with.

Chrome extension and desktop widget (Electron) to make it easy to capture notes, screenshots, links, audio, files almost anything. Pushed into your own knowledge base. We apply a little AI to fix typos, pull out topics, people, but of summarisation (needs a lot of work), and relationships to other entries.

You can search, quick and dirty or AI natural language and use grids, kanban and other UIs so sort and interact with whatever you have captured - projects, tasks, knowledge.

Lots of customisation to make it work your way.

There are lots of bugs, issues, and maybe poor design choices. And HN is tough crowd. But I also think there is the bones of something cool here so would love feedback.

Lately I've been getting a ton of ads for a device called Brick https://getbrick.app/ which is an NFC tag that you have to scan in order to unlock distracting apps on your phone. I really like the idea, and since I had an ESP32 with a screen laying around I figured that I could use this instead.

I made a simple iOS app that uses the Screen Time API to block a selection of apps. Once blocked, you have to scan the QR code on the ESP32 screen. This QR code is updated every 30 seconds using the TOTP algorithm (which is used by authenticator apps). It only uses a hardcoded shared key and the current timestamp, so there is no need to make the ESP32 and the iPhone communicate together. You do need to connect the ESP to WiFi at boot to sync its clock via NTP.

This design allows the QR code to be displayed on anything (e.g. a web page), but having it on a dedicated device adds more friction, which we want!

Hi HN,

I built a TUI for ProtonVPN because I wanted a better way to browse and filter servers directly from the terminal without relying on the GUI.

It's written in Rust using `ratatui` for the interface.

*The experiment:* This project was almost entirely built by AI coding agents. I acted as the architect/product owner, reviewing code and directing the agents, but wrote very little code manually.

Repo: https://github.com/cdump/proton-tui

Hello guys,

As a developer, technical interviews are part of our journey. But somehow, I have issues to prepare it the right way.

So I decided to build my own technical ITW prep tool.