is there better way

        when (info) {
            null -> {
                return unauthorized()
            }
            else -> {
                val validInfo = validator.validateInfo(info)
                when (validInfo) {
                    is Either.Right -> {
                        if (!validInfo.b.authorised) {

                            // authorised is false so return unauthorised
                            return unauthorized()
                        }
                        // authorised is true, so use the authorised token to create a certificate
                        val authorisedInfo = validInfo.b
                        val productService = productServiceBuilder.buildProductService(authorisedInfo)
                        // TODO add when (productService) here
                        //
                        return when (productService) {
                            is Either.Right -> {
                                val product = productService.b.getProduct(
                                        authorisedInfo.userId!!)

                                APIGatewayProxyResponseEvent()
                                        .withBody(jacksonObjectMapper().writeValueAsString(product))
                                        .withStatusCode(200)
                            }
                            is Either.Left -> {
                                systemError()
                            }
                        }
                    }
                    is Either.Left -> {
                        return systemError()
                    }
                }
            }
        }

Using fluent chains:

info
  .toOption()
  .toEither { unauthorized() }
  .flatMap {
    validator.validateInfo(it)
      .mapLeft { systemError() }
  }.flatMap { authorisedInfo ->
    if (!authorisedInfo.authorised) {
      unauthorized().left()
    } else {
      productServiceBuilder.buildProductService(it).flatMap {
        Either.monadError<Throwable>().catch { 
           val product = it.getProduct(authorisedInfo.userId!!)
           APIGatewayProxyResponseEvent()
             .withBody(jacksonObjectMapper().writeValueAsString(product))
             .withStatusCode(200)
        } 
      }.mapLeft {
        systemError()
      }
    } // else
} // flatMap

Using comprehensions:

Either.monadError<Throwable>().bindingCatch {
  val goodInfo = info.toOption().toEither { unauthorized() }.bind()
  val validInfo = validator.validateInfo(goodInfo).mapLeft { systemError() }.bind()
  val result = if (!validInfo.authorised) {
    unauthorized().left()
  } else {
    catch {
      val productService = productServiceBuilder.buildProductService(validInfo).bind()
      val product = productService.getProduct(validInfo.userId!!).bind()
      APIGatewayProxyResponseEvent()
        .withBody(jacksonObjectMapper().writeValueAsString(product))
        .withStatusCode(200)
    }.mapLeft {
      systemError()
    }
  }
  result.bind()
}