Go vs Kotlin: Qual Melhor para Backend?

Go e Kotlin são duas linguagens modernas que competem pelo espaço de backend, cada uma vinda de um universo diferente. Go nasceu no Google como linguagem de sistemas compilada para nativo. Kotlin nasceu na JetBrains como uma linguagem moderna para a JVM, hoje oficial para Android. Neste comparativo, avaliamos qual faz mais sentido para backend em 2026, considerando performance, produtividade, concorrência e mercado de trabalho brasileiro.

Resumo Rápido

Performance: Benchmarks Reais

Go tem vantagem clara em eficiência de recursos, enquanto Kotlin na JVM pode alcançar throughput competitivo após warmup:

Benchmark                  | Go 1.26      | Kotlin (Ktor) | Diferença
Startup do serviço         | 5ms          | 1.200ms       | Go 240x mais rápido
RAM em idle                | 12 MB        | 120 MB        | Go 10x menos memória
API REST JSON (req/s)      | 85.000       | 65.000        | Go ~30% mais rápido
Latência p99               | 2ms          | 6ms           | Go 3x menor latência
Build do projeto           | 3s           | 20s           | Go 6x mais rápido
Imagem Docker              | 15 MB        | 200 MB        | Go 13x menor
Goroutines/Coroutines (1M) | 2 GB RAM     | 4 GB RAM      | Go 2x menos memória

Go vence em eficiência: menos memória, startup instantâneo, binário pequeno e compilação rápida. Isso se traduz em custos de infraestrutura menores, especialmente em ambientes com dezenas ou centenas de microserviços.

Kotlin vence em expressividade: recursos como extension functions, sealed classes, operator overloading e DSLs permitem código mais conciso e expressivo. O overhead da JVM é o preço por essa riqueza.

Kotlin/Native tenta compilar Kotlin para nativo sem JVM, mas o ecossistema ainda é imaturo e a performance não compete com Go nativo em 2026.

Comparação de Sintaxe

API REST

Go:

package main

import (
    "encoding/json"
    "net/http"
)

type Tarefa struct {
    ID        int    `json:"id"`
    Titulo    string `json:"titulo"`
    Concluida bool   `json:"concluida"`
}

func main() {
    http.HandleFunc("/tarefas", func(w http.ResponseWriter, r *http.Request) {
        tarefas := []Tarefa{
            {1, "Aprender Go", true},
            {2, "Aprender Kotlin", false},
        }
        json.NewEncoder(w).Encode(tarefas)
    })
    http.ListenAndServe(":8080", nil)
}

Kotlin (Ktor):

data class Tarefa(val id: Int, val titulo: String, val concluida: Boolean)

fun main() {
    embeddedServer(Netty, port = 8080) {
        install(ContentNegotiation) { json() }
        routing {
            get("/tarefas") {
                val tarefas = listOf(
                    Tarefa(1, "Aprender Go", true),
                    Tarefa(2, "Aprender Kotlin", false)
                )
                call.respond(tarefas)
            }
        }
    }.start(wait = true)
}

Kotlin é mais conciso graças a data class, type inference e funções de extensão. Go é mais explícito — cada detalhe está visível no código. Em equipes grandes, a simplicidade de Go reduz ambiguidade; em projetos menores, a expressividade de Kotlin acelera o desenvolvimento.

Concorrência: Goroutines vs Coroutines

Go — goroutines com channels:

func buscarDados(ctx context.Context) ([]Resultado, error) {
    ch := make(chan Resultado, 3)

    go func() { ch <- buscarDB(ctx) }()
    go func() { ch <- buscarCache(ctx) }()
    go func() { ch <- buscarAPI(ctx) }()

    var resultados []Resultado
    for i := 0; i < 3; i++ {
        resultados = append(resultados, <-ch)
    }
    return resultados, nil
}

Kotlin — coroutines com structured concurrency:

suspend fun buscarDados(): List<Resultado> = coroutineScope {
    val db = async { buscarDB() }
    val cache = async { buscarCache() }
    val api = async { buscarAPI() }

    listOf(db.await(), cache.await(), api.await())
}

Kotlin coroutines oferecem structured concurrency nativa com coroutineScope, tornando o escopo e cancelamento mais explícitos. Go usa channels e errgroup para resultados semelhantes. Ambas as abordagens são eficazes, mas goroutines são mais leves em recursos de sistema.

Mercado de Trabalho no Brasil

O cenário brasileiro para Go e Kotlin reflete seus diferentes origens:

• Kotlin tem ~3.000 vagas/mês, mas a maioria é para Android. Vagas de backend Kotlin puro são cerca de ~800/mês, concentradas em empresas que já usam Spring Boot e querem modernizar sem abandonar a JVM.
• Go mantém ~2.000 vagas/mês, focadas exclusivamente em backend, DevOps e infraestrutura.
• Salário Go pleno backend: R$ 14.000–20.000/mês. Kotlin pleno backend: R$ 12.000–18.000/mês. Go paga em média 15-20% a mais para posições de backend.
• Kotlin para Android: desenvolvedores Android Kotlin pleno ganham entre R$ 11.000–17.000/mês.
• Empresas Go no Brasil: Nubank, iFood, Mercado Livre, PicPay, Stone, Wildlife Studios.
• Empresas Kotlin no Brasil: Nubank (Android), iFood (Android + backend), Itaú, BTG Pactual, Inter, Magazine Luiza.
• Tendência: Kotlin cresce em backend na JVM como substituto de Java. Go cresce em infraestrutura e cloud-native. São mercados complementares.

Confira as vagas Go atualizadas e a pesquisa salarial.

Quando Escolher Go

• Microserviços cloud-native — binário leve, startup instantâneo, deploy simples.
• Ferramentas DevOps e CLI — cross-compilation, binário único, sem dependências.
• APIs de alta performance — menor latência e consumo de memória.
• Equipes grandes que valorizam simplicidade — uma forma de fazer cada coisa.
• Infraestrutura e sistemas distribuídos — Kubernetes, Docker, Terraform, Prometheus.

Quando Escolher Kotlin

• Equipes que já usam JVM/Java — migração gradual, interoperabilidade total.
• Projeto que precisa de mobile e backend — Kotlin Multiplatform (KMP) permite compartilhar código.
• Desenvolvimento Android — linguagem oficial com suporte total do Google.
• Projetos que exigem frameworks enterprise ricos — Spring Boot com Kotlin é uma combinação poderosa.
• Equipes que valorizam expressividade da linguagem — null safety, DSLs, sealed classes.

Conclusão

Go e Kotlin são linguagens modernas e competentes, cada uma otimizada para seu contexto. Go é a escolha ideal para backend puro, microserviços e infraestrutura, oferecendo a melhor relação entre performance, simplicidade e custo operacional. Kotlin é a escolha certa para equipes no ecossistema JVM que querem uma linguagem moderna, especialmente quando há necessidade de compartilhar código entre Android e backend.

No mercado brasileiro, Go oferece salários melhores para backend e uma especialização mais clara. Kotlin oferece versatilidade entre mobile e servidor. Profissionais que dominam uma dessas linguagens e conhecem a outra terão vantagens significativas no mercado de 2026.

Próximos Passos

• Aprenda Go do zero — tutorial completo para iniciantes
• Vagas Go no Brasil — oportunidades atualizadas
• Salários de Go no Brasil — dados salariais detalhados
• Todas as comparações — Go vs outras linguagens
• Conheça também: Kotlin.dev.br — conteúdo Kotlin em português