Engineering Logs
Notes on systems, simplicity and complexity.
People Who Aren’t Afraid to Ask Questions Build Better Teams
Many teams slow down not because of technical limitations, but because of communication problems. When people hesitate to ask questions, become defensive after mistakes, or avoid sharing ideas, learning starts to slow down. Psychological safety refers to an environment where team members feel comfortable asking questions, making mistakes, and expressing opinions. In this article, we explore why psychological safety is not an HR topic, but a direct engineering productivity concern.
API Design From a Frontend Engineer Perspective
API design is often treated as a backend responsibility. But in reality, frontend teams usually pay the biggest price for poorly designed APIs. Inconsistent responses, unnecessary nesting, unclear endpoints, and unpredictable behavior significantly slow down frontend development. This article explores API design from a frontend engineer’s perspective and explains why good APIs should not only work — they should be consumable.
Design System vs Component Library
In frontend development, “Design System” and “Component Library” are often used interchangeably. However, they are fundamentally different. A component library focuses on reusable UI pieces, while a design system goes much further by defining visual language, usage principles, consistency, and cross-team standards. This article explores the real difference and why it matters.
Frontend Folder Structure Matters More Than You Think
Folder structure in frontend projects often seems like a minor detail. But as the project grows, it becomes one of the most critical aspects. A good structure improves readability, team speed, and maintainability, while a bad one creates chaos over time. This article explores the long-term impact and practical approaches.
Using AI Without Understanding Is Dangerous
AI-assisted coding is now part of daily development workflows. While it provides speed, using AI without understanding introduces serious risks: amplified bugs, increased technical debt, and loss of engineering control. This article explores these risks and how to use AI effectively.
Engineering Ownership: The Difference Between Coding and Engineering
Coding and engineering are often treated as the same thing, but they are fundamentally different. Coding is about completing tasks, while engineering is about understanding system impact, sustainability, and long-term consequences. In this article, we explore this difference through real-world scenarios and the concept of ownership.
Props vs Context vs State: Choosing the Right Tool
State management in React is not just a technical detail — it’s an architectural decision. Props, local state, and Context API solve similar problems in different ways. Choosing the wrong tool can lead to complexity, performance issues, and hard-to-maintain code. In this article, we explore when to use each with practical examples.
AI Writes Code, But Engineers Design Systems
AI tools can now write functions, fix bugs, and even generate entire components. However, software engineering is more than just churning out lines of code. While coding is a task of "production," system design is an art of "decision-making." In this article, we explore why engineering in the AI era goes far beyond writing code and why architectural vision is more critical than ever.
React Re-render Myths Developers Still Believe
One of the most misunderstood topics when discussing React performance is re-render behavior. Many developers see re-renders as always bad and start optimizing prematurely. However, React’s re-render mechanism is often cheaper than developers assume. In this article, we explore the common myths and realities around React re-rendering.
Code Review Is Not for Finding Bugs, It Is for Breaking Egos
Many developers view Code Review (CR) as a session to catch bugs. However, in high-performing teams, CR is less of a technical checklist and more of a tool for breaking down individual egos and building collective intelligence. In this article, we explore why the true value of code review lies in culture and growth, rather than just technical correctness.
React key Prop: Small Detail, Big Bug
The key prop in React often looks like a small detail, but incorrect usage can lead to unexpected bugs and performance issues. In this article, we explore why key usage matters, common mistakes, and best practices with examples.
Being a Solo Developer Helps You Grow — But Can Also Blind You
Being a solo developer accelerates learning but can create blind spots in the long term. Lack of feedback, missing code reviews, and limited technical discussions can introduce quality risks. In this article, we explore the advantages, risks, and solutions of working as a solo developer with real-world examples.
Why Closure Questions Are Common in Frontend Interviews
Closure questions are commonly asked in frontend interviews. These seemingly simple questions actually measure how well developers understand JavaScript scope, async behavior, and function execution. In this article, we explore closures in detail, why they are frequently asked in interviews, and where they appear in real-world projects.
useMemo / useCallback Don’t Always Provide Performance: The Premature Optimization Trap
In React, useMemo and useCallback are powerful tools for optimization. However, forgetting the "Boring Technology" principle and memoizing everything creates complexity and technical debt instead of performance. We explore the actual cost of memoization and when it’s truly necessary.
useEffect Is Not the Solution to Every Problem
useEffect is one of the most powerful hooks in React, but unnecessary usage can introduce complexity, extra renders, and hard-to-debug issues. This article explores when not to use useEffect and simpler alternatives.
AI Writes Code, But Takes No Responsibility
AI tools are significantly boosting developer productivity. However, speed gains come with new risks. This article explores the advantages, risks, and the "responsibility gap" of using AI in software development.
var vs let vs const: Not Syntax, It’s About Behavior
The difference between var, let, and const is often explained as simple syntax rules. But the real difference is about behavior and predictability. This article breaks it down in a simple, practical way.
The "Boring Technology" Principle: The Power of Predictability in Engineering
Trying out the newest framework in software can be fun. But in production systems, we crave predictability, not excitement. Let's explore the "Boring Technology" principle and how choosing proven tools preserves the colony's energy.
SSR vs. SPA: Finding the Perfect Balance in Next.js
Should every page be SSR? Or should everything run with SPA speed? In the hybrid world of Next.js, we explore the rendering strategies that will define the fate of your project.
Over-Engineering: The Silent Killer of Software Projects
Bad code slows you down, but unnecessary complexity kills the project. Let's explore how "clever" architectural decisions turn into technical debt traps and how to avoid them using the "Lazy Ant" philosophy.
Why React State Must Be Immutable: The Engineering Behind the Rule
One of the golden rules of React development is "Don't mutate state." But why? In this post, we'll dive deep into why this rule isn't just a stylistic preference. We'll explore the reference comparison optimization at the heart of React's render engine and learn how to write predictable, performant code that aligns with the "Lazy Ant" philosophy.
CSS Grid vs. Flexbox: Mastering the Art of Choosing the Right Layout Tool
The endless frontend debate: Grid or Flexbox? The answer isn't in a technical features list; it's in the mental model you develop. Stop over-engineering your CSS. Learn where and how to combine these two powerful layout systems for clean, efficient modern UIs.
Building a Dynamic Page Builder with Headless CMS
Why hardcode pages when you can build a flexible system? Learn how to combine the power of Next.js with a Headless CMS to create a dynamic Page Builder that empowers both developers and editors.
Component Composition Over Configuration
Stop building "God Components" with 30 props. Sometimes the best API is no API at all. Let's explore why composition beats configuration for maintainable React systems.
State Management Without Libraries
Redux, MobX, Zustand... do you really need them? Often, React's built-in tools are enough. Let’s climb the state complexity ladder and see where your app actually lands.
Why Simple Systems Win
Complexity is not a badge of honor; it’s technical debt waiting to happen. In a world obsessed with the "new," choosing boring technology and simple architectures is the ultimate competitive advantage.