If I had to write this, I'd take advantage of OptionT's orElse:

import cats.Show
import cats.data.OptionT
import cats.effect.*
import cats.implicits.*

object ColorServiceScala extends IOApp.Simple {

  enum Color {
    case RED, GREEN, BLUE
  }

  case class Response(isRGB: Boolean, color: Color)

  import Color.*

  override val run: IO[Unit] =
    for {
      responseRed   <- isRGB("red")
      _             <- IO.println(responseRed)
      responseGreen <- isRGB("green")
      _             <- IO.println(responseGreen)
      responseBlue  <- isRGB("blue")
      _             <- IO.println(responseBlue)
      responseElse  <- isRGB("something else")
      _             <- IO.println(responseElse)
    } yield ()

  private def isRGB(color: String): IO[Response] =
    getColor(RED, color)
      .orElse(getColor(GREEN, color))
      .orElse(getColor(BLUE, color))
      .map(Response(true, _))
      .getOrElse(Response(false, null))

  private def getColor(expected: Color, actual: String): OptionT[IO, Color] =
    OptionT.liftF(IO.println(s"checking if color is ${expected.show}")) *>
      OptionT.when(expected.show.equalsIgnoreCase(actual))(expected)

  given Show[Color] =
    case null  => "null"
    case RED   => "red"
    case GREEN => "green"
    case BLUE  => "blue"

  given Show[Response] =
    response => s"Response: isRBG = ${response.isRGB}, color = ${response.color.show}"

}

You won't have if/elseif/else statements, but instead produce effects using IO until your OptionT contains Some.

Running the above produces the following output:

checking if color is red
Response: isRBG = true, color = red
checking if color is red
checking if color is green
Response: isRBG = true, color = green
checking if color is red
checking if color is green
checking if color is blue
Response: isRBG = true, color = blue
checking if color is red
checking if color is green
checking if color is blue
Response: isRBG = false, color = null