Your engineering applications are becoming too complex to manage. How can you simplify them?

Agreed. Complexity means heterogeneity- lots of foreign bodies within the core function. If we can put black on white what should be done ( aka scope) we can remove unnecessary filling and focus on what has to be done. This is easier said than done, but with practice, things become easier

Modular Design: Break down the application into smaller, manageable modules or components. This not only makes the system easier to understand and maintain but also allows teams to work on different modules simultaneously. Code Refactoring: Regularly review and refactor the code to make it simpler and more efficient. Remove redundant or unnecessary code, and consolidate similar functions. Clean code with good documentation is much easier to manage. Adopt Design Patterns: Utilize established design patterns that provide solutions to common problems. This can improve code readability and maintainability, and also make the system more predictable.

Maintaining a lean and focused approach is imperative for organizational success. Invest in tooling that generates insights from user interactions with your platform. Regularly validate hypotheses regarding the utilization of features and the resultant commercial value they generate. Identify areas where considerable effort is invested in maintaining functionality that yield minimal or negative return on investment (ROI). Initiate customer engagement to understand their specific use cases, and proactively explore alternative solutions to ensure the team remains dedicated to delivering higher value to customers efficiently.

Start by clearly defining the main purpose and core functions of each application. Eliminate any features or components that are not essential or relevant to these core functions. Use tools like value stream mapping, user stories, or use cases to identify and focus on the key activities and outcomes.

To simplify complex engineering applications, focus on modularization, breaking down tasks into smaller, manageable components. Embrace automation for repetitive tasks, reducing manual effort. Streamline workflows by adopting standardized processes and clear documentation. Prioritize user-friendly interfaces and intuitive design to enhance usability. Regularly review and optimize systems for efficiency, eliminating unnecessary complexities. Emphasize training and support to ensure teams can effectively navigate and maintain the streamlined environment.

Modular design of the products or even services is tough to conceive and execute but definitely brings agility in the standardization and ease in the supply chain leading to quality delivery. Two different products can have the same components if the design is modular. It helps in ease of spares availability and reduced maintenance manpower but still giving better reliability and uptime of the systems. Automation of services heavily relies on modular answers and standard operating procedures. Chatbots and robocalls are an example of this concept and are gaining popularity. Human intervention will always be required and should be guiding the modular design aspects.

This also sounds easy. Modules creates lots of interfacing points which should be addressed in due time and using “non-standard” approaches usually automated or monitored under a solid quality control management.

Break down the applications into smaller, independent modules with well-defined interfaces. This allows for easier maintenance, updates, and scalability of individual modules without affecting the whole system.

Modular designs would also mean lesser things to focus on, instead of trying to think about the larger deliverable. Try to think of it as looking at the top of the mountain, at first, it seems scary, but with consistency, you would eventually get there. It's, however, important that your modules have timelines associated with them, as it helps in stakeholder management. It also helps you to keep track of the progress. Lastly you would need someone with experience to be able to stitch out the bigger picture from these smaller components, so that the modules could be prioritized accordingly.

As stated above this will work only within the natural habitat- the module itself. It is will function with extreme difficulty as the interfacing points and needs to be adapted

In my experience, the third crucial step in simplifying engineering applications involves leveraging standard tools and frameworks. By incorporating tools such as version control, code analysis, testing, continuous integration, continuous delivery, configuration management, and monitoring, you can automate, streamline, and standardize your development, deployment, and maintenance processes. This not only ensures code quality but also addresses performance, security, and reliability aspects. Additionally, adopting frameworks like agile, scrum, or kanban proves instrumental in effectively managing project scope, schedule, and resources. This comprehensive approach has proven to enhance overall efficiency and consistency in engineering project

Leverage existing, well-documented tools and frameworks wherever possible. This reduces the need for custom development and simplifies maintenance. Choose tools with a large community and support network for easy access to solutions and updates.

I'd advise to be cautious on adding more "tools" whether standardised or not. They will be chosen on bias of people in your team, which is natural as they will be impacted by them, however you don't want to add more tools all at once but build them up incrementally. Chosing the tools and frameworks depends highly on your organization: If you are a startup, trying to distrupt the field, you may want to deviate from standard tools as they won't serve your needs. As the organization size changes, use the experience and knowledge of your principle/senior engineers to chose more fitting tools. Process frameworks won't resolve your complexity problems but they will help you highlight bottlenecks. The way to resolve them will be up to you still.

Automated testing is essential for ensuring code quality while reducing manual testing efforts. Implementing Continuous Integration/Continuous Deployment (CI/CD) pipelines streamlines development, allowing for quick iterations and prompt feedback. Regular performance monitoring is also crucial, helping to quickly identify and address any efficiency issues. Additionally, peer programming encourages collaboration and enhances code quality, as developers can learn from each other and identify errors early. Finally, using tools for consistent code linting and formatting maintains a uniform style across the team, making the codebase more organized and understandable. These combined efforts lead to a more efficient and maintainable application.

Follow established coding practices and design patterns to maintain consistency and readability. Utilize code commenting and documentation to clearly explain the functionality and logic of your code. Implement automated testing to ensure the stability and robustness of your applications.

The importance of creating guidelines that follows the general best practices comes into play when onboarding new people to your teams. A complex solution will be easier to understand if there are guidelines that are shared across the organization and are similar to industry standards.

In my experience, I've found several techniques particularly useful for gathering feedback and insights. First, working with customer support teams. They have firsthand insights into user issues and suggestions, providing a direct line to user feedback. Second, error tracking and analytics tools. They offer real-time insights into application usage and help identify where users encounter problems. Third, conducting negative A/B experiments. By comparing different versions of a feature or the application itself, or by simply dropping a feature and measuring its impact, you can gain a clear understanding of user preferences, guiding more informed development decisions.

Regularly gather feedback from users and stakeholders about the complexity and usability of your applications. Use this feedback to identify areas for improvement and prioritize simplification efforts. Implement continuous improvement processes to constantly refine your applications.

If you are working already in separated functionalities with dedicated teams focused on specific parts of your product, ideally based on Inverse Conway's Law, you could benefit from asking feedback and suggestions for improvements from other development teams that are tightly connected to your application. The benefit of this could be higher if those teams consume your application's output.

The famous adage goes: wise people learn from mistakes and it is furthermore important if we learn from others. We have to assess the level of our systems and find out the best practices of the peers in the market. Benchmarking is an activity which addresses this dimension In professional advancements. We have to keep our eyes and mind open to see the better among others and adopt them to improve our own applications. Participation in industrial exhibitions, seminars, etc. also bring fresh perspectives in our work.

Invest in professional help: If the complexity is a significant hurdle, consider seeking assistance from consultants or engineering teams specializing in simplifying applications. Utilize cloud-based solutions: Explore cloud-based platforms that offer built-in scalability and management tools, simplifying the infrastructure complexity. Automate tasks: Identify repetitive tasks within your applications and automate them using scripting or dedicated tools.

Expect a long-term effort on this work to simplify your applications, whether involves complete refactoring monolithic to a microservices architecture or introducing bits of standardization. They will all take time. You might also want to hire people that has experienced such changes that they could help you better prepare for such work.

Yes, for example by splitting traditional monolithic applications into microservices and applying various modern techniques such as reactive programming, decoupled architecture, asynchronous messaging, etc.