How I Define Good Application Architecture

In the ever-evolving field of software engineering, defining the attributes of good application architecture can be as subjective as it is technical. Throughout my career, I have encountered various metrics and standards used to measure the quality of software architecture. However, I believe that the most effective and perhaps the simplest test of good architecture is this: it takes fewer lines of code to create new functionality than one initially expects.

This principle might appear overly simplistic at first glance, but its implications are profound. Good architecture, in my view, inherently possesses qualities like modularity, reusability, and scalability. These features, when effectively implemented, lead to a system where adding or modifying features becomes a task less daunting than one might anticipate.

Modularity: The Cornerstone of Efficient Architecture

At the heart of this approach is modularity. A well-architected application is divided into discrete components or modules, each responsible for a specific piece of functionality. This separation of concerns not only makes the codebase more manageable but also allows for easier addition of new features. When the architecture is modular, new functionality often requires just a few lines of code to integrate a new module or to enhance an existing one.

Reusability: Doing More with Less

Reusability is another key aspect. Good architecture promotes the development of reusable components. When you can reuse existing components to create new functionality, the amount of new code required decreases significantly. This not only saves development time but also maintains consistency across the application, leading to fewer bugs and maintenance issues.

Scalability: Preparing for the Future

Scalability is integral to good architecture. An application that is scalable is designed with future growth in mind. It means that when the time comes to expand the application’s capabilities or to enhance its performance, this can be done with minimal changes to the codebase. A scalable architecture anticipates future needs, thus reducing the need for extensive rewrites or adjustments when those needs arise.

The Litmus Test of Fewer Lines of Code

Now, why do I consider “fewer lines of code for new functionality” as the litmus test for good architecture? It’s because this principle encapsulates the essence of modularity, reusability, and scalability. If adding a feature to your application requires an inordinate amount of new code, it might be a sign that the architecture isn’t as modular, reusable, or scalable as it could be. Conversely, if you find yourself pleasantly surprised at how little code is needed for new features, it’s likely a testament to the solid architecture of your application.

Final Thoughts

In conclusion, while there are many ways to assess the quality of software architecture, I find that the most telling is how efficiently new functionality can be added. A good architecture should feel like a well-oiled machine, where each part plays its role seamlessly, and improvements can be made without the need for extensive overhauls. This approach not only makes the development process more efficient but also results in software that is robust, adaptable, and future-proof.

How Non-Developers Can Keep Developers Engaged and Productive

In today’s fast-paced technology landscape, effective collaboration between developers and non-developing team members is more crucial than ever. A harmonious working relationship not only boosts productivity but also ensures that projects align closely with their intended goals. Central to this collaboration is the understanding that developers, like all professionals, seek appreciation for their work and clear communication about their deliverables.

Understanding Developer Needs

  1. Appreciation of Work: A developer’s motivation and job satisfaction are significantly enhanced when their efforts are recognized and valued. Regular acknowledgment of a developer’s hard work in meetings or through written commendations can go a long way. This recognition fosters a sense of belonging and purpose, driving developers to continue delivering high-quality work.
  2. Clarity on Deliverables: Developers thrive when they have a clear understanding of what they are building and why. Non-developers should strive to provide comprehensive briefs that explain not only the technical requirements but also the broader context and objectives of the project. This clarity helps developers feel more connected to the project and can lead to more innovative and aligned solutions.

Actions for Non-Developer Partners

  1. Detailed Discussions on Requirements: It’s crucial for non-developers to engage in in-depth discussions with their developer counterparts. These discussions should aim to clarify the project needs, the reasoning behind them, and the expected outcomes. Regular check-ins and brainstorming sessions can help refine these objectives, ensuring that both parties are on the same page.
  2. Timely Feedback: Once developers release new updates or versions, it’s imperative for non-developers to acknowledge this progress and provide feedback as soon as possible. This feedback should be constructive, focusing on both the strengths and areas for improvement. Timely responses not only show that the work is valued but also guide developers in the right direction for future updates.

A Personal Story: The Impact of Feedback Delay

My personal experience highlights the importance of these practices. In a recent project, I delivered a version of the code to the non-developer team and eagerly awaited their feedback. However, it took them six weeks to respond. This delay led me to conclude that they were not interested in the work, which was disheartening. Feeling undervalued, I eventually pulled out of the project. This experience underscores how delayed feedback and poor communication can significantly dampen a developer’s enthusiasm and commitment to a project.


The relationship between developers and non-developers doesn’t have to be fraught with misunderstandings. By showing appreciation for developers’ work and providing timely, detailed feedback, non-developers can foster a more productive and positive working environment. Such practices not only enhance project outcomes but also build a foundation of respect and collaboration, crucial for any successful team.

As technology continues to evolve, the ability to work effectively across different roles will become increasingly important. By adopting these simple yet impactful practices, we can ensure that our teams are not just functional, but also thriving.

When to Use Components vs. Writing Code

In the ever-evolving world of software development, the choice between using pre-built components and crafting your code from scratch is a common dilemma. Thanks to the Node Package Manager (NPM), we have a treasure trove of libraries and components at our disposal. However, the question remains: when should you employ a component, and when should you roll up your sleeves and write your own code? Let’s explore this decision-making process to help you find the right balance for your projects.

The DIY Approach: Writing Your Own Code

Writing code from scratch can be a rewarding endeavor. It gives you complete control over your application’s logic and behavior. Here are some scenarios where opting for a custom solution might be your best bet:

1. Simplicity and Control

If you understand the full scope of the code required and it’s relatively simple to implement, it often makes sense to write it yourself. This approach can minimize the final amount of code used in your application. By crafting your code, you have complete control and can tailor it to your specific needs without the baggage of unnecessary features.

2. Customization

When your project demands a high level of customization that may not be readily available in existing libraries, writing your code becomes a compelling choice. Tailoring your solution ensures that it fits seamlessly into your application’s architecture.

3. Learning and Skill Development

Writing code from scratch offers a valuable learning experience. It allows you to delve deep into the mechanics of programming and helps improve your problem-solving skills. If you’re aiming to enhance your development skills, writing your code can be an excellent exercise.

Leveraging Libraries: When to Use Components

When considering whether to use pre-built components and libraries, it’s essential to recognize that many of these tools are developed and maintained by specialists in the field. These experts have honed their skills in tackling complex tasks and have poured their knowledge into creating these libraries. Here’s why you should consider relying on these expertly crafted resources:

1. Expertise and Specialization

Libraries and components are often developed by experienced developers who specialize in specific domains. For example, when it comes to data fetching and management in a React application, the React-Query library is an excellent choice. The developers behind React-Query have spent countless hours fine-tuning it to handle complex scenarios, such as caching, pagination, and background data synchronization. By using React-Query, you benefit from the expertise of these specialists and can tap into their solutions for common challenges.

2. Maintenance and Updates

One of the significant advantages of relying on established libraries is the ongoing maintenance and updates provided by the open-source community. Libraries like React-Query receive regular updates, bug fixes, and security patches. This means that your application can stay current with the latest best practices and security standards without requiring constant manual intervention.

3. Community Support

Popular libraries often have vibrant communities of developers who contribute to forums, provide documentation, and share their experiences. This wealth of community support can be invaluable when you encounter issues or need guidance. You’re not alone in troubleshooting problems or implementing complex features – the collective knowledge of the community is there to assist you.

4. Time Efficiency

Leveraging libraries can significantly accelerate your development process. Instead of investing considerable time and effort in building complex functionalities from scratch, you can integrate a well-established library into your project. This time efficiency can be a game-changer, especially when working on tight deadlines or large-scale applications.

5. Reducing Error Risk

Writing complex code from scratch increases the risk of errors and bugs. Specialized libraries, on the other hand, are thoroughly tested by both their creators and the community. This extensive testing helps identify and rectify issues, making it less likely for your application to encounter unexpected problems.


In the world of software development, the choice between using components and writing your code depends on the specific requirements of your project. The key is finding the right balance. If you can fully grasp the scope of your code and it aligns with your project’s simplicity and customization needs, writing your code can be a rewarding and efficient choice. However, when tackling more complex tasks or leveraging standardized functionality, leaning on libraries and components can save you time, reduce potential errors, and provide tested solutions.

In summary, when considering whether to use components and libraries, it’s important to recognize that these tools are not just pieces of code; they represent the collective knowledge and expertise of developers who specialize in solving complex problems. By embracing libraries like React-Query, you can harness the power of specialization, benefit from ongoing maintenance, tap into community support, save time, reduce error risk, and ultimately deliver more robust and efficient software solutions to your users. It’s a strategic choice that can elevate the quality and efficiency of your development projects.

Ultimately, your decision should consider factors like project complexity, time constraints, and your familiarity with the task at hand. The beauty of modern development is the wealth of options available. So, whether you’re writing your code or embracing pre-built components, remember that the goal is to create robust and efficient applications that meet your users’ needs.