Introducing rsonschema: A Fast and Understandable JSON Validator

🦀 We built a Rust crate. Meet #rsonschema ! hiop's JSON Schema validator for Rust, now open source - with Python bindings too. We needed solid JSON Schema validation for our data pipelines. We evaluated the existing options, but none matched our requirements for error clarity, API ergonomics, and long-term maintainability. So we built our own. #rsonschema is fast, gives you clear and actionable error messages, and has an API you can learn in minutes. You get a report. The report tells you what's wrong in a language you can actually understand. You fix it. Everyone goes home happy. 🎉 This is hiop's first open-source release. We've been running it in production and we're proud of where it's landed: good enough to share. Link in the first comment 👇 #Rust #OpenSource #JSONSchema #DataEngineering #Hiop

I built a mini Product API with FastAPI. If you’re learning backend, build this API first. Simple project, but it covers important backend fundamentals: - GET routes - POST routes - dynamic route parameters - request validation with Pydantic - basic error handling with HTTPException - in-memory data handling The project is small, but the concepts are used everywhere in real backend systems. Next step: replacing the in-memory product list with SQL. #FastAPI #Python #BackendDevelopment #SoftwareEngineering #APIDevelopment #RESTAPI #BuildInPublic #PythonDeveloper

Been spending my weekends on a Python side project and finally have something worth sharing. Built CareTrack API from scratch, a REST API for managing patient and provider records. It uses FastAPI, PostgreSQL, and JWT authentication, with a full CI/CD pipeline on GitHub Actions and a live deployment on Render. Tech stack: Python · FastAPI · PostgreSQL · SQLAlchemy · Alembic · JWT · GitHub Actions Live API docs: https://lnkd.in/e9beFYgM GitHub: https://lnkd.in/e53nQi9S Feedback always welcome. #Python #SideProject #BackendDevelopment #API

🚀 Top FastAPI Packages You Should Know in 2026 (Part 2) FastAPI already gives you speed. The real difference comes from the tools you add on top. These are a few packages I’ve been exploring recently while building APIs 👇 . . . . . . 💡 Small observation: Most performance gains don’t come from FastAPI itself. They come from how you structure, cache, and protect your APIs. If you’re interested in MCP + FastAPI use cases, I recently explored it here: https://lnkd.in/dbMFET_A Which one are you using in your projects right now? #FastAPI #Python #BackendDevelopment #APIs #WebDevelopment #OpenSource #DeveloperTools

A 40ms API became a 4ms API. Here's the only thing that changed. We were making 3 separate DB queries to assemble a response. Each was fast in isolation. Together, they were sequential — each waited for the previous. The fix: run them concurrently. In Python (asyncio), this went from: result_a = await get_a() result_b = await get_b() result_c = await get_c() To: result_a, result_b, result_c = await asyncio.gather(get_a(), get_b(), get_c()) That's it. No caching, no infra change, no complex refactor. The mental model that helps: always ask "are these operations actually dependent on each other?" before assuming they need to run in sequence. Most API latency problems aren't hard — they're just unexamined. #BackendDevelopment #PythonAsyncio #APIOptimization #SoftwareEngineering

FastAPI just unlocked a massive performance ceiling. 🚀 With the official release of FastAPI 0.136.0 supporting free-threaded Python (No-GIL) , I couldn't just read the changelog—I had to benchmark it. I ran a controlled, head-to-head comparison using identical code and identical hardware: ⚙️ Python 3.12 (GIL) vs. Python 3.13.0t (No-GIL) The result? A ~8x improvement in CPU-bound throughput. Same code. Same API. Zero changes. This is a game-changer for anyone running: 🔹 ML Inference APIs (real-time model serving) 🔹 Data Processing & ETL Workloads 🔹 CPU-Intensive Backend Services Is this the final nail in the coffin for the GIL bottleneck? Curious to hear what the Python backend community thinks. #FastAPI #Python #NoGIL #PerformanceEngineering #BackendDevelopment #Concurrency #MachineLearning

One of the most common FastAPI mistakes is reusing SQLAlchemy models as Pydantic response schemas. This doesn't just couple your layers—it makes it easy to accidentally expose fields like hashed passwords. In my latest post, I share 8 Sections of battle-tested patterns for structuring your FastAPI applications: 1️⃣ Centralized Config: Using pydantic-settings instead of scattered os.environ calls. 2️⃣ Dependency Injection: Leveraging Depends() for cleaner auth and DB sessions. 3️⃣ Business Logic: Moving core logic into pure Python service functions for easier unit testing. 4️⃣ Error Handling: Using app-level exception handlers to remove "try/except" noise from routes. Swipe through the PDF for the code examples and folder structures! ➡️ #FastAPI #Python #BackendDevelopment #WebDevelopment #CleanCode

Django vs FastAPI is not a debate. It's a use case question. Django when you need: Admin panel out of the box ORM, auth, migrations all bundled A monolith that ships fast A team that doesn't want to wire things together FastAPI when you need: High throughput async APIs Full control over every layer ML model serving or agentic backends Type safety and auto docs without extra setup Django is a framework that makes decisions for you. FastAPI is a framework that trusts you to make them. Neither is better. Wrong tool for the job is the only mistake. #Python #Django #FastAPI #BackendDevelopment #SoftwareEngineering

We spent years asking Python to orchestrate, sandbox, schedule, and run concurrent tasks while pretending the GIL wasn't there laughing at us. Two shifts are quietly fixing that... 1.) Hybrid runtimes like #OpenFANG let Rust handle sandboxing and execution while Python defines the workflow. Declarative glue,,, which is what most of us were using it for anyway. 2.) #Agents now generate Python instead of chaining tool calls. The old loop, #LLM tool LLM tool LLM tool, burned tokens for sport. Now the model emits one small program, runs it once, and several reasoning steps collapse into a single cycle. The two fit together. A hardened runtime makes generated code less terrifying, and generated code makes the runtime worth having. #Python is the language of intent. #Rust is where intent actually runs. Still chaining one call at a time... fair enough. Your token bill will tell you when...

FastAPI and Django Production Migration Challenges Revealed 📌 Django’s monolithic power meets FastAPI’s async speed-teams migrating to FastAPI report up to 300% faster dev cycles and razor-sharp I/O performance. But beware: you’ll lose built-in admin tools and session handling. The choice hinges on whether your app thrives on rapid iteration or raw throughput. 🔗 Read more: https://lnkd.in/dsBwaJ-J #Fastapi #Django #Python #Performance #Migration