Building a Python API with FastAPI and Pydantic

Have you ever been to dependency hell? A situation where a Python library version is causing a problem in your environment, but you don’t know which library it is and which version you should choose to fix it. Plotly staff member, Celia López Monreal, created a Plotly Dash App to debug dependency issues. More precisely, the app gets insights into library versions that might be causing issues in your Python environment. https://lnkd.in/eEKZYPmj

💡 𝗧𝗶𝗽 𝗼𝗳 𝘁𝗵𝗲 𝗗𝗮𝘆 — 𝗗𝗷𝗮𝗻𝗴𝗼 𝗗𝗶𝗱 𝘆𝗼𝘂 𝗸𝗻𝗼𝘄? Django’s "annotate()" lets you add 𝗰𝗮𝗹𝗰𝘂𝗹𝗮𝘁𝗲𝗱 𝗳𝗶𝗲𝗹𝗱𝘀 𝗱𝗶𝗿𝗲𝗰𝘁𝗹𝘆 𝗶𝗻 𝘆𝗼𝘂𝗿 𝗾𝘂𝗲𝗿𝘆𝘀𝗲𝘁𝘀. Instead of processing data in Python after fetching it, you can compute values at the 𝗱𝗮𝘁𝗮𝗯𝗮𝘀𝗲 𝗹𝗲𝘃𝗲𝗹. 🔧 𝗖𝗼𝗺𝗺𝗼𝗻 𝘂𝘀𝗲 𝗰𝗮𝘀𝗲𝘀: - Counting related objects ("Count") - Calculating averages ("Avg") - Adding computed fields to API responses This reduces data processing in your app and leverages the power of your database. Smarter queries = faster apps. #Django #Python #BackendDevelopment #WebDevelopment #DatabaseOptimization #PerformanceOptimization #SoftwareEngineering #CodingTips #FullstackDeveloper

LoraDB is now public. https://loradb.com/ It is a fast in-memory graph database written in Rust, with a Cypher-shaped query engine, an HTTP API, and bindings for Node.js, WebAssembly, and Python. It is built for developers who need relationship queries close to their application without adopting a large graph database stack on day one. This release is the beginning of the public journey: source-available core, developer-first adoption, and a path toward a hosted platform for teams that want managed operations later.

Graph databases are overkill for most product work. So I built LoraDB. An embedded, in-memory graph database that runs in the browser at million-node scale, with near-full Cypher support. It’s really, really fast: ~7.4M nodes/sec scans ~3.8M edges/sec traversals ~900K nodes/sec writes Node.js, WASM, Python, Go, Ruby Benchmarks: https://lnkd.in/e_qmfqQQ Curious who else felt this gap.

As I prepare for my upcoming lab performance on FastAPI with Python, I wanted to break down something simple but important: how it actually works and why we even need it. How FastAPI works: FastAPI is a modern Python framework used to build APIs (Application Programming Interfaces). In simple terms, it acts as a bridge between the frontend and the database. - You define routes (URLs) where users or systems send requests - FastAPI processes those requests using Python functions - It validates data automatically (which saves a lot of time) - Then it sends back a response (like data, status, or results) It’s built on top of powerful standards like async programming, which makes it super fast and efficient. Why we need FastAPI: Here’s the real point— - Modern apps (web, mobile) need fast and reliable backends - APIs are the core way different systems communicate - FastAPI helps build these APIs quickly with less code and fewer errors - It’s perfect for scalable systems, AI apps, and real-time services What this really means is: learning FastAPI is not just about passing a lab—it’s about understanding how real-world applications handle data and communication behind the scenes. Still learning, still improving—but getting closer to building something real. #FastAPI #Python #BackendDevelopment #APIs #CSE #LearningJourney

I’ve been exploring Python for the past few days. Since I already work with JavaScript, one question kept bothering me: Why does Python always require a virtual environment, while Node.js doesn’t? After digging deeper, here’s what I understood: In Python, we use virtual environments to isolate dependencies. Each project gets its own set of libraries, which avoids version conflicts across projects. Without this, managing packages globally would quickly become messy. In contrast, Node.js uses a different approach. It installs dependencies locally inside the project (node_modules). It also allows nested dependencies, meaning different packages can depend on different versions of the same library. This flexibility comes with a trade-off: → Large node_modules folders → Duplicate packages → The infamous “node_modules hell” So the difference is not that Node.js doesn’t solve the problem — it just solves it in a different way than Python. Key takeaway: Both ecosystems handle dependency management differently: Python → isolation via virtual environments Node.js → local + nested dependency system Understanding these differences helps you make better decisions when switching between ecosystems. If you’re a developer who likes going deeper into concepts, this is worth exploring. #Python #JavaScript #WebDevelopment #Backend #LearningInPublic

Day 13 of my Python Full Stack journey. ✅ Today's topic: Scope — where your variables live and die. This one concept explains so many confusing bugs. Here's what I typed today: # Local scope — only lives inside the function def my_function(): message = "I only exist here" print(message) # works ✅ my_function() # print(message) # ❌ Error! message doesn't exist out here # Global scope — lives everywhere name = "Punith" def greet(): print(f"Hello {name}") # works ✅ greet() # Modifying a global variable inside a function count = 0 def increment(): global count count += 1 increment() print(count) # 1 ✅ Biggest lesson today: Avoid using 'global' too much. If every function is touching the same variable — that's a sign your code needs better structure. This is exactly why functions should take inputs and return outputs — not secretly modify things from outside. Small concept. But this is how senior developers think. #PythonFullStack #Day13 #BuildingInPublic #100DaysOfCode #Bangalore

Day 57 of #100DaysOfCode 🚀 Today I built a blog application using Flask 🧩 I focused on understanding how to structure a web app using Flask, including routing, templates, and handling user input. It was interesting to see how quickly you can turn a simple idea into a working blog with Python. 🔹 What I worked on: Setting up a Flask project Creating routes for home, post, and add blog pages Using Jinja2 templates for dynamic content Handling form submissions Basic styling for better UI 💡 Key learning: Flask makes backend development feel simple and flexible. Once the basics are clear, building real-world projects becomes much easier. Still a lot to improve — like adding authentication, database integration, and deployment — but this feels like a solid step forward. On to Day 58 💪 #Flask #Python #WebDevelopment #CodingJourney #LearnByDoing

Every framework you have ever used is just design patterns written in production code. Day 06 of 30 -- Design Patterns in Python Advanced Python + Real Projects Series Django post_save is the Observer pattern. DRF renderer_classes is the Strategy pattern. logging.getLogger() is the Singleton pattern. @app.route is the Decorator pattern. Most developers use all of these every day without knowing the names. Today's Topic covers: Why patterns exist and the 3-category decision framework 6 patterns every Python backend developer must know Singleton with double-checked locking for thread safety Factory with self-registering decorator pattern Observer event bus with decorator-based subscriptions Strategy using typing.Protocol for structural subtyping Real scenario -- Factory + Strategy + Observer in one order pipeline 6 mistakes including pattern hunting and Observer without error isolation 5 best practices including why Python functions are strategies Key insight: Design patterns are not solutions you add to code. They are names for solutions already in your code. Phase 1 complete -- 6 days of Python internals done. #Python #DesignPatterns #SoftwareEngineering #BackendDevelopment #Django #FastAPI #100DaysOfCode #PythonDeveloper #TechContent #BuildInPublic #TechIndia #CleanCode #PythonProgramming #LinkedInCreator #LearnPython #PythonTutorial

🚀 Day 01 of 30 — Advanced Python + Real Projects I used @app.route() for 2 years before I understood what was actually happening. Turns out? It's just a decorator. And decorators are just functions wrapping functions. But here's what nobody tells you — Every serious Python framework you've ever used is built on this one pattern: → Flask uses it for routing → FastAPI uses it for dependency injection → Django uses it for auth (@login_required) → Celery uses it for task registration → Pytest uses it for fixtures Once you truly understand decorators, you stop being a framework user. You start being a framework reader. ✅ Why decorators exist (the real reason) ✅ The "onion model" mental model ✅ 4 types used in production ✅ Fully annotated syntax breakdown ✅ Real e-commerce API example with auth + cache + rate limiting ✅ Common mistakes senior devs still make ✅ Performance tips from real systems 💡 Key insight: "A function that needs 5 decorators probably has 5 responsibilities that aren't the function's fault." Save this. You'll need it. 🔖 #Python #PythonProgramming #SoftwareDevelopment #BackendDevelopment #Programming #CodeNewbie #Developer #TechLinkedIn #PythonDeveloper #LearnPython #SoftwareEngineering #CodingLife #100DaysOfCode #FastAPI #Django #OpenSource #TechContent #LinkedInLearning #DataEngineering #PythonTips #PythonTutorial