Do not overcomplicate simple tasks. Most of the time you will need only:

• algebraic datatypes
• structural recursion
• monad-like api (map, flatMap, fold)

There is plenty of complicated stuff in Scala, such as:

• Cake pattern or Reader Monad for Dependency Injection.
• Passing arbitrary values as implicit arguments.

These things are not clear for newcomers: avoid using them before you understand them. Using advanced concepts without a real need obfuscates the code, making it less maintainable.

• Find meaningful names for computation units.
• Use for comprehensions or map to combine computations together.

Let's say you have something like this:

if (userAuthorized.nonEmtpy) {
  makeRequest().map {
    case Success(respone) =>
      someProcessing(..)
      if (resendToUser) {
        sendToUser(...)
      }
    ...
  }
}

If all your functions return Either or another Validation-like type, you can write:

for {
  user     <- authorizeUser
  response <- requestToThirdParty(user)
  _        <- someProcessing(...)
} {
  sendToUser
}

By default:

• Use val, not var, wherever possible. This allows you to take seamless advantage of a number of functional utilities, including work distribution.
• Use recursion and comprehensionss, not loops.
• Use immutable collections. This is a corrolary to using val whenever possible.
• Focus on data transformations, CQRS-style logic, and not CRUD.

There are good reasons to choose non-functional style:

• var can be used for local state (for example, inside an actor).
• mutable gives better performance in certain situations.