Tech Articles
Demystifying Postgres EXPLAIN Is Sequential Scan Always a Performance Blocker
Explores the nuances of PostgreSQL's sequential scan, challenging the common misconception that it's inherently bad and demonstrating scenarios where it's efficient.
Build a Docusaurus-like Site with FastAPI: Step 2 - Render Markdown
This article guides you through rendering Markdown files in a FastAPI application by installing `python-markdown`, creating a new route, and passing the converted HTML to a Jinja2 template.
Understanding and Mitigating Database Connection Exhaustion in High-Concurrency Web Applications
Explores why web applications face database connection exhaustion under high concurrency, detailing underlying mechanisms, common pitfalls, and practical solutions with code examples.
Build a Docusaurus-like Site with FastAPI: Step 1 - HTML Template
This guide explains the first step in building a documentation site with FastAPI: setting up the project and using Jinja2 to render a dynamic HTML template.
The Silent Killer Understanding NULL's Impact on Database Performance
NULL doesn't just mean "no value"; it has profound implications for how databases operate, especially when it comes to indexes, COUNT(), and JOINs. This article explores these often-overlooked effects and provides practical insights into mitigating them.
Event Sourcing with a Single Database Table A Simplified Approach
This article explores implementing event sourcing using only a database table for event logging, offering a simpler alternative to Kafka while detailing its principles, implementation, and practical use cases with code examples.
Build Your Own Forum with FastAPI: Step 10 - Categories
This article explains how to add a "Categories" feature to a FastAPI forum by updating database models, modifying routes, and updating templates to organize posts by topic.
Choosing the Optimal UUID Type for PostgreSQL Primary Keys
This article thoroughly examines UUID v1, v4, and v7 as primary key candidates for PostgreSQL, explaining their characteristics, practical implications, and offering a data-backed recommendation for optimal database performance and scalability.
The Silent Killer of Databases - Why Logical Deletion Harms More Than Helps
This article delves into the common misconception of using `is_deleted = true` for data deletion, explaining why it's a harmful anti-pattern and proposing robust, maintainable alternatives for managing "deleted" data.
Build Your Own Forum with FastAPI: Step 9 - Upload Images
This guide details adding S3 image uploads to a FastAPI forum. It covers backend logic with `boto3`, database model changes, and updating FastAPI routes and HTML templates.
The Great Primary Key Debate for Modern Web Applications
A deep dive into the pros and cons of UUIDs, BIGINTs, and Natural Keys for primary key selection in modern web applications, exploring their implications on scalability, performance, and development.
Stream Processing with io.Reader and io.Writer in Go Web Development
This article delves into how io.Reader and io.Writer interfaces enable efficient stream processing for requests and responses in Go web applications, improving performance and memory usage.
Choosing Between Postgres Materialized Views and Redis Application Caching
This article delves into the critical decision-making process for leveraging Postgres materialized views versus Redis application-level caching, helping developers select the optimal data acceleration strategy for their applications.
Crafting Custom Errors and HTTP Status Codes in Go APIs
This article delves into the best practices for defining custom error types in Go APIs and mapping them elegantly to appropriate HTTP status codes, enhancing error handling and API clarity.
Build Your Own Forum with FastAPI: Step 8 - Full Text Search
This guide adds a powerful full-text search to a FastAPI forum using PostgreSQL's `tsvector`, SQL triggers, and a new search route.
Why Database Triggers Often Lead to Trouble
This article delves into the reasons why database triggers should generally be avoided, emphasizing the placement of business logic outside the database for better maintainability and scalability.
Decoding the Intricacies of JSON with json.RawMessage and Custom Unmarshaling
Explore how json.RawMessage and custom UnmarshalJSON in Go empower developers to handle complex and evolving JSON structures with grace and efficiency, preventing data loss and enhancing flexibility.
Achieving Robust Multi-Tenant Data Isolation with PostgreSQL Row-Level Security
Explore how PostgreSQL's Row-Level Security (RLS) offers a database-native solution for ensuring strict data isolation in multi-tenant applications, moving beyond application-level enforcement.
Build Your Own Forum with FastAPI: Step 7 - Permissions
This guide implements a permission system for the FastAPI forum, adding admin roles and a user-banning feature with model updates and protected routes.
Understanding and Debugging Goroutine Leaks in Go Web Servers
This article delves into common scenarios causing goroutine leaks in Go web servers, explains the underlying mechanisms, and provides practical methods for detection and resolution.
Authentication or Authorization Deciding the Right Fit for Your Backend
Navigating the complexities of user identity and access control is a common challenge for backend developers. This article demystifies OIDC and OAuth 2.0, helping you choose the appropriate solution for authentication or authorization in your applications.
Build Your Own Forum with FastAPI: Step 6 - Comments and Replies
This guide details adding comment and reply functionality to a FastAPI forum by updating database models, creating a new `post_detail.html` template, and implementing backend routes.
Efficiently Orchestrating External API Calls with Go Fans
Discover how Go's Fan-In, Fan-Out pattern unlocks powerful concurrency for processing data from multiple external APIs, enhancing performance and scalability.
Designing Observable APIs from the Ground Up
Integrating logging, metrics, and tracing into API design processes for robust and maintainable backend systems.
Choosing Your PostgreSQL Connection Proxy
A deep dive into PgBouncer and Pgpool-II, two popular connection pooling solutions for PostgreSQL, exploring their features, use cases, and how to select the right one for your needs.
Build Your Own Forum with FastAPI: Step 5 - Editing Posts
This tutorial explains how to add a secure post-editing feature to a FastAPI forum. It covers creating templates, adding API routes, and verifying user ownership before allowing edits.
From Monolith to Modularity Refactoring Go Web Applications
This article delves into the crucial process of refactoring a monolithic Go web application, initially housed in a single main.go file, into a modular, maintainable, and scalable project structure. It covers the rationale behind this transformation, core concepts, practical implementation steps with code examples, and the significant benefits reaped.
Understanding the Core Differences Between API Gateways and BFFs
Exploring the distinct roles and practical applications of API Gateways like Kong and Backend for Frontend (BFF) patterns in modern microservice architectures.
Understanding Consistency Models in Web Development
Explore the trade-offs between strong consistency and eventual consistency in web development, covering their definitions, implementation techniques, and practical use cases with code examples.
Build Your Own Forum with FastAPI: Step 4 - User System
This guide details adding a user authentication system to a FastAPI forum, covering registration, login, and password hashing to associate posts with authors.
Type-Safe Configuration in Go Without Viper
Discover how to achieve robust and type-safe application configuration in Go using struct tags and environment variables, offering a lightweight alternative to external libraries like Viper.
Streamlining Backend Dependencies with the Factory Pattern
Explore how the Factory Pattern enhances backend service layers by effectively managing dependencies and strategies, improving modularity and testability.
Understanding Prepared Statements for Robust Security and Optimal Performance
Delve into how prepared statements fundamentally enhance SQL security against injection attacks and contribute significantly to database performance.
Build Your Own Forum with FastAPI: Step 3 - HTML Template
This guide shows how to integrate the Jinja2 template engine with a FastAPI forum, separating HTML presentation from Python logic for cleaner, more maintainable code.
Building a High-Performance Concurrent Cache in Go with sync.RWMutex
This article explores how to leverage Go's sync.RWMutex to create an efficient and thread-safe in-memory cache, offering detailed explanations and practical code examples for robust concurrent applications.
Why Monolithic Architecture Reigns Supreme for New Projects in 2025
This article argues for the continued relevance and strategic advantage of monolithic architecture for new backend projects in 2025, emphasizing its benefits in development efficiency, operational simplicity, and accelerated time-to-market.
Cache Invalidation Strategies Time-Based vs Event-Driven
Exploring the core differences and applications of time-based and event-driven cache invalidation to optimize data consistency and performance in database systems.
Database Connection Management in Go Web Apps A Dive into Dependency Injection vs. Singleton
Exploring best practices for managing sql.DB instances in Go web applications, comparing singleton patterns with dependency injection to ensure robust and maintainable code.
Ensuring Microservice Compatibility with Consumer-Driven Contracts
This article explores how Pact.io facilitates consumer-driven contract testing in backend microservices, ensuring robust and reliable integration between services.
Build Your Own Forum with FastAPI: Step 2 - Integrating Database
This tutorial explains how to replace a FastAPI forum's in-memory list with a PostgreSQL database using SQLAlchemy, enabling persistent data storage for posts across server restarts.
Maintaining Index Health in PostgreSQL: When to Choose REINDEX or VACUUM FULL
This article clarifies the scenarios for using REINDEX versus VACUUM FULL in PostgreSQL to optimize index performance and storage, explaining their mechanisms and providing practical examples.
SQLC vs GORM - Two Approaches to Database Interaction in Go
Exploring the fundamental differences between SQLC and GORM for database operations in Go, highlighting their distinct philosophies and use cases.
Build Your Own Forum with FastAPI: Step 1 - A Minimal Forum
This beginner-friendly tutorial shows how to build a simple forum from scratch using Python and FastAPI, covering setup, core APIs, and a basic HTML front-end for a working prototype.
Orchestration vs. Choreography - Event-Driven Backend Integration
Exploring the two primary event-driven patterns, orchestration and choreography, for building robust and scalable microservices architectures. This article delves into their principles, implementation strategies, and practical applications with code examples, helping you choose the right approach for your backend systems.
Granular Database Roles for Web Application Modules
This article delves into the importance and implementation of creating dedicated database roles and permissions for different modules within a web application to enhance security and maintainability.
Elegant Error Handling in Axum/Actix Web with IntoResponse
This article explores how to gracefully transform Rust's Result type into HTTP error responses within Axum and Actix Web frameworks using the IntoResponse trait.
Unpacking Middleware in Web Frameworks - A Chain of Responsibility Deep Dive
This article delves into the core mechanics of middleware in popular web frameworks like Express, Gin, and Axum, revealing its implementation as a classic Chain of Responsibility pattern. We explore its principles, practical applications, and provide code examples to illustrate how this design pattern empowers flexible and modular request processing.
Streamlining SQL with Common Table Expressions for Enhanced Readability
This article delves into the power of CTEs in SQL, demonstrating how they simplify complex queries and significantly boost code readability for better maintainability and collaboration.