Donnchadh Murphy

Scaling an engineering team is a journey, filled with challenges, revelations, and rewarding moments. Reflecting on my time at Microsoft Ireland, I remember how our team grew and evolved, and with each new addition, each new challenge, we learned more about what it takes to scale not just a team,

Mentoring software engineers is more than a professional responsibility—it's a deeply rewarding journey that continually shapes how I approach leadership, collaboration, and innovation. Throughout my career at Microsoft, I’ve had the privilege of mentoring both up and down, gaining insights that have enriched not only my

Sometimes the biggest challenge in building great tools isn’t the tech itself—it’s getting the right people to work together in the right way. At Microsoft Ireland, we faced this head-on when tasked with creating tools to automate complex network operations. We had two groups of incredibly talented

Software architecture remains a foundational discipline that can make or break the success of a project. For many developers and architects, the challenge lies in balancing the theoretical principles of software architecture with the practical realities of building and maintaining complex systems. Fundamentals of Software Architecture: An Engineering Approach by

Creating systems that are maintainable, scalable, and adaptable to change is a significant challenge. Two powerful approaches that have gained widespread recognition for addressing these challenges are Clean Architecture and Domain-Driven Design (DDD). While each of these methodologies can be applied independently, they complement each other so well that, when

When designing software, choosing the right architecture is critical to the success of your project. The architecture you select shapes how your code is organized, how it evolves, and how easy it is to maintain over time. Among the various architectural styles, three popular approaches stand out: N-Tier Architecture, Clean

In modern distributed systems, managing the size of messages exchanged between services is critical for ensuring performance, scalability, and reliability. When dealing with large payloads, directly passing them between services can lead to issues such as increased network latency, memory consumption, and processing time. The Claims Check Pattern is a

In software development, the excitement of building new features or designing a cutting-edge architecture often takes center stage. However, amid this excitement, it’s easy to overlook a critical aspect that can determine the long-term success of your project: testing. Specifically, testing early in the Proof of Concept (POC) phase

The shift to remote work has transformed the way software teams collaborate and deliver projects. While remote work offers flexibility and access to a global talent pool, it also presents unique challenges that can impact project success if not managed effectively. In this blog post, we’ll explore strategies and

In distributed systems, ensuring data consistency across multiple services can be challenging, especially when dealing with scenarios that require eventual consistency or involve booking, allocation, or reservations. The Reservation Pattern is a useful strategy for managing these types of transactions, where resources must be reserved and confirmed before finalizing a

As organizations continue to adopt cloud-native technologies, containers have become the standard for deploying and managing applications at scale. While Kubernetes has emerged as the de facto orchestration platform for managing containers, its complexity can be overwhelming for teams without deep expertise in the ecosystem. Enter Azure Container Apps, a

Serverless computing has gained significant popularity in recent years, offering a new paradigm for building and deploying applications without worrying about the underlying infrastructure. Among the leading serverless platforms is Azure Functions, Microsoft's event-driven, serverless compute service. While Azure Functions offer many benefits, they aren't the

When developing software, handling errors and managing the results of operations is a crucial aspect of writing reliable and maintainable code. One approach to this is using the Result pattern, which is becoming increasingly popular in modern C# development. The Result pattern allows you to encapsulate the outcome of an

As APIs evolve and grow in complexity, managing and consuming them efficiently becomes a challenge. To address this, many organizations generate API clients—libraries or SDKs that simplify interaction with APIs. Two prominent approaches to generating these clients are using OpenAPI and Microsoft’s Project Kiota. In this blog post,

In recent years, artificial intelligence has made significant strides, particularly in the field of natural language processing (NLP). One of the most exciting applications of NLP in software development is the use of large language models (LLMs) and AI Copilots, such as GitHub Copilot, ChatGPT, and others. These tools have

As software developers, we often find ourselves juggling complex systems, intricate business logic, and sprawling codebases. With so much to manage, it’s easy to feel overwhelmed by the sheer amount of information we need to keep in our heads. In Code That Fits in Your Head, Mark Seemann offers

As software engineers, we often hear the phrase "code is read more often than it is written." While this may sound obvious, its implications are profound. One of the most effective ways to make your code easier to read and maintain is by writing self-documenting code. But what

In the world of software development, efficiency and code quality are paramount. While there are many strategies to achieve these goals, one technique that stands out for its effectiveness is pair programming. Pair programming involves two developers working together on the same piece of code, with one acting as the

Duplicate code is a common issue in software development, often referred to as code duplication or "DRY" (Don't Repeat Yourself) violations. While it might seem harmless at first, duplicate code can lead to maintenance headaches, inconsistencies, and increased technical debt as your project grows. When faced

In modern distributed systems, ensuring consistency across multiple microservices is a critical challenge. As organizations adopt microservices architectures, they often find themselves grappling with how to manage complex, long-running business processes that span multiple services. This is where the Saga pattern comes into play. Sagas are a design pattern for

In the world of software engineering, few methodologies are as powerful and widely respected as Domain-Driven Design (DDD) and Test-Driven Development (TDD). Both approaches focus on improving the quality, maintainability, and alignment of software with business needs. While DDD provides a strategic approach to building complex software systems that accurately