Caching Is Not Free
Cache is one of the most misunderstood components in software architecture. We all know this story. You have a critical web application and you notice that the latencies of a few endpoints have gone up in the last few weeks.
Panayiotis Kritiotis
Thoughts on Engineering Leadership, Software Engineering
Latest posts
Staying Technical as an Engineering Manager
It’s Friday afternoon and you’re coming out of a week where the important work was mostly conversations. You look at the backlog and it hits you again: “I’m not doing enough technical work. I’m losing my edge. My identity. Damn.”
Redesigning my Website with an AI Partner: What a Joy
It’s been a long time since I wanted to redesign my website. I wanted it to feel like mine, but I kept postponing it. The problem wasn’t a lack of ideas. It was a mix of time, priorities, and to be honest, motivation. I’ve never been comfortable with the plumbing of CSS and JavaScript, and I didn’t want to spend my limited time mastering frontend development just to tweak a personal…
Domain-Driven Design in Go: Designing Entities - What Works, What Breaks, and What’s Overkill
At first glance, defining an entity in Go seems simple - just a struct, right? Well, not quite. Introduction I’ve been fascinated with Domain-Driven Design (DDD) for a while now. I’ve been using bits and pieces of DDD for several years, but in the last couple of years, I’ve spent considerable time deep-diving into its details - refining my understanding and exploring how to apply it effectively in…
Agile: Embrace the Philosophy, Not Rigid Framework Rules
Staying strictly fixated on any Agile framework and enforcing written-in-stone rules by the book is inefficient. “Pure Scrum/XP/Kanban is the way” Well, not necessarily. While all these are valid methodologies, they are not the only way.
3 Major Fallacies Engineers Make in Architecture Decisions
Over the past 10 years, I’ve led and participated in numerous architecture designs, learning a lot from my mistakes and observations. Architecture design is the foundation of successful software. It enables business strategy and vision, and it’s crucial for evolving a system without incurring huge costs as requirements change.
5 Essential Prioritization Frameworks for Engineering Managers
Your time is finite, and your team’s backlog feels endless - welcome to life as an Engineering Manager. As we highlighted in the previous post on the Engineering Manager’s ultimate goal, the most important part of your role is execution - you need to deliver results. To do this as efficiently and effectively as possible, you need to identify the highest-leverage activities that will…
Understanding and Achieving Your Goal as an Engineering Manager: 3 Fundamental Principles
As an Engineering Manager, you have a lot on your plate and need a wide range of skills to be successful. From technical expertise, to execution know-how and people management, mastering all these skills takes a lifetime, no doubt about it.
Refreshing My Writing Journey
In August 2021, I published my first “Hello World” blog post. My goal was to share the valuable lessons I’ve learned and experienced with the community, while also documenting my journey and deepening my understanding of the topics I write about.
5 Lessons That Transformed How I Approach Execution as an Engineering Manager
In this blog post, I’m diving into execution; arguably the most crucial skill in engineering management because it’s all about delivering the results that drive your company forward. Throughout my career as an engineering manager, I’ve stumbled upon some game-changing ‘Aha Moments’ that totally shifted how I think about getting things done. These insights have not only…
8 Tips for Pragmatic Technical Decision-Making in Fast-Paced Environments
This blog post explores the engineering decision-making challenges in fast-paced development environments, the importance of maintaining technical agility, and presents a framework to make balanced technical decisions that enable consistent velocity and quality.
Feedback loops in software engineering
In this blog post, I write about the power of feedback loops and the essential characteristics of the ideal feedback loop. Introduction Our goal, as software engineers, is to deliver software projects. Personal projects, work projects, and projects of any type, size, and industry.
Implementing a simple, generic mediator pattern in go
This article presents a simple implementation of a generic mediator in Go. Introduction As software systems become larger and more complex, managing the interaction dependencies between different components can become complicated. Refactoring and introducing changes can also become particularly challenging and error-prone when the interaction semantics change.
Software Documentation - Value, Misconceptions, Common Pitfalls, and Essentials
This article explores the value of software documentation, a few misconceptions about the need for documentation, and some common pitfalls we fall into when we document software. Finally, it provides an overview of the essential documentation for software engineering teams and some guidelines for organizing documentation.
Implementing the Outbox pattern in go
This article presents the design and implementation of the outbox pattern in go. Introduction Last November, I wrote an article on what the outbox pattern is and its implementation challenges. If you are unfamiliar with the outbox pattern, I suggest reading this post first.
Software Engineering Philosophy: Tradeoffs and Quality
This post talks about software engineering philosophy; the list and priorities of the fundamental values we, software engineers, use to decide how to approach tradeoffs in software engineering problems. Introduction The nature of software engineering involves a continuous need for decision-making. Decision-making is needed for the design, development, and delivery of software. And can be even…
A systematic approach to Technical Requirement Analysis
This article describes a methodical way of approaching Technical Requirement Analysis that includes a list of steps that help in clarifying ambiguity and preventing unexpected issues before an engineering team jumps into the design phase.
Outbox pattern - Why, How and Implementation Challenges
This article presents the outbox pattern, a communication/messaging pattern used in event-driven distributed systems that allows executing database operations and reliably publishing messages. We will examine why we need the outbox pattern, how it works, and its implementation challenges.
Designing functions that return potentially absent values in Go
This article presents a micro-level design pattern to indicate the absence of function return values idiomatically in Go. Introduction Code readability is one of the most critical properties of maintainable software and a significant factor in reducing cost in software development1. It allows developers to correctly understand how software behaves with less effort while also preventing errors by…
Clean Architecture in Go [2024 Updated]
❇️ This post and the respective repository was updated in August 2024 to reflect a simplified infra layering approach and more accurate terminology This article covers the fundamentals of the Clean Architecture design concept and demonstrates how to apply its principles in Go through a simple web app implementation.