You have 1 article left to read this month before you need to register a free LeadDev.com account.
Estimated reading time: 6 minutes
Key takeaways:
- Look past the component. A component can work perfectly while the system around it fails, so map what each change depends on and what it could break.
- Let the problem pick the framework: trouble starts when a favorite framework drives your architecture, so ask why you’re building something before asking how.
- AI-generated code still lands in your wider system, so check whether it fits, duplicates something, or adds risk.
When I began my career as a software engineer the technology was very different from today’s. My first experience was with CBASIC and enterprise point-of-sale applications, followed by Java, J2EE, Spring, Spring Boot, Angular, microservices, containers, cloud native architecture, Python, and now AI.
With each shift in technology, there were always some new skills to learn: a language, framework, architecture, or a software development approach. In the early stages of my career, I thought that being a good engineer meant mastering technology in front of me.
Regardless of technology changes, the hard questions for an engineer remain very much the same:
- What problem are we trying to solve?
- How does this piece integrate with the rest of the system?
- What if it breaks?
- Is the next engineer going to be able to work with this system?
This is how I learned one of the most important lessons in my career: frameworks are important, but systems thinking goes further.
Your inbox, upgraded.
Receive weekly engineering insights to level up your leadership approach.
Look beyond the code in front of you
Engineers always pay attention to the component of the application they are implementing. Whether it’s an Angular component, a Spring Boot service, or application programming interface (API), your task is to make sure this component works properly.
However, the component may work flawlessly, while the whole system doesn’t function. One user action can go through the user interface, API, several services, databases, infrastructure, and even third-party applications before it reaches its destination. The decision that looks obvious for a particular component can bring performance issues, security concerns, maintenance challenges, or even reliability issues somewhere else in the system.
The more responsibility I gained for larger parts of software systems, the more questions arose not related to my current implementation. What is the origin of this data and where does it go? What assumptions do we have regarding the other service? What will happen if the service is no longer available? How are we going to investigate a production problem? Do we implement a requirement for today only or can our solution grow further?
Thinking of the system starts when we stop considering components separately and look at the context and connections between them.
Reuse changed how I approached engineering
One experience that helped me adopt such an approach was creating reusable user interface capabilities for enterprise applications. The fact that multiple applications solve the same problem does not make duplication of effort an issue at first sight. One group develops the functionality required, and another implements it with minor changes. It is only a matter of time before multiple applications have their own implementation of the same functionality.
The cost is realized later. Duplicate defects require fixing multiple times. The user experience starts to differ. Testability gets harder, and enhancements in one application do not apply to other applications.
Creating reusable libraries in Angular for the commonly implemented functionality posed a new engineering challenge. Rather than focusing on implementing a certain functionality in one app, we had to think about what to put in the library, what to make configurable, and how to allow adoption for other teams without going through all the implementation details. Our solution enabled more than a dozen internal apps and provided a unified basis for several engineering teams.
The hard part was not about writing reusable code. It was all about creating boundaries, providing extension points, managing versioning, and ownership. I have learned that reuse cannot be an end and some things should not go into a library. An abstraction can be justified if its value over time outweighs its maintenance cost.
More like this
Understand the business system as well as the software
However, systems thinking is not confined to architectural systems alone. I have worked in two entirely different domains: retail and healthcare. Although the technology and workflows have varied, there is one constant that always holds true: understanding the business workflow is just as important as understanding the code.
An elegant technical solution may very well be the wrong solution if it fails to consider the way in which the user will interact with the system. Engineers are better positioned to make such decisions when they understand the rationale behind the requirement, its dependencies, and the consequences of workflow failure. They can argue against complexity, identify risks, and participate in a constructive discussion with the product owner, architect, tester, and domain expert
This is even more relevant in senior and staff+ level positions where impact can no longer be calculated based on your personal code
Let the problem guide the framework
This focus on the system, however, doesn’t mean that framework proficiency is no longer critical. In-depth knowledge of the underlying technology will help you see the benefits and drawbacks of the framework, its performance characteristics, and use cases. The problems begin when a favored framework begins to drive your architecture rather than the problem driving your technology choice
Frameworks for me are just another tool in the engineer’s toolbox. Learning a new one becomes much easier if you have already learned about the separation of concerns, the API, the data flows, the concurrency, the failure handling, the security considerations, testing, and maintenance
It is important to ask two simple questions when using any framework:
- How does this framework do this?
- Why are we doing this in the first place?
Often, the latter proves to be even more insightful than the former
AI increases the need for engineering judgment
AI-assisted development makes engineering judgment even more important. With the aid of AI, developers can produce code, make sense of an unknown API, generate test cases, and even help explore possible solutions. When used responsibly, this technology helps shorten the distance from ideas to implementation.
However, faster implementation still requires sound engineering decisions. Generated code is always incorporated into the larger system, and somebody must decide whether it fits the place, what assumptions the generated code makes, what security and performance issues it creates, whether it repeats some capability that already exists, and what maintenance problems it may cause.
As code generation becomes simpler, questioning its implications becomes increasingly crucial. Instead of asking “can we implement it?” we should ask “should we implement it this way?” Senior engineers and technical leaders can assist in applying AI effectively without letting implementation speed override architectural considerations.
Practice systems thinking before the next promotion
Systems thinking doesn’t just magically spring up upon the engineer getting a promotion. It takes time and practice.
Here is how I’ve been building it myself throughout the years:
- Before making any changes to any component, figure out what it depends on and what else might get impacted by it.
- While troubleshooting a bug, analyze the entire process flow rather than stopping at the point of failure.
- In design reviews, think about all potential failure paths with the same level of attention that we give to success paths.
- Understand enough about the business domain to explain the rationale behind the software.
- Be in touch with architects, testers, product owners, operations engineers, domain experts, and adjacent teams who see pieces of the system that you don’t.
- Every time you learn something new about a particular technology, find out what problem it tries to solve, what compromises it makes, and how it integrates with the rest of the system.
All these practices slowly but surely shift your perspective on engineering problems.

New York • September 8 & 9, 2027
Loved LDX3 New York? Pre-sale tickets for 2027 are now available.
Systems thinking is the skill that survives the next technology shift
I do not know what framework engineers will talk about ten years from now. Some technologies we depend on today will change or disappear. I worry less about that now than I once did.
Technology will continue evolving, and engineers need to keep learning. However, understanding complex systems, balancing the pros and cons, integrating the technology with business objectives, and working with teams will always be useful.
Our framework knowledge allows us to develop our current software. Our systems thinking allows us to develop software for the future.