Aceita novos projetos · equipa composta apenas por profissionais seniores · trabalho remoto em primeiro lugar PWN-ALL · Estúdio de software personalizado

Software em que sobreviva a equipa que o lançou.

Somos um estúdio composto exclusivamente por profissionais seniores que desenvolve software personalizado em duas linguagens de forma deliberada: Rust, onde errar custa caro, e Python, onde demorar a entregar custa caro.

Iniciar projeto Ver a pilha
Melhoria média p99 0× em 40 migrações
Redução de memória 0 em comparação com as linhas de base da JVM / Node
Serviços em produção 0 desde 2024
Incidentes de segurança resolvidos 0 ao longo de toda a nossa história
Equipas que confiam no nosso código
01 Duas linguagens. Não cinco.

Uma pilha, escolhida a propósito.

Agências poliglotas soam bem numa apresentação de vendas. Na prática, significam três sistemas de compilação, quatro variações de null e um cemitério de serviços mal mantidos. Escolhemos duas linguagens que cobrem 95% das cargas de trabalho reais — e tornámo-nos muito, muito bons em ambas.

Caminho crítico · sistemas · segurança

Rust

9,6 índice de ajuste interno

Seguro em termos de memória sem um coletor de lixo. Livre de conflitos de dados em tempo de compilação. O revisor de código mais exigente que alguma vez terá — e, assim que o aprovar, o seu serviço não o acordará ao domingo.

Quando o procuramos

  • Canais de pagamento e tudo o que envolva dinheiro ou dados pessoais identificáveis
  • Gateways de API de alta disponibilidade com SLAs de 99,999%
  • Mecanismos de correspondência de baixa latência, negociação, em tempo real
  • Módulos WebAssembly enviados para o navegador
  • Ferramentas CLI e daemons que devem iniciar em milésimos de segundo

Compromissos que não ignoramos

  • Integração de novos colaboradores: ~2–4 semanas até à produtividade
  • Tempos de compilação em espaços de trabalho enormes (resolvemos com sccache)
  • Ecossistema mais recente do que o Java — maduro onde é importante
Glue · dados · ML · velocidade

Python

9,3 índice de ajuste interno

O caminho mais rápido do quadro branco ao sistema funcional. O ecossistema mais rico do mundo para dados, ML e automação. Python moderno — 3.12, uv, ruff, pydantic, FastAPI — é uma linguagem precisa, tipada e suficientemente rápida para a maior parte do que precisa.

Quando o procuramos

  • Ferramentas internas, painéis de controlo e painéis de administração
  • ETL, pipelines de dados, Airflow / Dagster / Prefect
  • ML — treino, implementação, avaliação
  • Automatizações e integrações com APIs de fornecedores
  • MVPs lançados neste trimestre, não no próximo ano

Compromissos que não ignoramos

  • O rendimento de um único núcleo é 20–50 vezes mais lento do que o Rust
  • Maior consumo de memória por solicitação — fatal para algumas cargas de trabalho
  • A tipagem dinâmica apresenta problemas sem o uso rigoroso do mypy / pydantic
Rust, onde o erro custa caro. Python, onde o atraso no lançamento é caro. Uma equipa. Zero dogmas.
02 Os números, não as vibrações

Rust e Python contra os suspeitos do costume.

Toque numa métrica para ver onde cada linguagem se situa. As pontuações variam entre 0 e 10 e são calculadas a partir dos nossos próprios testes de desempenho e de fontes públicas (Techempower R22, CLBG, migrações reais que realizámos).

Criterio Rust Python Go C++ Java Node.js
Desempenho bruto (p99, núcleo único) 10 3 7 10 7 5
Segurança da memória e disputas de dados 10 9 8 2 8 7
Tempo até ao protótipo funcional 5 10 7 3 6 8
Amplitude do ecossistema 8 10 7 9 10 9
Concorrência sem complicações 10 6 9 4 6 7
Custo operacional por pedido 10 5 8 9 5 6
Disponibilidade de talentos seniores 6 10 7 8 10 9
Manutenção a 10 anos 10 8 8 5 8 5
03 De → Para

O que muda quando migra.

Escolha uma linguagem inicial. Veja o impacto da mudança para Rust ou Python. Os números são medianas dos nossos últimos 40 projetos de migração, não são exageros de marketing.

Atualmente em

C / C++

Rápido, sim. Mas cada ponteiro nulo é um potencial CVE, cada thread é uma potencial corrida de dados, e o seu sistema de compilação é o trabalho a tempo inteiro de alguém.

Problemas típicos
  • CVE de segurança de memória
  • Comportamento indefinido
  • Expansão do sistema de compilação
Mudar para

Rust

Rendimento ×6,4
Pegada de memória −78%
Falhas de execução −99%
Fatura mensal de computação −65%

Ideal quando se lida atualmente com erros de ponteiro nulo, disputas de dados ou memória que cresce sem limites. O Rust mantém a velocidade e elimina os riscos.

Mudar para

Python

Velocidade de desenvolvimento ×3,1
Linhas de código −55%
Tempo até ao lançamento −60%
Sobrecarga de tempo de execução +40%

Ideal quando o custo real é o tempo de engenharia, não a CPU. Troque o rendimento bruto por um ciclo de feedback mais curto, bibliotecas mais ricas e código que os humanos consigam realmente ler.

Como medimos estes números

Médias das 40 migrações concluídas entre 2023 e 2026. A taxa de transferência foi medida na camada de aplicação (p50 de ponta a ponta sob carga realista, não em microbenchmarks). A memória é RSS em estado estável. O custo é de computação mensal sob demanda na AWS/GCP, mantendo-se tudo o resto igual. Os resultados individuais variam — publicamos também aqueles que não correram conforme o planeado, mediante solicitação.

04 Números sem asteriscos

Pedidos por segundo sob carga real.

Carga de trabalho idêntica — validação JSON → consulta Postgres → renderização — medida numa única máquina AMD Ryzen 7. Isto não são microbenchmarks. Fonte e metodologia ↓

  1. 1 Rust · Axum
    21 030 req/s
  2. 2 C# .NET · ASP.NET Core
    14.707 req/s
  3. 3 Node.js · Fastify
    9.340 solicitações/s
  4. 4 C++ · Drogon
    7.200 solicitações/s
  5. 5 Go · Gin
    3.546 req/s
  6. 6 Python · FastAPI (Uvicorn)
    1.185 req/s
  7. 7 PHP · Laravel
    299 solicitações/s

Interprete isto corretamente: o Python está perto do fundo deste gráfico, e isso é normal. Não executamos o FastAPI no caminho de acesso frequente. Executamo-lo onde 1.185 req/s já é cerca de 10 vezes mais do que a carga de trabalho necessita, e as horas de trabalho dos engenheiros valem mais do que os ciclos de CPU. Metodologia: AMD Ryzen 7, Linux, Docker, instância única, uma estrutura popular por linguagem. Os números são médias de várias execuções.

05 O custo real de código defeituoso

O que uma interrupção realmente lhe custa.

«Cinco noves» não é marketing. Abaixo está o que custa uma hora de inatividade não planeada, por setor — com fontes. Construímos o Rust onde estes números existem.

Custo acumulado desde que abriu esta secção
Finanças / saúde $0 ~83 mil dólares/min · 5 milhões de dólares/hora
Automóvel $0 ~38 mil $/min · 2,3 milhões $/h
Grandes empresas 0 23 750 $/min · 1,4 milhões de $/h
Empresa de média dimensão 0 ~5 mil $/min · 300 mil $/h
Finanças e cuidados de saúde Mais de 5 milhões de dólares por hora

Os setores de maior risco. As plataformas de negociação, os sistemas de liquidação e os sistemas clínicos podem ultrapassar os 5 milhões de dólares por hora durante uma interrupção grave — antes de se contabilizarem quaisquer custos regulamentares ou de litígio.

Fonte: Estudo da Gartner sobre a Fortune 500 de 2024; Custo por hora do tempo de inatividade da ITIC de 2024.
Fabrico automóvel 2,3 milhões de dólares / hora

Uma linha de produção paralisada representa um prejuízo de cerca de 640 dólares por segundo. A interrupção dos serviços da CrowdStrike em julho de 2024 custou à Delta Air Lines, só a ela, 380 milhões de dólares em cinco dias.

Fonte: Análise setorial do Erwood Group de 2025; análise pós-incidente da Antithesis sobre a CrowdStrike.
Grande empresa (média) 1,4 milhões de dólares/hora

Número da BigPanda para grandes empresas em 2024: 23 750 dólares por minuto. O ITIC relata que 41% das grandes empresas perdem entre 1 milhão e 5 milhões de dólares por hora de interrupção.

Fonte: Investigação da BigPanda para 2024; 11.º Relatório Anual do ITIC sobre o Custo Horário do Tempo de Inatividade.
Global 2000 (Oxford Economics) 400 mil milhões de dólares / ano

Custo total oculto do tempo de inatividade não planeado nas 2.000 maiores empresas do mundo, segundo o estudo de 2024 da Oxford Economics — com um impacto médio de 200 milhões de dólares por empresa quando se somam receitas, produtividade e reparação.

Fonte: Oxford Economics 2024, “The Hidden Costs of Downtime”.
Médias e grandes empresas (hora típica) Mais de 300 mil dólares / hora

Inquérito da ITIC de 2024: mais de 90% das médias e grandes empresas consideram agora que uma única hora de tempo de inatividade não planeado ultrapassa este limite — excluindo penalizações legais, civis ou regulamentares.

Fonte: Relatório do ITIC de 2024 sobre o custo por hora do tempo de inatividade.
Pequenas e médias empresas (PME) 25 000–150 000 $ / hora

O estudo conjunto ITIC/Calyptix de 2025 revela que muitas PME perdem este valor por hora; a Siemens relata que as PME afetadas por interrupções podem chegar a perder até 150 000 dólares por hora. A duração média de uma interrupção é de 87 minutos.

Fonte: ITIC + Calyptix 2025; Siemens True Cost of Downtime 2024.
06 Trabalhos selecionados

Três projetos. Três desafios diferentes.

Anonimizados onde o acordo de confidencialidade o exige, específicos onde os resultados o justificam. Estes são os projetos que apresentaríamos em primeiro lugar a um comprador técnico.

  1. Caso 01 Python Base de dados Criptografia RGPD

    Cofre de dados Fintech: 4 vezes menor, 5,5 vezes mais rápido, em conformidade global.

    O cliente mantinha um cluster Postgres de 1,8 TB sobrecarregado com colunas legadas, índices inativos e BLOBs com encriptação inline que tinham crescido ao longo de sete anos. A criptografia era executada numa biblioteca obsoleta sinalizada em três auditorias distintas. O risco regulatório era real; os auditores estavam de olho.

    O que fizemos

    • Auditoria completa do esquema e da utilização, remoção de colunas e índices não utilizados, introdução de particionamento adequado.
    • Migrar o pipeline de criptografia de uma biblioteca legada para uma pilha AEAD moderna e auditada com chaves rotativas.
    • Converter a encriptação BLOB-inline para encriptação de envelope referenciada + KMS dedicado.
    • Alinhar a retenção de dados e os fluxos de acesso dos titulares de dados com o RGPD, a CCPA e a APPI.
    Resultado

    Os mesmos dados, um quarto da conta de armazenamento, 5,5 vezes mais rendimento e um atestado de boa saúde para o próximo regulador que viesse bater à porta.

  2. Caso 02 Rust C++ → Rust Segurança Armazenamento

    Serviço em C++ reescrito em Rust: mais de 100 bugs da classe CVE eliminados em 9 semanas.

    Serviço de processamento de ficheiros voltado para o utilizador em C++, que falhava a cada 4–5 dias e era corrigido no local de cada vez. A nossa auditoria revelou mais de 100 bugs reais: caminhos de negação de serviço, transbordamentos de buffer, tratamento de pedidos sem limites. Os erros 503 nas horas de pico eram um ritual semanal. No lado do armazenamento, os uploads dos utilizadores tinham-se acumulado numa confusão de ficheiros duplicados que esgotavam o espaço de armazenamento.

    O que fizemos

    • Reescrita completa em Rust (axum + tokio) com validação rigorosa de entradas e limites de recursos definidos.
    • Testes baseados em propriedades + cargo-fuzz em todos os analisadores e limites de formato de transmissão.
    • Camada de armazenamento endereçada por conteúdo com desduplicação no momento da gravação.
    • Implementação blue-green num intervalo de integração de 4 horas, sem tempo de inatividade.
    Resultado

    O serviço passou de «frágil e remendado semanalmente» para «deixámos de olhar para o pager». Os custos de armazenamento baixaram com a deduplicação, os tickets de suporte sobre erros e 503s desapareceram, e a reescrita pagou-se a si própria no espaço de um trimestre.

  3. Caso 03 Rust Python eBPF / XDP CRM · 4 mil utilizadores

    CRM empresarial, reconstruído: 18 servidores → 5, redução de custos de mais de 60%.

    CRM interno a servir mais de 4.000 utilizadores em IAM, SOC, registo centralizado, chat, partilha de ficheiros, VoIP e dados encriptados de ponta a ponta. Dezoito servidores, Cloudflare por cima, e uma fatura de nuvem que continuava a crescer independentemente do número de colaboradores. Reconstruímos o caminho ativo em Rust, mantivemos o Python na camada de integração e relatórios e colocámos um filtro eBPF/XDP diretamente à frente da entrada.

    O que fizemos

    • Serviços Rust para autenticação (IAM), mensagens em tempo real, sinalização VoIP e transferência de ficheiros.
    • Python para interfaces de administração, relatórios, correlação de eventos SOC e integração com APIs de fornecedores.
    • Filtragem de bots e abusos via eBPF/XDP no kernel — substituiu o Cloudflare para esta carga de trabalho.
    • Pipeline de registo estruturado reescrito em torno de um esquema de cópia zero.
    Resultado

    Treze servidores a menos, fim da rubrica orçamental da Cloudflare, a equipa do SOC vê um sinal mais claro através do pipeline de registo, e o diretor financeiro deixou de fazer perguntas incómodas sobre o orçamento de infraestrutura.

07 Como trabalhamos na prática

Ajuste os parâmetros. Veja o plano a mudar.

Cada projeto equilibra velocidade, custo e fiabilidade. A estimativa em cinco fases abaixo é calibrada em relação às medianas do setor (descoberta 2–6 semanas, arquitetura 1–4 semanas, implementação 4–20 semanas, reforço 2–8 semanas, entrega 1–2 semanas — de acordo com relatórios de 2024–2026 da NIX United, Agilie, SOLTECH, OTG Lab). Mova os controles deslizantes; o plano é recalculado em tempo real.

01

Descoberta

3 semanas

Leia o seu código, entreviste a sua equipa de operações, liste as incógnitas, escolha a linguagem por componente.

  • Entrevistas sobre o domínio e auditoria de código
  • Registo de riscos e metas do SLA
  • Decisão sobre a linguagem por serviço
02

Arquitetura

2 semanas

Contratos antes do código. OpenAPI / protobuf, modelos de dados, topologia de implementação, esboços de manuais de operações.

  • RFCs para todos os contratos públicos
  • Modelo de dados + plano de migração
  • Linha de base de infraestrutura como código
03

Implementação

8 semanas

Pequenos PRs, CI aprovado desde o primeiro dia, implementações em cada fusão, revisão por um segundo sénior.

  • Rust: axum · tonic · sqlx
  • Python: FastAPI · Pydantic · SQLAlchemy
  • Demonstrações semanais + registo de alterações
04

Reforço

3 semanas

Fuzzing, testes baseados em propriedades, testes de carga com tráfego realista, modelo de ameaças.

  • cargo-fuzz · proptest · hypothesis
  • Testes de carga k6 vinculados a SLOs
  • Revisão de segurança e auditoria de dependências
05

Entrega

1 semana

Runbooks, rotação de plantão, ADRs e uma equipa que já lançou isto uma vez.

  • Manuais de procedimentos + matriz de plantões
  • Registo de ADR e diagramas de arquitetura
  • Suporte pós-lançamento de 30 dias
08 O mesmo problema, duas linguagens

Como o mesmo endpoint se apresenta em cada uma.

Recuperar um utilizador, validar a entrada, persistir no Postgres, devolver JSON. Alterne entre as linguagens — ambas são código real que realmente lançaríamos. 

SQL_CREATE_USER = "insert into users(email,name) values(lower($1),$2) returning id,email,name"
Name = Annotated[str, StringConstraints(strip_whitespace=True, min_length=1, max_length=120)]

class UserIn(BaseModel):
    email: EmailStr
    name: Name

class UserOut(UserIn):
    id: int

@router.post("/users", response_model=UserOut, status_code=201)
async def create_user(u: UserIn) -> UserOut:
    try:
        row = await pool.fetchrow(SQL_CREATE_USER, str(u.email), u.name)
   except UniqueViolationError as exc:
        raise HTTPException(status_code=409, detail="email já existe") from exc
    if row is None:
        raise HTTPException(status_code=500, detail="falha na inserção")
    return UserOut.model_validate(dict(row))
#[derive(Deserialize, Validate)]
#[serde(deny_unknown_fields)]
pub struct UserIn {
    #[validate(email)]
    pub email: String,
    #[validate(custom(function = "valid_name"))]
    pub name: String,
}

pub async fn create_user(
    State(pool): State<PgPool>,
    ValidatedJson(u): ValidatedJson<UserIn>,
) -> Result<(StatusCode, Json<UserOut>), ApiError> {
   let user = sqlx::query_as!(UserOut,
        "insert into users(email,name) values(lower($1),$2) returning id,email,name",
        u.email.as_str(),
        u.name.trim(),
    )
    .fetch_one(&pool)
    .await
    .map_err(ApiError::from_db)?;

    Ok((StatusCode::CREATED, Json(user)))
}
Linhas de código
16 22
Rendimento
1.185 req/s 21 030 req/s
Latência p50
21,0 ms 1,6 ms
RAM em modo inativo
41,2 MB 8,5 MB
Respondemos no prazo de 1 dia útil. Não estamos a brincar.

Você leu a página inteira.
Vamos construir isto.

Diga-nos o que está errado com a sua pilha de tecnologias, ou o que pretende construir do zero. Receberá uma opinião técnica genuína — não um argumento de vendas.

hello@pwn-all.com Voltar ao topo
  • Sem engenheiros juniores. Sem subcontratação no estrangeiro.
  • Opções de preço fixo para trabalhos com âmbito definido.
  • NDA assinado antes de lhe fazermos qualquer pergunta.