DEV Community: Diego

Rebalanceando a carteira só com o próximo aporte (sem vender)

Diego — Tue, 23 Jun 2026 20:55:55 +0000

Parte de uma série sobre construir o Balance, um app de rebalanceamento de carteira
para investidores BR/US/Cripto, como dev solo. O código aqui é simplificado em relação ao real.

Todo investidor que faz aportes recorrentes esbarra na mesma parede:

"Tenho R$ 1.000 pra investir esse mês. O que eu compro pra minha carteira ficar perto da meta?"

A resposta de manual — "venda o que está acima, compre o que está abaixo" — tem custo: IR, corretagem e a disciplina emocional de vender o que está subindo. Existe um caminho mais gentil, que quase ninguém formaliza: rebalancear usando só o novo aporte.

É esse o algoritmo no coração do Balance. Vamos construir.

A ideia em um exemplo

Digamos que sua meta seja:

Categoria	Meta
Ações	40%
Renda fixa	25%
FIIs	20%
Internacional	15%

Esse mês, depois de algumas oscilações de preço, você está em 46% de ações e 16% de FIIs. Ações acima, FIIs abaixo.

Em vez de vender ações (e gerar um fato gerador de IR), você direciona o aporte do mês inteiro para as categorias abaixo da meta. A carteira converge para o alvo sem uma única venda.

O algoritmo

A coisa toda é: descobrir o quanto cada categoria está longe de onde deveria estar depois do aporte, e distribuir o aporte proporcionalmente a esses gaps.

from collections import defaultdict
from decimal import Decimal

def calculate(self, deposit_amount: Decimal) -> dict:
    deposit = Decimal(deposit_amount).quantize(Decimal('0.01'))

    investments = self._category_investments()   # {category_id: [(kind, item), ...]}
    current_total = self.portfolio.total_value
    new_total = current_total + deposit

    # 1. Valor atual em cada categoria
    cat_value = defaultdict(lambda: Decimal('0'))
    for cat_id, rows in investments.items():
        for kind, item in rows:
            cat_value[cat_id] += item.current_value

    # 2. Gap = o quanto cada categoria está ABAIXO da meta pós-aporte
    gaps = {}
    for cat_id, rows in investments.items():
        category = rows[0][1].category
        target_value = new_total * category.target_percentage / Decimal('100')
        gaps[cat_id] = max(Decimal('0'), target_value - cat_value[cat_id])

    total_gap = sum(gaps.values())

    # 3. Divide o aporte entre as categorias, proporcional a cada gap
    cat_budget = {
        cat_id: (deposit * gaps[cat_id] / total_gap).quantize(Decimal('0.01'))
        for cat_id in investments
    }
    ...

Três passos:

Valor por categoria — soma o que você tem hoje em cada uma.
Gap por categoria — max(0, meta − atual). Categorias já na meta ou acima têm gap zero; não recebem nada.
Orçamento por categoria — distribui o aporte proporcionalmente aos gaps.

O max(Decimal('0'), ...) é o pulo do gato: categorias acima da meta simplesmente não competem pelo aporte. O dinheiro flui para onde falta.

Caso de borda: se todas as categorias já estão na meta ou acima (total_gap == 0), não há déficit a preencher. Caímos num fallback que divide o aporte por peso de meta, mantendo a alocação atual em vez de dividir por zero.

Do orçamento para as ordens

Orçamento por categoria ainda não é uma ordem — você não compra 3,7 ações. Então o orçamento de cada categoria é dividido entre os ativos e vira quantidade inteira:

def _buy_suggestion(self, kind, item, budget: Decimal):
    if budget <= 0:
        return None

    if self.portfolio.market == 'CRYPTO':
        quantity = (budget / item.current_price).quantize(Decimal('0.00000001'))
    else:
        quantity = int(budget / item.current_price)   # só ações inteiras

    if quantity <= 0:
        return None
    cost = (quantity * item.current_price).quantize(Decimal('0.01'))
    return self._asset_suggestion_row(item, quantity, cost)

Repare no branch por mercado: ações compram unidades inteiras (int()), cripto compra frações de até 8 casas decimais. Esse único if é o que permite o mesmo motor servir uma carteira de ações e uma de Bitcoin. (Tem um artigo só sobre essa decisão mais pra frente na série.)

O problema do troco

Arredondar para ações inteiras deixa dinheiro na mesa. Compre int(500 / 140) = 3 ações a R$140 e você gastou R$420 — sobram R$80 do aporte sem alocação.

Por isso há uma segunda passada que gasta o restante, de forma gananciosa, na categoria que ainda tem o maior déficit:

while remaining > 0:
    # pega a categoria mais abaixo da meta que ainda dá pra comprar
    best_item = max(
        affordable_items,
        key=lambda it: target(it) - simulated_value[it.category_id],
        default=None,
    )
    if best_item is None:
        break
    # compra mais uma ação (ou, pra cripto, gasta todo o resto como fração)
    ...

Para ações isso compra uma ação extra por vez até não sobrar nada comprável. Para cripto, joga o restante no ativo mais abaixo da meta como fração. De qualquer jeito, o aporte é totalmente deployado em vez de deixar caixa parado.

Opcional: rebalancear com vendas (driblando o IR)

Às vezes o aporte não basta — uma categoria está tão acima que nenhum aporte realista resolve. Para esses casos, o serviço pode sugerir vendas também, com uma sacada específica da lei brasileira:

if avoid_ir_sells and _is_always_taxed(ticker):
    continue   # nunca sugere vender um ativo sempre tributado (ETF/FII)

No Brasil, vendas de ações até R$20k/mês são isentas, mas ETFs e FIIs (tickers terminados em 11) são sempre tributados. A flag avoid_ir_sells manda o motor rebalancear vendendo só o que é isento, deixando os ativos tributáveis intocados. O mesmo cálculo, agora consciente do IR.

Por que isso virou o produto

A matemática aqui não é sofisticada — é distribuição proporcional com alguns guardas. Mas embrulhada numa UI que busca cotação ao vivo, sabe suas metas e respeita as regras de IR, ela responde uma pergunta que investidores reais fazem todo mês e hoje resolvem com planilha e chute.

É a lição que eu fico reaprendendo construindo o Balance: a parte valiosa raramente é o algoritmo. É remover o atrito em volta dele.

O Balance é uma ferramenta de rebalanceamento para investidores BR/US/Cripto — diz o que comprar com o próximo aporte pra ficar na meta. Se você faz aportes recorrentes e quer testar, o link está no perfil. Dúvidas sobre a abordagem? Comenta aí.

Rebalancing a portfolio with only your next deposit (no selling)

Diego — Tue, 23 Jun 2026 20:43:10 +0000

Part of a series on building Balance, a portfolio rebalancing app for BR/US/Crypto
investors, as a solo developer. Code in this article is simplified from the real service.

Every investor who makes recurring contributions hits the same wall:

"I have $1,000 to invest this month. What do I buy so my portfolio stays close to my target allocation?"

The textbook answer — "sell what's overweight, buy what's underweight" — has a cost: taxes, brokerage fees, and the emotional discipline to sell things that are going up. There's a gentler approach that most people never formalize: rebalance using only the new deposit.

This is the core algorithm behind Balance. Let's build it.

The idea in one example

Say your target allocation is:

Category	Target
Stocks	40%
Fixed income	25%
REITs	20%
International	15%

This month, after some price moves, you're actually at 46% stocks and 16% REITs. Stocks are overweight, REITs underweight.

Instead of selling stocks (and triggering a taxable event), you point this month's entire deposit at the underweight categories. The portfolio converges toward target without a single sale.

The algorithm

The whole thing is: figure out how far each category is from where it should be after the deposit, then distribute the deposit proportionally to those gaps.

from collections import defaultdict
from decimal import Decimal

def calculate(self, deposit_amount: Decimal) -> dict:
    deposit = Decimal(deposit_amount).quantize(Decimal('0.01'))

    investments = self._category_investments()   # {category_id: [(kind, item), ...]}
    current_total = self.portfolio.total_value
    new_total = current_total + deposit

    # 1. Current value held in each category
    cat_value = defaultdict(lambda: Decimal('0'))
    for cat_id, rows in investments.items():
        for kind, item in rows:
            cat_value[cat_id] += item.current_value

    # 2. Gap = how much each category is BELOW its post-deposit target
    gaps = {}
    for cat_id, rows in investments.items():
        category = rows[0][1].category
        target_value = new_total * category.target_percentage / Decimal('100')
        gaps[cat_id] = max(Decimal('0'), target_value - cat_value[cat_id])

    total_gap = sum(gaps.values())

    # 3. Split the deposit across categories, proportional to each gap
    cat_budget = {
        cat_id: (deposit * gaps[cat_id] / total_gap).quantize(Decimal('0.01'))
        for cat_id in investments
    }
    ...

Three steps:

Value per category — sum what you currently hold in each.
Gap per category — max(0, target − current). Categories already at or above target get a gap of zero; they receive nothing.
Budget per category — distribute the deposit proportionally to the gaps.

The max(Decimal('0'), ...) is the whole trick: overweight categories simply don't compete for the deposit. The money flows to where it's needed.

Edge case: if every category is already at or above target (total_gap == 0), there's no deficit to fill. We fall back to splitting the deposit by target weight, so the new money keeps the existing allocation rather than dividing by zero.

From budget to actual orders

A budget per category isn't an order yet — you can't buy 3.7 shares of a stock. So each category's budget is divided among its assets and turned into whole-share quantities:

def _buy_suggestion(self, kind, item, budget: Decimal):
    if budget <= 0:
        return None

    if self.portfolio.market == 'CRYPTO':
        quantity = (budget / item.current_price).quantize(Decimal('0.00000001'))
    else:
        quantity = int(budget / item.current_price)   # whole shares only

    if quantity <= 0:
        return None
    cost = (quantity * item.current_price).quantize(Decimal('0.01'))
    return self._asset_suggestion_row(item, quantity, cost)

Note the market branch: stocks buy whole units (int()), crypto buys fractions down to 8 decimal places. That single if is what lets the same engine serve a stock portfolio and a Bitcoin portfolio. (A whole article on that decision is coming later in the series.)

The leftover problem

Rounding to whole shares leaves money on the table. Buy int(500 / 140) = 3 shares at $140 and you've spent $420 — $80 of the deposit is unallocated.

So there's a second pass that spends the remainder, greedily, on whichever category still has the largest deficit:

while remaining > 0:
    # pick the category furthest below target that we can still afford
    best_item = max(
        affordable_items,
        key=lambda it: target(it) - simulated_value[it.category_id],
        default=None,
    )
    if best_item is None:
        break
    # buy one more share (or, for crypto, spend all the remainder as a fraction)
    ...

For stocks this buys one extra share at a time until nothing affordable is left. For crypto it just dumps the remainder into the most-underweight asset as a fraction. Either way, the deposit gets fully deployed instead of leaving idle cash.

Optional: rebalance with sales (and dodge the tax)

Sometimes a deposit isn't enough — a category is so overweight that no realistic contribution will fix it. For those cases the service can optionally suggest sales too, with a twist specific to Brazilian tax law:

if avoid_ir_sells and _is_always_taxed(ticker):
    continue   # never suggest selling an always-taxed asset (ETFs/REITs)

In Brazil, stock sales up to R$20k/month are tax-exempt, but ETFs and REITs (tickers ending in 11) are always taxed. The avoid_ir_sells flag tells the engine to rebalance by selling only the tax-exempt stuff, leaving the taxable assets untouched. The same calculation, made tax-aware.

Why this became the product

The math here isn't fancy — it's proportional distribution with a couple of guards. But wrapped in a UI that fetches live prices, knows your targets, and respects tax rules, it answers a question that real investors ask every single month and currently solve with a spreadsheet and a guess.

That's the lesson I keep relearning building Balance: the valuable part is rarely the algorithm. It's removing the friction around it.

Balance is a portfolio rebalancing tool for BR/US/Crypto investors — it tells you what to buy with your next deposit to stay on target. If you make recurring contributions and want to try it, the link is in my profile. Questions about the approach? Drop them in the comments.

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.