Ertugrul Mutlu’s Post

𝗨𝗡𝗟𝗘𝗔𝗦𝗛𝗜𝗡𝗚 𝗧𝗛𝗘 𝗨𝗟𝗧𝗜𝗠𝗔𝗧𝗘 𝗣𝗬𝗧𝗛𝗢𝗡 𝗣𝗢𝗪𝗘𝗥𝗛𝗢𝗨𝗦𝗘: 𝗧𝗛𝗘 𝗦𝗘𝗖𝗥𝗘𝗧 𝗧𝗢 𝗕𝗨𝗜𝗟𝗗𝗜𝗡𝗚 𝗟𝗜𝗚𝗛𝗧𝗡𝗜𝗡𝗚 𝗙𝗔𝗦𝗧 𝗔𝗣𝗜𝗦 𝗥𝗘𝗩𝗘𝗔𝗟𝗘𝗗 As we head into 2026, building scalable microservices requires a rock-solid understanding of how your code is organized from the first line. This guide demystifies the structural foundations of FastAPI to ensure your backend remains maintainable as your codebase grows. THE FASTAPI INSTANCE The core of every application begins with initializing the FastAPI class. This instance acts as the central router and configuration hub, serving as the bridge between your incoming HTTP requests and your internal application logic. Understanding how to instantiate this object correctly is the first step toward managing middleware, dependencies, and route decorators effectively. ROUTING AND PATH OPERATIONS Path operations are the fundamental building blocks of your API. By using decorators linked to your FastAPI instance, you define how the server responds to specific HTTP methods like GET or POST. This video breaks down how these functions map directly to URL paths, allowing for clean, readable code that handles client communication without unnecessary complexity. PARAMETER HANDLING AND TYPE HINTS FastAPI leverages Python type hints to perform automatic data validation and documentation. By defining expected types for path parameters, query parameters, and request bodies, you enable the framework to enforce data integrity before your logic even executes. This approach significantly reduces the surface area for bugs while providing built-in Swagger UI documentation for your endpoints. As a Senior Engineer, I cannot overstate that the structure of your application in 2026 is just as important as the logic inside it. FastAPI enforces good habits early by requiring explicit type definitions and clear route mapping, which saves hundreds of hours in debugging and refactoring down the line. Treat your project structure as your primary documentation. Tags: #FastAPI #Python #API #BackendDevelopment 📺 Watch the full breakdown here: https://lnkd.in/d7YeSp75

Your API isn’t slow. Your pagination is. 📉 It worked perfectly… until your data grew. Then every page got slower than the last. Nothing changed in your code. Only the dataset got bigger. The culprit? Offset pagination. The deeper the page, the more rows your database has to scan and skip. Page 1 → fast Page 1000 → painful Same query. Very different cost. The fix wasn’t caching. It was switching to cursor-based pagination. No skipping. Just jumping. In Django REST Framework, this was as simple as: Use 'CursorPagination' instead of 'PageNumberPagination'. Constant performance. Even at scale. Most performance issues aren’t complex. They’re patterns that don’t scale. Most developers don’t notice this until it’s too late. #BackendDevelopment #Django #Python #WebDevelopment #SoftwareEngineering #APIPerformance #DatabaseOptimization #SystemDesign #ScalableSystems #DjangoRESTFramework

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

🏗️ 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

We are encountering challenges with validating STAC JSON schemas in Python. Given that concurrency can be costly in Python, organizations ingesting and validating thousands of STAC items daily must seek more efficient solutions for the geospatial community that can reduce costs and energy consumption. To tackle this issue, we are developing a STAC validator in Golang. For more information, please visit gostac-validator hosted at StacLabs. https://lnkd.in/g2X3wC-P

Building a Backend System: Day 1 Kicking off FlowState, a workflow automation API (not generic todo app). Day 1 Focus: Modern Tooling & Optimization ✅ Python 3.13 & Django 6.0 (Latest Stable) ✅ uv for dependency management (Blazing fast) ✅ Multi-stage Docker build (Alpine based) ✅ Image size optimized to < 250MB 🐳 Why uv? It's Rust-based and solves Python packaging speed issues. Why Django 6? Leveraging the latest async capabilities and security features. Starting with a lean, modern foundation is key to scalable system design. Stack: Python 3.13, Django 6.0, PostgreSQL 17, Docker, UV. #BackendEngineering #Django #Python #Docker #BuildInPublic #SystemDesign #DevOps #UV

From the leaked Claude source code, people are porting the architecture and logic to a different language (python) to avoid legal issues. One example is this one: https://lnkd.in/eVpnWN-n I remember using claude code to reverse engineering it itself, the intention? to enable a custom llm proxy, and it worked! The llm proxy didn't follow the regular authentication mechanism (required extra headers, custom url pattern) plus a custom change in the response. It was the opencode before opencode 😅🤣

🦀 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

Data validation libraries were built to make computers happy... not the person debugging at 2am. So we made a different one, and it's now open source 🎉 Agentic apps, APIs and data pipeline break for the same reason: someone sends data in the wrong shape. A number arrives as a text. A required field is missing. The fix isn't more code, it's a contract: "here's what your data should look like, reject anything else before it causes damage downstream." A language-agnostic standard for the definition of these "contracts" exists and is called JSON Schema. Think of it as a bouncer for your API. However, existing tooling was not built for the AI era - where understandability, clarity and performance do all matter. At hiop we build systems that validate at scale, both server side in hiop cloud and client side in our MCP and dev toolchain. So we had to solve the trade-off in existing Rust libraries between good performance and cryptic error handling (try explaining "Schema Composition failure" at 2am). Alternatives were unmaintained or lacking validation APIs entirely. So we built rsonschema, and made it open source. For the non-Rust crowd: it works in Python too. pip install rsonschema and it's done. Happy coding! #opensource #rust #python #agents #ai #jsonschema

API Documentation in Django REST Framework — Simplified with drf‑spectacular Building APIs is easy. Maintaining them at scale? That’s where things get tricky. As teams grow and endpoints multiply, keeping a clear API contract becomes essential. That’s why I explored drf‑spectacular, a powerful tool that turns your DRF code into a clean, OpenAPI‑compliant schema — ready for Swagger and Redoc. In my latest Medium article, I break down: How to set up drf‑spectacular in minutes Why schema generation matters for scaling and collaboration Integrating JWT authentication for secure testing Hiding internal endpoints and documenting complex responses Best practices for production‑ready API docs Think of it as reverse‑engineering your API into documentation. 👉 Read the full article here: https://lnkd.in/dbuTaNym #Django #DRF #API #Documentation #OpenAPI #Swagger #Redoc #Python #BackendDevelopment