Skip to main content

Dev|Journal

Technical blog covering software architecture, backend development, AI, and engineering best practices.

Latest Posts

Page 3 of 4
AlgorithmsInterviewDynamic Programming

Best Time to Buy and Sell Stock: Finding Profit in a Single Pass

Learn how to find the maximum profit from a single stock transaction with an elegant O(n) solution. Discover why tracking the minimum price is the key insight that transforms this problem from complex to simple.

Read more
AlgorithmsInterviewHeap

Top K Frequent Elements: Finding Signal in the Noise

Master the Top K Frequent problem with practical heap-based and optimized solutions. Learn when to use max heaps vs min heaps, and why this matters for real-world data analysis.

Read more
AlgorithmsInterviewDFS

Flood Fill Algorithm - The Paint Bucket Tool Explained

Implement flood fill using DFS. Learn the key optimization: use color changes as implicit visited marking to eliminate the need for a separate Set. Includes iterative and recursive solutions with real trade-offs.

Read more
ThoughtsSecurityMLOps

The Future of Software Development: Security and Intelligence

Why security, MLOps, and AI agents not just code will define software in the next decade. Practical guidance for builders and leaders.

Read more
Software architecturePerformanceArchitecture

Caching, when to add it and how to avoid headaches

Best practices for caching layers, invalidation strategies, common failure modes, and practical patterns to reduce latency and backend load.

Read more
Software architecturePerformanceInfrastructure

CDNs, make the world feel closer

How CDNs improve performance and reliability: caching strategies, configuration tips, purge practices, and cost considerations.

Read more
Software architectureDatabasesArchitecture

Choosing a database, practicality over purity

Practical guidance to choose the right database for your needs: relational, key-value, document, column-family, graph, and NewSQL trade-offs.

Read more
Software architectureDatabasesOperations

Database replication, how to copy reliably and why it matters

Overview of replication modes, when to use synchronous vs asynchronous replication, and operational practices for reliable failover and scaling.

Read more
Software architectureDatabasesArchitecture

Database sharding, splitting data without losing your mind

A practical look at sharding strategies, design trade-offs, rebalancing, and operational tips for partitioning large datasets.

Read more
Software architectureSystem designArchitecture

Horizontal scaling, building systems that grow outwards

Practical guidance for scaling out by adding nodes, autoscaling flow, orchestration tips, and common pitfalls to avoid.

Read more
Software architectureSoftware designSystem design

Massively scaling a web application

A complete guide to scaling web applications from a single server to multi-region deployments. Covers vertical and horizontal scaling, load balancing, database sharding, caching, CDNs and more.

Read more
Software architectureNetworkingSystem design

Load balancers, the traffic cops of your architecture

Overview of load balancer types, trade-offs between L4 and L7, operational best practices, and deployment recommendations.

Read more
Software architectureArchitectureOperations

Multi-region deployment, global availability with local complexity

Guidance for running services across multiple regions: patterns for routing, data strategies, failover testing, and compliance considerations.

Read more
Software architectureSystem designOperations

Single server setup, when simple is best

Practical guide to single-server deployments: minimal ops, backups, monitoring, and safe evolution strategies for small teams and prototypes.

Read more
Software architectureSystem designArchitecture

Stateful vs Stateless, design choices that shape scalability

Compare stateful and stateless architectures, trade-offs for scaling, operational patterns, and practical techniques for managing state.

Read more
Software architectureSystem designArchitecture

Vertical scaling, when you need raw power

When to scale up a single machine, practical tuning tips for CPU, memory, and storage, and operational cautions for large-instance deployments.

Read more
AILLMGithub

Stock Weather AI

A compact AI toolkit that collects market data and news, runs lightweight evaluations, and produces per-ticker weather-style reports for stock analysis experiments.

Read more
2025techrecallfilai

Recallfilai: document workflow

Designing a linear document workflow system for Recallfilai. Covers multi-tenant workflow management, document lifecycle states, and the architecture of the workflow engine.

Read more
2025techrecallfilai

Recallfilai part 1: requirements and tech stack

Introduction to Recallfilai, an open-source document store with AI capabilities. Covers requirements including upload, search, malware detection, and the chosen tech stack.

Read more
GitGithubGitphoto

GitPhoto

A proof of concept using GitHub as encrypted cloud storage for personal photos and videos. Data is encrypted on-device and stored in private repositories managed by the application.

Read more
GitGithubToolkit

How to push large projects to Github

A practical shell script to push large projects (50+ GB) to GitHub by splitting commits into smaller chunks that fit within GitHub's 2 GB push limit.

Read more
Software architectureSoftware designSOLID

SOLID

Complete guide to SOLID principles in object-oriented programming. Learn Single Responsibility, Open-Closed, Liskov Substitution, Interface Segregation, and Dependency Inversion with practical examples.

Read more
Software architectureSoftware designSOLID

D (Dependency Inversion) from SOLID

Understand the Dependency Inversion Principle from SOLID. Learn why high-level modules should depend on abstractions, not concrete implementations, and how DIP enables testable, flexible architecture.

Read more
Software architectureSoftware designSOLID

I (Interface Segregation) from SOLID

Learn the Interface Segregation Principle from SOLID. Discover why fat interfaces force unnecessary dependencies and how to design focused, client-specific interfaces.

Read more