How to Speak With Superiors in a Way That Speeds Up Your Promotion and Income

Once, I was on a project that was built using a UI framework. This UI framework was going to be discontinued soon. But our project already had 1000s of lines of code using this framework.

The framework was still fully operational and fully supported, and additional security and bugfix support was planned for the next few years. In theory, we had plenty of time to work on something new.

However, we needed to act now, as this kind of change sometimes takes months and even years.

We prepared a list of technical reasons why we need to change now:

• The obvious ones were the security and the safety of the framework,

• Another technical issue was the ability to use Typescript instead of pure Javascript

• Some wanted to include the ‘Modern development paradigm’ as a reason for a switch

• Performance reasons were another point

The above technical reasons are sometimes problematic on their own. However, we also need to list business reasons, which provides the management with clear business implications.

Here is our list:

• Security Assurance: Staying with an unsupported technology can expose the product to security vulnerabilities, which could have severe implications for business.

• Community support: Community support will suffer as the language is used less and less.

• The challenge of finding good developers: unsupported frameworks are no longer used by developers, and they are not willing to learn frameworks that are not used

However, this is still not enough. The transition to a new framework, or any big change like this, is inherently risky.

We need to:

• Provide a clear, realistic plan

• Identify and address the risks

So, part of our proposal was a plan that covered the above:

• The new framework was going to be applied incrementally. E.g. we introduced a way for both frameworks to run in parallel

• New features were developed in the new framework

• The old features were migrated to a new framework according to a defined plan

• The UI testing code needs to be adjusted so it works for both frameworks

• Yes, we will require some time to convert an old UI, but it can be done in parallel. This requires additional time and resources but is needed to address the problems with the old framework.

• The developers will need some time to adjust to the new framework. We can use the other company teams already using this framework.

• The company is already using the new framework on other projects. They can share learnings.

• Attracting Talent: The modern tech stack attracts prospective developers and can make hiring easier.

I do not want to discuss the technical details too much because this is really not the point. You can universally apply these principles to any technology change.

So here are the key learnings.

Before doing anything, plan strategically.

Steps:

• Identify a technical issue that needs to be addressed.

• Make sure that the issue has a clear business and/or user impact

• Document the solution, its pros and cons

• Use the table below to map the technical issue to the business language so you can communicate it effectively.

• Plan the process of applying the solution.

Planning the change can show you major holes in your approach. The plan should address

• How the feature will involve over time

• Who will be affected

• What other systems will be affected

Be prepared for the setbacks. But do not be discouraged. This exercise will help you in the future.

Here are a few mistakes developers make:

• Not preparing - A good plan goes a long way. Prepare a plan and discuss it with different groups. Find other successful transitions or changes in the company and learn how they progressed.

• Trying to do too much - any change is disruptive. Start with small changes first.

• Thinking locally. Thinking your change is easy and can be done in a day is probably unjustified. The easy changes are done already. If the change feels too easy, you are missing some connections to other systems or other parts of the organization.

Prepare a list of issues like this; do not have just one. Address the most impactful issue first.

The list maps technical features to benefit end-users and business stakeholders. This can help you transform your tech language into a business language.

Apply it to any technical communication. Make it count.

Here is the list:

• User authorization, authentication, roles -> Protects privacy and prevents unauthorized access

• Continuous compliance (SOC 2, ISO 27001, GDPR, HIPAA) -> Ensures security and protects sensitive user data

• Internationalization and localization -> Provides better experience for global or diverse users

• Documentation -> Enables self-service and reduces customer support costs

• Migrations from older systems -> Allows retaining data when improving technology

• 3rd party API access and maintenance -> Allows expanding capabilities through integrations

• Internal Admin interface -> Enables managing and optimizing the software

• Billing and subscription management -> Facilitates monetization with flexible pricing plans

• Monitoring and alerts -> Improves uptime and preserves customer experience

• Reporting and analytics -> Provides insights to guide business decisions

• Scalability and performance optimizations -> Supports business growth and avoids disruptions

• Backup and disaster recovery -> Minimizes downtime and data loss risks for users

• Customization and personalization -> Increases customer engagement and satisfaction

• Integration with other systems -> Expands features and value for users

• Feedback and support tools -> Identifies issues early and improves user experience

• Audit trails -> Increases transparency and accountability, supports compliance

• Data export and portability -> Enables ownership and protects customer interests

• Downtime notifications -> Allows users to plan around outages

• Mobile accessibility and responsive design -> Extends access and usage scenarios

• Feature flags and toggles -> Allows releasing and testing new features incrementally to minimize risk

• Search and filtering -> Helps users quickly find what they need in large data sets

• Caching and content delivery networks (CDNs) -> Speeds up response times and improves performance

• Async processing and background jobs -> Enables processing high volumes without slowing user interactions

• Version control and code merging -> Streamlines team collaboration during software development

• Feature usage analytics -> Identifies popular and neglected features to optimize UX

• Automated testing -> Catches bugs and regressions to improve quality

• Progressive web app features -> Provides app-like experience on mobile web for engagement

• User feedback collection -> Identifies pain points and improvement opportunities

• Dark mode and accessibility options -> Caters to diverse accessibility needs and preferences

• Multi-tenancy and isolation -> Allows securely serving multiple customers from the same platform

• Automated database sharding -> Scales databases by partitioning data across nodes

• Network effects -> Increases value for all users as the user base grows

• Open API and extensibility -> Encourages innovation and integration by 3rd party developers

• Configurability and custom workflows -> Adapts the software to diverse customer needs

P.S. Here is another article you might enjoy - https://beyond-coding.beehiiv.com/p/type-coding-counts-increased-pay