Top 6 time wastes as a Software Engineer
Tags: productivity, testing, timemanagement, softwareengineer
Published: 2021-08-23 22:02:46


Effective time management is a skill that most successful software engineers have. It will help you advance quickly in your career without having to work long hours at the end of a sprint. 

Every organization is trying to reduce waste and enhance productivity with [automation pipelines](https://kaholo.io/), enhanced IDEs, and DevOps. Be ahead of the curve and make your day more productive by avoiding these top 6 time wastes.


## Top 6 Time Wastes as a Software Engineer


### 1) Adding too many features

How many times have you over-complicated a story requirement by thinking about all the ‘what-ifs’? What if the API you’re working on could be designed to integrate into other platforms seamlessly? What if your dashboard could send automatic reports?

Resist the urge. Don’t over-engineer it. You shouldn’t spend a lot of time on features that are too ahead in the future. And, more code means more bugs and unnecessary scripts add to application bloat. Understanding your code and adding new features will also be more complex.

To avoid this, constantly ask yourself if your code is solving the specific story requirements. Make sure you think through the use cases and the edge cases, but don’t spend weeks on a feature that you could have shipped much faster.

If you’re confused about adding a feature that could potentially address an extreme use case, bring it up in the next sprint meeting. You’ll save a lot of time AND you’ll establish yourself as a team player. 


### 2) Writing the same scripts again and again

As a software engineer, you should follow the DRY (Don’t Repeat Yourself) principle to be more productive. This can be done in two ways: eliminating redundancies in your code or streamlining development processes. 

Let’s see how to tackle both these scenarios.



1. Redundancies in code

Setting up a server or even a virtual environment involves writing the same scripts and actions multiple times. You’re to build your 4-tier development architecture with dev, test, stage, and prod environments with nearly the same steps and code. On top of that, managing infrastructure dependencies have become increasingly complex. Not only is it repetitive and boring, but doing it manually also leaves you vulnerable to human errors. 

Low code platforms have this functionality out of the box with reusable abstraction-based components and visual drag and drop interfaces. Of course, you won’t find one-click solutions for every scenario, but you’ll have the most basic, repeatable ones covered. [Automated pipelines](https://kaholo.io/blog/once-you-try-automatic-environment-setup-you-can-never-go-back/) will help you build, replicate and scale the code for as many environments as you need.



2. Redundancies in Processes

Clearly outline the number of steps you undertake in a development process and think of how you can reduce them. Automation is your friend here.

Also, keep an eye out for processes that you end up performing more than two times. You’d benefit from making an automated sequence that can be triggered every time you want to do that task.

Before you go ahead with automation, though, always be mindful of the time tradeoff. Some questions to ask yourself before automating anything would include: Will I save more time if I automate this than if I do the task? Will I be doing this regularly for at least the next couple of weeks?

If the answer is yes, automate it. Reduce time wastes (and headaches).


### 3) Building systems from scratch 

If a developer had to custom-code a JDBC database connection every time they built a web app, it would take ages to complete a single project.

Developing maintainable and secure software should be your priority. However, that doesn’t mean building systems from scratch. You don’t need to reinvent the wheel and rebuild functionality that already exists. 

Companies want efficient work, and the time you spend building a system from scratch is, in most cases, redundant. So instead, build on the pre-built functionality by using frameworks and customize it according to the client’s needs.

Also, check pre-existing company code databases. If the tool has existing features that overlap with the one assigned to you, it would be good to check if a function call can give you the data you need or if it can be integrated.

However, when dealing with confidential data such as finances, or health records, it makes sense to build features from scratch to enhance security. But in most cases, frameworks, reputed open-source libraries, or paid plugins do the job perfectly.


### 4) Poor Testing Strategy

There’s a delicate balance that you’ve to take care of while choosing between automation and manual testing. So let’s understand how you, as a software engineer, can use this to work out an efficient testing strategy.

It’s easy to write a small manual test to ensure that the new feature you added is working fine. But when you scale, running those manual tests needs more hours off the clock, especially when you’re trying to find that pesky bug that keeps breaking your code. 

If your application or website has many components, the chances of you not running a specific test by mistake also increase. Automated tests or even a system to run tests more efficiently helps avoid this.

You would need to spend a bit more time setting up your automated tests. Once they are written, though, they can be reused and triggered as soon as you make any code changes. So you don’t have to manually re-test previous functions just because you added a new one. 

Conversely, choosing the right tasks to automate is just as important. Unfortunately, it is one of [the most common mistakes of QA automation testing](https://kaholo.io/blog/7-common-qa-automation-mistakes-and-how-to-avoid-them/). It’s tempting to fall into the trap of over-automating things and end up replicating tests script-by-script. This is a major time waste because figuring out why your complex automation didn’t work is still a very manual task - the very thing you intended to avoid.

Don’t make it more complex than it has to be. Instead, focus on simple test cases and ignore the infrequent or complex tasks that come with many dependencies. Optimize and plan your test strategy before you start writing any unit test cases, and you’ll be saving a lot of time.


### 5) Incorrect Code Optimization 

This is a fairly common time waste and is usually difficult to spot from the get-go. You spend a lot of time optimizing code for use cases that are not the priority or might not even be needed. 

Your sole focus should be making the feature work and then thinking about optimization. However, don’t set unrealistic benchmarks. Optimization decisions are usually case-based. 

If that performance optimization takes just a couple of minutes, do it. But, in most business scenarios, byte-level optimization is usually not crucial to the project. Is it good to have? Yes. However, if it’s going to take you hours to get that 1% increment in performance, it’s probably better to discuss it first with the stakeholders.

For example, let’s assume you are developing a web page for an internal team. You don’t really need the website to load in 0.5 seconds if it successfully loads in under a second. That is not going to improve business operations significantly. However, if it’s an e-commerce store, getting it to load under a second instead of two seconds will be a functional requirement.

The best way to tackle this time waste is to get regular feedback from your users. You should optimize based on their extreme use cases instead of building your own.  


### 6) Ineffective communication

Ineffective communication is the direct, sometimes indirect, cause of many time-wasters in software development, some of which have been mentioned on this list. 

Software development has many moving parts - individual team members working on different product features, which then becomes the input for the QA team, and finally a product for the end-user. 

Communication is critical, especially in the development and transition phases. Suppose a situation where the developer misunderstands the business requirements of the stories. This communication gap can overcomplicate the solution and lead to technical mistakes and enhance the chances of bugs or reworks.

Since communication is the most human aspect of software development, this time waste cannot be entirely done away with. However, with proper project management tools and a collaborative environment, it can definitely be reduced. Tools like Trello or Microsoft Teams help reduce the friction. 

On an individual level, always think about the bigger picture when in a meeting or developing a feature. Learn to listen and collaborate effectively. Make a habit of writing down or sending a summary of what was discussed in the meeting to clear expectations from both sides.

Also, communicate sooner rather than later. Don’t assume requirements, and when possible, present a small demo before working on the entire project.


## Final Thoughts

The key here is to make a habit of avoiding these time-wasting activities. Short-term productivity ‘tips and tricks’ can only take you so far. But good coding practices and self-awareness will help you become more efficient. Be mindful of where your time is being spent most, try to reduce it, and you’re well on your way to becoming a successful software engineer!