Day 17: Server-Side Rendering and Debugging with Python and Node.js

🚀 Today I went deeper into building backend APIs using Python, FastAPI, and Async SQLAlchemy. Instead of just learning theory, I implemented a mini backend system that includes: 🔹 REST API endpoints with FastAPI 🔹 Request & response validation using Pydantic 🔹 Async database integration with SQLAlchemy 🔹 SQLite async engine configuration 🔹 UUID-based primary keys for scalable data models 🔹 Automatic database table creation at startup 🔹 Error handling using HTTPException Example endpoints implemented: • GET /posts/{id} → Retrieve a post • POST /post → Create a new post Tech stack used today: Python 🐍 FastAPI ⚡ Pydantic 📦 Async SQLAlchemy 🗄️ SQLite (async driver) Key learning today: Modern Python backend development is moving toward asynchronous architectures, which significantly improve scalability and performance for real-world applications. Next steps in this project: ✔ File upload API ✔ Authentication system (JWT) ✔ Cloud deployment ✔ Production-grade database integration Building every day. Improving every day. #Python #FastAPI #BackendDevelopment #AsyncPython #SQLAlchemy #SoftwareEngineering #BuildInPublic

Daily Learning Log: DSA + Development — Day 18 🚀 Day 18 was focused on strengthening backend fundamentals and improving project structure. 🧠 Python (DSA): ✅ Revised memory concepts (Stack vs Heap) ✅ Solved basic array problems (Reversing an array) ✅ Focused on writing cleaner loops and improving logical thinking 🌐 Development (Node.js + Express + MongoDB): ✅ Improved the structure of my URL Shortener project ✅ Learned Authentication concepts ✅ Understood Cookies, Sessions, and Tokens ✅ Learned why authentication is important in real-world applications ✅ Worked on smoother frontend and backend integration 🔑 Key Takeaway: 👉 Learning backend is not just about building APIs. It’s about understanding security, data flow, structure, and user management. Small improvements daily = Big growth over time 🚀 #Python #DSA #NodeJS #ExpressJS #MongoDB #BackendDevelopment #Authentication #LearningInPublic

Daily Learning Log: DSA + Development — Day 20 🚀 🧠 Python (DSA): ✅ Practiced array traversal (normal + reverse) ✅ Solved frequency count problems using dictionary ✅ Focused on avoiding off-by-one errors 🌐 Development (Node.js + Express + MongoDB): ✅ Revised authentication concepts ✅ Creating authentication for url shortner ✅ Fixed small bugs in backend routing Day 20 complete ✅ #DSA #100DaysOfCode #BackendDevelopment #Consistency #LearningJourney

Python 3.11 was released over two years ago, but I still see a lot of developers ignoring or simply not knowing about asyncio.TaskGroup. Most of us learned to use asyncio.gather() to run multiple async tasks concurrently. It’s what older tutorials teach, and it mostly works—until things go wrong. The issue with gather() is how it handles failures. Imagine you are running three concurrent database queries. If the first query fails and raises an exception, gather() instantly throws that exception back to you. But here is the catch: the other two queries are not cancelled. They keep running in the background as "orphaned" tasks. This leads to: • Wasted CPU, memory, and database connections • Unexpected race conditions later in your application lifecycle You can handle this manually with gather(), but it requires verbose try/except/finally blocks to explicitly track and cancel tasks. TaskGroup fixes this by bringing structured concurrency to Python. It ties the lifetimes of concurrent tasks together using a standard context manager: async with asyncio.TaskGroup() as tg: tg.create_task(fetch_data(1)) tg.create_task(fetch_data(2)) tg.create_task(fetch_data(3)) If any task in that block fails, the TaskGroup automatically cancels all other pending sibling tasks. No orphaned background processes, and no manual cancellation boilerplate. Additionally, if multiple tasks fail at the exact same time, it bundles them into an ExceptionGroup (also introduced in 3.11) so you can see all the errors instead of just the first one. It’s not some massive paradigm shift, just a solid feature that makes handling concurrent async operations cleaner and much safer. If your tasks depend on each other or should fail as a single unit, it's worth making the switch. Are you still using gather(), or have you made the switch to TaskGroup? #Python #Asyncio #SoftwareEngineering #BackendDevelopment

Building High-Performance APIs with Python + FastAPI Over the past few days, I’ve been exploring FastAPI, and it’s impressive how quickly you can build modern, high-performance APIs with it. Why FastAPI is becoming a popular choice among developers: High Performance – One of the fastest Python frameworks, comparable to NodeJS and Go. Automatic API Docs – Built-in interactive documentation with Swagger UI. Type Hints Powered – Uses Python type hints for validation and better developer experience. Async Support – Perfect for scalable, high-concurrency applications. Easy Integration – Works seamlessly with databases, ML models, and microservices. For developers working with AI, ML, or microservices, FastAPI is a powerful tool to expose models and services through clean REST APIs. I’m currently experimenting with Python + FastAPI for building scalable backend services and AI-powered applications. #Python #FastAPI #BackendDevelopment #APIs #SoftwareDevelopment #Programming #WebDevelopment #AI

🚀 Daily Learning Log: DSA + Development — Day 21 🧠 Python (DSA): ✅ Practiced array rotation (left + right rotation) ✅ Revised time & space complexity (Big-O basics) ✅ Solved problems using two-pointer technique ✅ Did dry run before coding to improve logic clarity 🌐 Development (Node.js + Express + MongoDB): ✅ Improved authentication middleware logic ✅ Worked on protected routes for URL shortener ✅ Understood how cookies + sessions work ✅ Refactored backend code for cleaner structure 💡 Key Learning: Think first. Code second. Brute force → Optimize → Pattern recognition. Day 21 complete ✅ Consistency building. Discipline growing. 🔥

Most performance problems are not CPU problems. They are database problems. Early in my career, when something was slow, my instinct was to look at the Python code. Later I learned the real bottleneck was almost always: Too many queries Inefficient joins Missing indexes Loading more data than necessary A single endpoint can look perfectly fine in code and still generate hundreds of database queries. A few habits that made a big difference for me: Always checking query counts during development Using select_related and prefetch_related intentionally Avoiding loading full objects when only a few fields are needed Being careful with nested serializers in APIs Django’s ORM is incredibly productive. But performance comes from understanding what SQL is actually being executed behind the scenes. The ORM abstracts the database. It does not eliminate it. Hashtags #Django #Python #BackendEngineering #PerformanceOptimization #DatabasePerformance #SoftwareEngineering

Python is powerful, but it has one well-known limitation: the Global Interpreter Lock (GIL). Because of the GIL, only one thread can execute Python bytecode at a time inside a single process. This means that traditional multi-threaded web servers in Python often don’t scale efficiently for high-concurrency workloads, especially when thousands of requests are waiting for network or database responses. This is where FastAPI comes in. FastAPI is a modern Python web framework built on top of ASGI (Asynchronous Server Gateway Interface). Instead of relying on heavy threads for every request, FastAPI uses async programming with an event loop. Here’s the simple idea: • A request comes in • If the request is waiting for I/O (database, API call, file read) • The event loop pauses that task and switches to another request So instead of 1 thread per request, a single event loop can handle thousands of concurrent requests. Think of it like a waiter in a restaurant: A traditional threaded server: The waiter stands at one table until the food arrives. FastAPI async model: The waiter takes the order, moves to other tables while the kitchen prepares the food, and comes back when it's ready. Because of this: • Much lower memory usage • Higher concurrency • Faster APIs for I/O heavy applications • Better scalability FastAPI doesn’t remove the GIL, but it works around the limitation by avoiding thread blocking and using non-blocking asynchronous execution. That’s why FastAPI has become one of the fastest growing frameworks for building high-performance Python APIs. #fastapi #python #backenddevelopment #softwareengineering #asyncio #systemdesign #programming #webdevelopment #tech

🚀 Day 2 of Learning Backend Development Today I started learning Flask — a lightweight Python framework used to build web applications and APIs. Here are some basics I understood: • Flask helps convert Python code into a web application • We can create routes (URLs) to handle different requests • It follows a simple and minimal structure (easy for beginners) • Useful for building APIs and backend systems Example idea: When a user opens a URL like /home, Flask runs a function and returns a response. Simple… but powerful. What I liked most: You can quickly build a working backend without too much setup. Currently exploring: • Flask project structure • How routing works • Handling user requests Next step → Learning Flask Blueprints and building a structured backend system. If you're learning backend or Python, what did you start with? 👇 #Day2 #Flask #Python #BackendDevelopment #LearningInPublic

Our team at Fivetran just made SQLGlot 5x faster... and it's written in pure Python. It is now competitive with other Python libraries that call out to Rust bindings. We decided to really spend time speeding up SQLGlot when we noticed that there were folks using LLMs to copy SQLGlot in other languages. We thought if people who don't work on SQLGlot can use AI to port it, certainly our core team who've dedicated years to its development could leverage AI to make it faster. SQLGlot v30 is dropping soon, and it's up to 5.3x faster than v28. The entire codebase is now pure Python, compiled to a C extensions via mypyc. We used to have a Rust based tokenizer but we've gotten rid of it because it's slower than mypyc compiled Python. But why are we going all in on Python and not Rust? Because I believe AI should assist developers, not replace them. A pure Python project means anyone can read it, debug it, and contribute to it. Also... I just find it to be more fun. Even though AI driven development will become more and more prevalent, I think that we're still going to be designing, reviewing, and steering the direction of the project. Therefore, the code is still for me and my developers, not the machine. mypyc gives us native performance without sacrificing our ability to be productive. SQLGlot is now the fastest (and arguably comprehensive) Python based SQL parser framework. It is even competitive with SQL parsing libraries built exclusively in Rust with Python bindings. Claude has also helped us contributed 7 PRs to mypy in order to improve mypyc's compatibility and performance. Kudos to them for building a great product and also being so quick to review and merge our work. #oss #sqlglot