DEV Community: Diego

Rebalancing a portfolio without selling anything: the contribution algorithm

Diego — Thu, 18 Jun 2026 23:50:16 +0000

How to split a monthly contribution across several assets to pull a portfolio back toward its targets — without selling anything or paying taxes.

Every long-term investor hits the same wall: you set a target allocation (say 40% stocks, 25% fixed income, 20% REITs, 15% international), the market moves, and three months later your portfolio is lopsided. The classic advice is to rebalance by selling what went up and buying what went down.

The problem: selling triggers taxes, brokerage fees, and — here in Brazil — the headache of filing a DARF. There's a far cheaper way to rebalance if you contribute every month: steer the new money toward the categories that are lagging. Without selling a single share.

This post walks through the algorithm I used for that. It's subtler than it looks.

The naive temptation (which is wrong)

Everyone's first idea is: "I have $1,000 to invest, I'll split it by the targets." 40% goes to stocks, 25% to fixed income, and so on.

# WRONG
for category in categories:
    budget[category] = contribution * category.target_pct / 100

This rebalances nothing — it just perpetuates the current allocation. If your stocks are already at 50% (above the 40% target), throwing another 40% of the contribution at them makes the drift worse.

What you actually want is the opposite: give more money to whoever is furthest behind the target.

The core concept: the gap

For each category, compute how much it should be worth after the contribution, and how far it is from getting there:

new_total = current_total + contribution

def gap(category):
    target_value = new_total * category.target_pct / 100
    return max(0, target_value - category.current_value)

The max(0, ...) matters: categories that have already passed the target have a gap of zero — they get nothing from the contribution (and they naturally drift back toward the target as everything else grows around them).

Now distribute the budget proportionally to the gaps, not to the targets:

total_gap = sum(gap(c) for c in categories)

for category in categories:
    budget[category] = contribution * gap(category) / total_gap

That's it — the money flows on its own toward the underweight categories. The further behind a category is, the bigger the slice it gets. When everything is on target, the gaps equalize and the contribution splits proportionally just like the naive case (which, in that case, is the correct behavior).

Edge case: if every category is already at or above target, total_gap == 0 and you'd hit a division by zero. Fall back to distributing by target — there's nothing to correct, just keep the proportions.

The annoying problem: shares are indivisible

So far it's clean arithmetic. Reality breaks it: you don't buy "$213.47 of PETR4". You buy a whole number of shares.

def buy_suggestion(asset, budget):
    quantity = int(budget / asset.price)   # rounds down
    if quantity <= 0:
        return None
    cost = quantity * asset.price
    return {'ticker': asset.ticker, 'quantity': quantity, 'cost': cost}

That int() throws away the leftovers from each asset. Add it up across a 15-asset portfolio and you can easily leave $150 of the contribution sitting idle. Unacceptable — the user wants to see the money allocated.

Spending the change: the greedy second pass

The fix is a second pass that takes whatever is left and spends it greedily, always on the category with the largest remaining deficit:

def spend_remaining(remaining, assets, simulated):
    while remaining > 0:
        best = None
        largest_deficit = 0

        for asset in assets:
            if asset.price > remaining:          # can't afford even one unit
                continue
            deficit = asset.category.target_value - simulated[asset.category]
            if deficit > largest_deficit:
                largest_deficit = deficit
                best = asset

        if best is None:                          # nothing else fits the change
            break

        remaining -= best.price                   # buy +1 unit
        simulated[best.category] += best.price
        record_buy(best, quantity=1)

    return remaining

Each loop iteration buys one unit of the asset whose category is furthest behind, updates the simulated deficit, and repeats. It stops when the leftover can't buy even the cheapest share. This squeezes the contribution down to the last possible dollar, without ever breaking the target logic.

(Fixed income is easier: since it's divisible, you can allocate exact cents — no whole-number problem.)

Selling, only when you choose to

Sometimes the drift is too large to fix with contributions alone. Then the user opts in to rebalance by selling. The excess calculation is the mirror image of the gap:

def sell_suggestions(category):
    excess = category.current_value - category.target_value
    if excess <= 0:
        return []
    # sell from each asset proportionally to its weight in the category
    sells = []
    for asset in category.assets:
        slice = excess * (asset.current_value / category.current_value)
        qty = int(slice / asset.price)
        if qty > 0:
            sells.append({'ticker': asset.ticker, 'quantity': qty})
    return sells

And since this is Brazil, you can add an avoid_tax_sells=True flag that skips ETFs and REITs (tickers ending in 11, always taxed here) from the sell suggestions — so you rebalance touching only the tax-exempt holdings.

Why it matters

The result is that the investor opens the app, types "I'm going to invest $1,000," and gets a list like:

Buy   12 BOVA11   × $ 38.50   = $ 462.00
Buy    8 MXRF11   × $ 10.30   = $  82.40
Add      Nubank CD          = $ 455.60
Leftover: $ 0.00

Everything allocated, the portfolio closer to its targets, and no taxes paid. That's the difference between "rebalancing" as a tedious quarterly chore and as something that happens on its own with every contribution.

I built this into Balance, an app that helps Brazilian investors keep their portfolio on target by computing exactly these suggestions on every contribution. The full service also handles crypto (8-decimal fractions), multiple markets, and tax reporting — but the heart of it is the algorithm above.

Rebalanceando uma carteira sem vender nada: o algoritmo do aporte

Diego — Thu, 18 Jun 2026 23:26:09 +0000

Como dividir um aporte mensal entre vários ativos pra aproximar a carteira das metas — sem precisar vender nada nem pagar imposto.

Todo investidor de longo prazo bate na mesma parede: você define uma alocação-alvo (digamos 40% ações, 25% renda fixa, 20% FIIs, 15% internacional), o mercado se mexe, e três meses depois a carteira tá torta. O conselho clássico é rebalancear vendendo o que subiu e comprando o que caiu.

O problema: vender gera imposto, custo de corretagem e, no Brasil, dor de cabeça com DARF. Existe um jeito muito mais barato de rebalancear se você aporta todo mês — direcionar o dinheiro novo pras categorias que estão atrasadas. Sem vender uma cota sequer.

Esse post mostra o algoritmo que usei pra isso. É mais sutil do que parece.

A tentação ingênua (que está errada)

A primeira ideia de todo mundo é: "tenho R$ 1.000 pra aportar, divido pelas metas". 40% vão pra ações, 25% pra renda fixa, e assim por diante.

# ERRADO
for categoria in categorias:
    orcamento[categoria] = aporte * categoria.meta_pct / 100

Isso não rebalanceia nada — só perpetua a alocação atual. Se suas ações já estão em 50% (acima dos 40% de meta), jogar mais 40% do aporte nelas piora o desvio.

O que você quer é o contrário: dar mais dinheiro pra quem está mais atrás da meta.

O conceito central: o gap

Para cada categoria, calcule quanto ela deveria valer depois do aporte, e quanto falta pra chegar lá:

novo_total = total_atual + aporte

def gap(categoria):
    valor_alvo = novo_total * categoria.meta_pct / 100
    return max(0, valor_alvo - categoria.valor_atual)

O max(0, ...) é importante: categorias que já passaram da meta têm gap zero — não recebem nada do aporte (e vão naturalmente "voltar" à meta conforme o resto cresce em volta delas).

Agora distribua o orçamento proporcionalmente aos gaps, não às metas:

total_gap = sum(gap(c) for c in categorias)

for categoria in categorias:
    orcamento[categoria] = aporte * gap(categoria) / total_gap

Pronto — o dinheiro flui sozinho pras categorias subalocadas. Quanto mais atrás uma categoria está, maior a fatia que ela recebe. Quando todas estão na meta, os gaps se igualam e o aporte cai proporcionalmente como no caso ingênuo (que aí, sim, é o comportamento certo).

Caso de borda: se todas as categorias já estão na ou acima da meta, total_gap == 0 e você cairia numa divisão por zero. Nesse caso, faça fallback pra distribuição por meta — não há o que corrigir, só manter a proporção.

O problema chato: ações são indivisíveis

Até aqui é aritmética limpa. A realidade quebra ela: você não compra "R$ 213,47 de PETR4". Compra um número inteiro de ações.

def sugestao_compra(ativo, orcamento):
    quantidade = int(orcamento / ativo.preco)   # arredonda pra baixo
    if quantidade <= 0:
        return None
    custo = quantidade * ativo.preco
    return {'ticker': ativo.ticker, 'quantidade': quantidade, 'custo': custo}

Esse int() joga fora as sobras de cada ativo. Some isso por uma carteira de 15 ativos e você facilmente deixa R$ 150 do aporte parados. Inaceitável — o usuário quer ver o dinheiro alocado.

Gastando o troco: a passada gulosa

A solução é uma segunda passada que pega o que sobrou e gasta de forma gulosa, sempre na categoria com maior déficit restante:

def gastar_restante(restante, ativos, simulado):
    while restante > 0:
        melhor = None
        maior_deficit = 0

        for ativo in ativos:
            if ativo.preco > restante:          # não cabe nem 1 unidade
                continue
            deficit = ativo.categoria.valor_alvo - simulado[ativo.categoria]
            if deficit > maior_deficit:
                maior_deficit = deficit
                melhor = ativo

        if melhor is None:                       # nada mais cabe no troco
            break

        restante -= melhor.preco                 # compra +1 unidade
        simulado[melhor.categoria] += melhor.preco
        registrar_compra(melhor, quantidade=1)

    return restante

Cada volta do loop compra uma unidade do ativo cuja categoria está mais atrás, atualiza o déficit simulado, e repete. Para quando o troco não compra nem a ação mais barata. Isso espreme o aporte até o último real possível, sem nunca furar a lógica de meta.

(Renda fixa é mais fácil: como é divisível, dá pra alocar centavos exatos — sem o problema do inteiro.)

Vender só quando você quiser

Às vezes o desvio é grande demais pra corrigir só com aporte. Aí o usuário opta por rebalancear vendendo. O cálculo do excesso é o espelho do gap:

def sugestoes_venda(categoria):
    excesso = categoria.valor_atual - categoria.valor_alvo
    if excesso <= 0:
        return []
    # vende de cada ativo proporcional ao peso dele na categoria
    vendas = []
    for ativo in categoria.ativos:
        fatia = excesso * (ativo.valor_atual / categoria.valor_atual)
        qtd = int(fatia / ativo.preco)
        if qtd > 0:
            vendas.append({'ticker': ativo.ticker, 'quantidade': qtd})
    return vendas

E como isso é Brasil, dá pra adicionar um flag evitar_vendas_ir=True que pula ETFs e FIIs (tickers terminados em 11, sempre tributados) das sugestões de venda — você rebalanceia mexendo só no que é isento.

Por que isso importa

O resultado é que o investidor abre o app, digita "vou aportar R$ 1.000", e recebe uma lista do tipo:

Comprar  12 BOVA11   × R$ 38,50   = R$ 462,00
Comprar   8 MXRF11   × R$ 10,30   = R$  82,40
Aportar     CDB Nubank          = R$ 455,60
Sobra: R$ 0,00

Tudo alocado, carteira mais perto das metas, e nenhum imposto pago. É a diferença entre "rebalanceamento" como tarefa trimestral chata e como algo que acontece sozinho a cada aporte.

Construí isso no Balance, um app de código que ajuda investidores brasileiros a manter a carteira na meta calculando exatamente essas sugestões a cada aporte. O serviço completo lida ainda com cripto (frações de 8 casas), múltiplos mercados e cálculo de IR — mas o coração é o algoritmo acima.