I have been programming for a couple of years and have often found myself at a dilemma. 

There are two solutions - 


one is simple one i.e. simple approach, easier to understand and maintain. It involves some redundancy, some extra work (extra IO, extra processing)   and therefore is not the most optimal solution. 
but other uses a complex approach,difficult to implement, often involving interaction between lot of modules and is a performance efficient solution.


Which solution should I strive for when I do not have hard performance SLA to meet and even the simple solution can meet the performance SLA? I have felt  disdain among my fellow developers for simple solution. 

Is it good practice to come up with most optimal complex solution if your performance SLA can be met by a simple solution?


  Which solution should I strive for when I do not have hard performance SLA to meet and even the simple solution can meet the performance SLA? 


The simple one. It meets spec, it's easier to understand, it's easier to maintain, and it's probably a whole lot less buggy.

What you are doing in advocating the performance efficient solution is introducing speculative generality and premature optimization into your code. Don't do it! Performance goes against the grain of just about every other software engineering 'ility' there is (reliability, maintainability, readability, testability, understandability, ...). Chase performance when testing indicates that there truly is a need to chase after performance.

Do not chase performance when performance doesn't matter. Even if it does matter, you should only chase performance in those areas where the testing indicates that a performance bottleneck exists. Do not let performance problems be an excuse to replace simple_but_slow_method_to_do_X() with a faster version if that simple version doesn't show up as a bottleneck.

Enhanced performance is almost inevitably encumbered with a host of code smell problems. You've mentioned several in the question: A complex approach, difficult to implement, higher coupling. Are those really worth dragging in?
