⑂
Referencia · Estrategias

Estrategias de ramas en Git

GitHub flow, trunk-based, Git flow, GitLab flow, ramas de release, pull requests apilados y forks: cómo funciona cada estrategia, para quién sirve y para quién no. Responde cinco preguntas y te recomendamos una.

Lo que más importa

La estrategia depende sobre todo de cada cuánto despliegas y de cuántas versiones mantienes a la vez. Las investigaciones de DORA encontraron que los equipos de mejor desempeño tienen tres ramas activas o menos e integran al tronco al menos una vez al día. Las ramas cortas son la parte que más ayuda, sea cual sea la estrategia que uses.

¿Qué estrategia me sirve?
¿Cada cuánto despliegas o publicas?
¿Cuántas versiones mantienes a la vez?
¿Tus pruebas automáticas son confiables?
¿Quién contribuye al repositorio?
¿Necesitas aprobación entre entornos (staging, producción)?

Comparación rápida

EstrategiaRamas permanentesVida de una ramaIdeal para
GitHub flowmainHoras a pocos díasWeb y SaaS que despliegan seguido
Trunk-basedmainHorasCI sólido, despliegues diarios
Git flowmain y developDías a semanasVersiones numeradas, apps instaladas
GitLab flowmain + una por entornoHoras a díasDespliegues por ventanas o con aprobación
Ramas de releasemain (+ una por versión)Horas a díasSprints, anillos, varias versiones
PRs apilados(se combina con otras)Horas a díasCambios grandes que hay que revisar por partes
ForksLas del proyectoLo que dure el PROpen source y contribuciones externas

GitHub flow

Una sola rama permanente, main, que siempre se puede desplegar. Cada cambio entra por una rama corta y un pull request.

Ramas
main (permanente) y una rama por cambio, que vive horas o pocos días y se borra al fusionarse.
Cómo se libera
Se despliega main: al fusionar cada PR o cuando el equipo decide. Opcionalmente, un tag por versión.
Sirve para
Aplicaciones web y SaaS con entrega continua; equipos de cualquier tamaño que revisan por pull request.
No sirve para
Productos con varias versiones en circulación que hay que mantener a la vez (por ejemplo, la 1.x y la 2.x).
Problemas típicos
Pull requests que crecen demasiado y main roto cuando las pruebas automáticas son débiles. Se resuelve con PRs pequeños, checks obligatorios y una merge queue.
bash
git switch -c cupones
# ...commits...
git push -u origin cupones
gh pr create --fill
gh pr merge --squash --delete-branch

# en GitHub: protege main (PR obligatorio + checks de CI)

Fuentes: GitHub Docs: GitHub flow

Trunk-based development

Todos integran a main (el «tronco») al menos una vez al día. Lo que no está terminado entra igual, apagado con un feature flag.

Ramas
main y, si se usan, ramas de horas de una persona o una pareja (que no superen un par de días, contando la espera de revisión). A veces, ramas de release cortadas del tronco.
Cómo se libera
Desde el tronco, varias veces al día, o desde una rama de release que solo recibe cherry-picks.
Sirve para
Equipos con CI rápido y pruebas automáticas confiables que quieren desplegar seguido.
No sirve para
Equipos sin pruebas automáticas (cada integración sería una apuesta), o proyectos open source con contribuciones de desconocidos.
Problemas típicos
Exige disciplina: commits pequeños y CI siempre verde. Los feature flags se acumulan si nadie los borra.
bash
git switch -c menu            # rama de horas, no de semanas
git pull --rebase origin main # varias veces al día
git push -u origin menu       # PR chico, se fusiona el mismo día

# lo incompleto entra apagado:
# if (flags.menuNuevo) { ... }

Fuentes: trunkbaseddevelopment.com · DORA: Trunk-based development

Git flow

Dos ramas permanentes, main (lo publicado) y develop (lo próximo), más ramas temporales para funcionalidades, versiones y arreglos urgentes.

Ramas
main y develop permanentes; feature/* salen de develop; release/* preparan una versión; hotfix/* salen de main.
Cómo se libera
Una release/* sale de develop, se estabiliza, se fusiona en main con un tag de versión y vuelve a develop.
Sirve para
Software con versiones numeradas que se publican cada cierto tiempo: apps de escritorio o móviles, librerías, productos instalados en el cliente.
No sirve para
Aplicaciones web con entrega continua. Su propio autor lo escribió en 2020: para esos equipos recomienda un flujo mucho más simple, como GitHub flow.
Problemas típicos
Muchas ramas largas, merges dobles (a main y a develop) y conflictos al volver de la release. develop tiende a alejarse de lo publicado.
bash
git switch -c release/1.1 develop
# ...solo arreglos en la release...
git switch main && git merge --no-ff release/1.1
git tag v1.1.0
git switch develop && git merge --no-ff release/1.1

# hotfix:
git switch -c hotfix/1.1.1 main

Fuentes: Vincent Driessen: A successful Git branching model (con la nota de 2020)

GitLab flow (ramas de entorno)

GitHub flow más ramas que representan entornos (por ejemplo staging y production). Los cambios bajan de main a cada entorno, siempre en la misma dirección.

Ramas
main y una rama por entorno. En la variante con versiones, ramas como 2-3-stable.
Cómo se libera
Fusionar main en staging despliega a pruebas; fusionar staging en production despliega a producción.
Sirve para
Equipos que despliegan por ventanas programadas o que necesitan aprobación entre entornos (por ejemplo, en sectores regulados).
No sirve para
Equipos que pueden desplegar main directamente: las ramas de entorno solo agregan pasos.
Problemas típicos
Si alguien commitea directo en una rama de entorno, se aleja de main. Todo arreglo entra primero a main («upstream first») y baja desde ahí.
bash
# despliegue a pruebas
git switch staging && git merge main && git push
# después de aprobar, a producción
git switch production && git merge staging && git push

Fuentes: GitLab Docs (archivo 16.1): Introduction to GitLab Flow

Ramas de release (release flow)

Se trabaja como en trunk-based, y en cada versión se corta una rama release/… desde main. Es el modelo que Microsoft describe para Azure DevOps.

Ramas
main, ramas de tema cortas y una rama por versión. Las ramas de release nunca se fusionan de vuelta a main.
Cómo se libera
Se despliega la rama de release. Los arreglos van primero a main y se llevan a la release con cherry-pick.
Sirve para
Equipos que publican por sprints o en anillos (primero a un grupo, luego a todos), y productos que mantienen varias versiones a la vez.
No sirve para
Equipos pequeños que despliegan main en cada merge: la rama de release no aporta nada.
Problemas típicos
Si hay dos releases vivas, el arreglo se lleva a las dos. Y si alguien arregla solo en la release, el bug vuelve en la siguiente.
bash
git switch -c release/2026.11 main   # al cerrar el sprint
# arreglo urgente: primero en main, después
git switch release/2026.11
git cherry-pick -x <commit-del-arreglo>

Fuentes: Microsoft Learn: How Microsoft develops with DevOps

Pull requests apilados (stacked PRs)

Un cambio grande se divide en una serie de PRs pequeños, cada uno encima del anterior. Se revisan por separado y se fusionan en orden.

Ramas
Una rama por parte, cada una basada en la anterior; la primera, en main.
Cómo se libera
No cambia cómo se libera: es una forma de llevar trabajo a main que se combina con GitHub flow o trunk-based.
Sirve para
Equipos que revisan todo por PR y tienen cambios que no caben en uno solo; trabajo que depende de un PR que todavía está en revisión.
No sirve para
Cambios pequeños, que caben en un PR. Y pilas entre forks: las de GitHub exigen que todas las ramas estén en el mismo repositorio.
Problemas típicos
Cuando cambia una parte de abajo, hay que rebasar todas las de arriba. git rebase --update-refs (desde Git 2.38) o las herramientas de pilas lo hacen de una vez.
bash
# con Git solo:
git switch -c parte-2 parte-1
git rebase --update-refs main       # mueve toda la pila
git config --global rebase.updateRefs true

# con la extensión de GitHub CLI (GA desde oct. 2026):
gh stack init parte-1
gh stack add parte-2
gh stack submit

Fuentes: GitHub Docs: Creating stacked pull requests · GitHub Changelog: Stacked pull requests GA (6 oct. 2026) · Highlights from Git 2.38 (--update-refs)

Forks y pull requests (open source)

Quien contribuye no tiene permiso de escritura: trabaja en su copia (fork) y propone cambios con un pull request al repositorio original.

Ramas
En el original, las que defina el proyecto (casi siempre GitHub flow). En tu fork, una rama por pull request.
Cómo se libera
Lo deciden quienes mantienen el proyecto: fusionan los PRs y publican versiones.
Sirve para
Proyectos open source y cualquier repositorio que recibe contribuciones de personas externas.
No sirve para
Un equipo con acceso al mismo repositorio: las ramas compartidas son más simples que los forks.
Problemas típicos
Forks desactualizados, CI con acceso limitado a secretos en PRs que vienen de forks, y PRs apilados que no funcionan entre forks.
bash
gh repo fork proyecto/tienda --clone
git switch -c arregla-carrito
# ...commits...
git push -u origin arregla-carrito
gh pr create --repo proyecto/tienda

# mantener el fork al día:
git fetch upstream && git rebase upstream/main

Fuentes: GitHub Docs: Syncing a fork

Prácticas que funcionan con cualquier estrategia

Merge queueCada PR se prueba junto con main y con los que entran antes, y solo se fusiona si todo pasa. Evita el «main roto» cuando muchos fusionan a la vez. GitHub la tiene como merge queue (escucha el evento merge_group en tus workflows) y GitLab como merge trains.
Ship / Show / AskNo todo cambio necesita esperar revisión. Ship: va directo a main. Show: PR que se fusiona sin esperar y se revisa después. Ask: PR que espera la revisión. Propuesto por Rouan Wilsenach en martinfowler.com; requiere confianza y buen CI.
main protegidaPull request obligatorio, checks de CI que deben pasar, sin force push y, si hace falta, archivo CODEOWNERS para pedir revisión a quien conoce cada parte. Es lo primero que conviene configurar en cualquier repo de equipo.

Más sobre estas prácticas: GitHub merge queue · GitLab merge trains · Ship / Show / Ask · DORA