Building a Billing System from Scratch with Idempotency Keys

I wrote a JSONc formatter in Rust. It's basically just a clone of "fracturedJSON". JSONc is a variant of JSON that is commonly used for config files. It supports comments and trailing commas, unlike standard JSON. Anyhoo, my formatter renders this JSONc in a human-friendly way rather than what you'd see out of jq or python -m json.tool.

I built a RAG layer for Claude Code that cuts token usage by 80–90%                            Most devs using Claude Code don't realize they're burning tokens on files Claude doesn't need to read.                                                Ask Claude "how does auth work?" and it reads 3 full files — 1,500+ tokens just to answer with 40 relevant lines. I fixed that. What I built: A local hybrid RAG system that sits between Claude and your codebase:  → Late chunking — splits every file into overlapping 40-line windows  → Dense retrieval — semantic search with all-MiniLM-L6-v2 (runs fully local, no API key)  → BM25 sparse retrieval — keyword matching for exact symbol names  → Cross-encoder reranking — picks the 3 best chunks from 20 candidates  → File watcher — auto-rebuilds the index within 2 seconds of any file save Claude Code reads the CLAUDE.md and knows: run pip package before opening any file. It gets back 3 precise snippets with file path + line range. It reads only those lines. Nothing else. Real numbers on my Volta Engine project (76 files):  - Without RAG: 17,235 chars across 3 files for one question  - With RAG: 3,073 chars the exact 3 chunks that matter  - 82% fewer tokens. Same answer. The whole thing runs offline. No cloud embeddings. No API calls. Just a one time pip install and run it. Stack: sentence-transformers · rank-bm25 · watchdog · Python If you use Claude Code daily on a real codebase, this pays for itself in the first session. DM me if you want the scripts. 🧠  #AI #ClaudeCode #RAG #DeveloperTools #Python #LLM #Productivity

I use Tailscale a ton in our post-AI world, mostly to securely host vibecoded slop for myself that is useful for *me* and nobody else. Broadly speaking, you have three options for hosting an app on your tailnet: 1) a port on a host that is on your tailnet; 2) a docker sidecar; and 3) tsnet (tailnet as a library) if you write your app in go. I most often choose #3 and I fall back to #2 if I'm on a non-Go stack. I'm glad to see Tailscale is porting tsnet to rust so I'll have more options (like a python library compiled from rust).

Day 33/90 How will circular imports affect performance? They don’t. They stop the application from starting entirely. Circular dependencies between serializers blocked the server today. Moving imports inside the __init__ method resolved the loop and allowed for the removal of 608 lines of redundant code. Resuming after a 7-day break following Day 32. Backend EdTech Project: • Query Count: Reduced database queries from 36 to 4 for student lists. I used prefetch_related with a Prefetch object to batch-load only the enrollment records relevant to the current course. • Refactoring: Consolidated five serializers and several views into a single ModelViewSet. This removed 608 lines of unnecessary code. • Search Fix: Resolved a 404 error in the search action. self.get_object() was incorrectly applying filters to the lookup; switching to a direct lookup fixed the routing. • Stability: Added checks in StudentSerializer to prevent KeyError crashes when specific fields are excluded. Code can pass tests and still be inefficient. I found an N+1 leak and a broken sort order today only because I looked at the raw SQL logs. Just because the server starts doesn't mean the logic is right. It’s a reminder to use automated test scripts and CaptureQueriesContext—I have to trust the logs. How do you catch performance drops in your code? Do you use query-count limits in your test suite, or do you have a different method for catching these issues before they reach a review? #python #django #backend #drf #90daysofcode #sql #refactoring #coding

Did you know that Tailscale connects any device, anywhere to your own private intranet? I bet you did. But did you also know that those devices can also be individual programs? Yup, if you want to run a server on Tailscale, you don’t actually need a separate container or a cloud instance or anything like that. Any Go program can use our tsnet library to join your tailnet as its own service. The only catch is that it had to be a Go program. Until today! A small team of Rustaceans have been prototyping tailscale-rs and are publishing a very early preview. Initial bindings for Python, Elixir, and C are also available to try out. This isn’t anything official, so don’t make a big deal about it, but you can read more on our blog: 🦀 https://lnkd.in/gjX_rKfS

“App started breaking under the first production load test, even though the structure was correct.” Sometimes it’s not just about having a perfect application structure but about proper configuration tuning. That’s why I’m sharing another comparison, the earlier run without tuning (present on my profile) and the optimized version after tuning. At ~300 concurrent users, latency behavior degraded sharply, P99 reached ~2.7s and max spikes went up to ~7s, even though average response time still looked normal. The issue wasn’t the API structure or queries; it was how DB connections were being handled under concurrency. Pooling wasn’t properly enforced, so requests started queuing instead of executing in parallel. After fixing proper pool acquisition and ensuring each request correctly borrows/releases a connection, performance stabilized under the same load. Same system. Different behavior under pressure. #fastapi #python #backenddevelopment #postgresql

Production-ready multi-agent orchestration is finally here. With Agent Framework v1.0 introducing some exciting new features. My personal favourites: 1. Agent workflows 2. Middleware hooks 3. Integration with managed agents in Foundry Agent Service 4. Multi-agent orchestration with HITL 5. Skills 6. Foundry Tools, Memory, Observability and Evaluations and many more. Check out the amazing blog post from Shawn Henry detailing the various features with concrete examples in Python and .NET https://lnkd.in/dKBRDujY

🏗️ Building the Backbone: From Python Classes to Persistent Data "The best way to learn is to build, break, and fix. 🛠️ Over the last few days, I’ve been architecting the backend for my FastAPI TodoApp. It’s been a journey of connecting the dots: Defining the Schema: Using SQLAlchemy to turn Python classes into database tables. Establishing the Link: Setting up the engine and SessionLocal to bridge the gap between my app and SQLite. Overcoming Hurdles: Navigating Windows environment variables and mastering the SQLite3 CLI to verify data integrity. The foundation is now officially set. By calling models.Base.metadata.create_all(engine), my app now automatically generates its own database environment on startup. Next stop: Developing the CRUD API endpoints to bring this data to life! 🚀" #Python #FastAPI #SQLAlchemy #BackendDevelopment #CleanCode #SoftwareEngineering

Most backend projects stop at “it works.” I wanted to know — how well does it work under pressure? So I built a small performance lab comparing Flask vs FastAPI under real-world load. What I did: • Built identical REST APIs in both frameworks (same logic, same endpoints) • Simulated concurrent users using k6 • Tested both lightweight and CPU-heavy endpoints • Measured latency, throughput, and scalability behavior What I found: • Flask performance degrades sharply as concurrency increases • FastAPI handles concurrent requests more efficiently (~50% higher throughput at peak load) • Both frameworks struggle with CPU-bound workloads — async helps with concurrency, not heavy computation The most interesting part wasn’t which framework is “faster” — it was seeing where systems break and why. This project shifted my focus from just building APIs to understanding how backend systems behave under load ⚡ GitHub Repo: https://lnkd.in/gUhFmp4i #backend #fastapi #flask #python #systemdesign #performance #softwareengineering #webdevelopment

Eigen is a library in C++ with lazy evaluation for matrices and other linear algebra. An API should never fail to receive a request for data to be prepared. Instead the API, should receive requests to prepare data then compare the request to a cache and drop repeat requests. A separate request then can be made async to get the prepared data from multiple requests as one object. If the request fails it can be safely repeated or waited for longer.