Accettiamo nuovi progetti · team composto esclusivamente da senior · remote-first PWN-ALL · Studio di software personalizzato

Software in che sopravvive il team che l'ha realizzato.

Siamo uno studio composto esclusivamente da senior che sviluppa software personalizzato in due linguaggi di proposito: Rust, dove sbagliare costa caro, e Python, dove ritardare la consegna costa caro.

Avvia un progetto Guarda lo stack
Miglioramento medio p99 0× su 40 migrazioni
Riduzione della memoria 0 rispetto ai valori di riferimento JVM / Node
Servizi in produzione 0 dal 2024
Incidenti di sicurezza segnalati 0 nel corso della nostra storia
I team che si fidano del nostro codice
01 Due linguaggi. Non cinque.

Un unico stack, scelto appositamente.

Le agenzie poliglotte sembrano fantastiche in una presentazione. In produzione significano tre sistemi di build, quattro varianti di null e un cimitero di servizi mantenuti a metà. Abbiamo scelto due linguaggi che coprono il 95% dei carichi di lavoro reali — e siamo diventati molto, molto bravi in entrambi.

Percorso critico · sistemi · sicurezza

Ruggine

9,6 punteggio di adattamento interno

Sicuro per la memoria senza un garbage collector. Privo di conflitti di dati in fase di compilazione. Il revisore di codice più severo che tu abbia mai avuto — e una volta che ti lascia passare, il tuo servizio non ti sveglia la domenica.

Quando ci proviamo

  • Canali di pagamento e tutto ciò che riguarda denaro o dati personali
  • Gateway API ad alto traffico con SLA a cinque nove
  • Motori di abbinamento a bassa latenza, trading, in tempo reale
  • Moduli WebAssembly inviati al browser
  • Strumenti CLI e daemon che devono avviarsi in pochi millisecondi

Compromessi che non ignoriamo

  • Formazione per i nuovi assunti: ~2–4 settimane per diventare produttivi
  • Tempi di compilazione su spazi di lavoro enormi (risolviamo con sccache)
  • Ecosistema più giovane rispetto a Java — maturo dove conta
Collante · dati · ML · velocità

Python

9,3 punteggio di adattamento interno

Il percorso più veloce dalla lavagna al sistema funzionante. L'ecosistema più ricco al mondo per dati, ML e automazione. Il Python moderno — 3.12, uv, ruff, pydantic, FastAPI — è un linguaggio preciso, tipizzato e abbastanza veloce per la maggior parte delle tue esigenze.

Quando ci proviamo

  • Strumenti interni, dashboard, pannelli di amministrazione
  • ETL, pipeline di dati, Airflow / Dagster / Prefect
  • ML — addestramento, distribuzione, valutazione
  • Automazioni e integrazioni con le API dei fornitori
  • MVP in uscita questo trimestre, non l'anno prossimo

Compromessi che non ignoreremo

  • Il throughput single-core è 20–50 volte più lento rispetto a Rust
  • Maggiore consumo di memoria per richiesta — fatale per alcuni carichi di lavoro
  • La tipizzazione dinamica è un problema senza mypy / pydantic rigorosi
Rust dove l'errore costa caro. Python dove la lentezza nel rilascio costa cara. Un team. Zero dogmi.
02 I numeri, non le sensazioni

Rust e Python contro i soliti sospetti.

Tocca una metrica per evidenziare la posizione di ciascun linguaggio. I punteggi vanno da 0 a 10 e sono compilati dai nostri benchmark e da fonti pubbliche (Techempower R22, CLBG, migrazioni reali che abbiamo effettuato).

Criterio Rust Python Go C++ Java Node.js
Prestazioni grezze (p99, single core) 10 3 7 10 7 5
Sicurezza della memoria e conflitti di dati 10 9 8 2 8 7
Tempo necessario per realizzare un prototipo funzionante 5 10 7 3 6 8
Ampiezza dell'ecosistema 8 10 7 9 10 9
Concorrenza senza lacrime 10 6 9 4 6 7
Costo operativo per richiesta 10 5 8 9 5 6
Disponibilità di talenti senior 6 10 7 8 10 9
Manutenibilità a 10 anni 10 8 8 5 8 5
03 Da → A

Cosa cambia quando si esegue la migrazione.

Scegli un linguaggio di partenza. Osserva l'impatto del passaggio a Rust o Python. I numeri sono mediane ricavate dai nostri ultimi 40 progetti di migrazione, non chiacchiere di marketing.

Attualmente su

C / C++

Veloce, sì. Ma ogni puntatore nullo è un potenziale CVE, ogni thread è una potenziale corsa ai dati, e il tuo sistema di compilazione è il lavoro a tempo pieno di qualcuno.

Problema tipico
  • CVE relativi alla sicurezza della memoria
  • Comportamento indefinito
  • Espansione del sistema di compilazione
Vai a

Rust

Throughput ×6,4
Impronta di memoria −78%
Arresti anomali in fase di esecuzione −99%
Fattura mensile per il calcolo −65%

Ideale se attualmente convivete con bug del puntatore nullo, conflitti di accesso ai dati o memoria che cresce senza limiti. Rust mantiene la velocità ed elimina le insidie.

Passa a

Python

Velocità di sviluppo ×3,1
Righe di codice −55%
Tempo di rilascio −60%
Overhead di runtime +40%

Ideale quando il costo reale è il tempo di sviluppo, non la CPU. Scambia la velocità pura per un ciclo di feedback più breve, librerie più ricche e codice che gli esseri umani possano effettivamente leggere.

Come misuriamo questi dati

Mediane relative a 40 migrazioni completate tra il 2023 e il 2026. Throughput misurato a livello di applicazione (p50 end-to-end sotto carico realistico, non microbenchmark). La memoria è RSS in condizioni di stabilità. Il costo è quello mensile del calcolo on-demand su AWS/GCP, a parità di tutte le altre condizioni. I risultati individuali variano: su richiesta pubblichiamo anche quelli che non sono andati secondo i piani.

04 Cifre senza asterischi

Richieste al secondo sotto carico reale.

Carico di lavoro identico — convalida JSON → query Postgres → rendering — misurato su un singolo sistema AMD Ryzen 7. Questi non sono microbenchmark. Fonte e metodologia ↓

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

Leggete bene: Python è quasi in fondo a questo grafico, e va bene così. Non eseguiamo FastAPI sul percorso principale. Lo eseguiamo dove 1.185 richieste al secondo sono già circa 10 volte superiori al carico di lavoro richiesto, e le ore di lavoro degli ingegneri valgono più dei cicli di CPU. Metodologia: AMD Ryzen 7, Linux, Docker, istanza singola, un framework popolare per ogni linguaggio. I numeri sono medie ottenute da più esecuzioni.

05 Il costo reale di un codice difettoso

Quanto ti costa effettivamente un'interruzione del servizio.

"Cinque nove" non è solo marketing. Di seguito è riportato quanto costa un'ora di inattività non pianificata, per settore — con le fonti. Noi sviluppiamo Rust proprio dove risiedono questi numeri.

Costo accumulato da quando hai aperto questa sezione
Finanza / sanità 0 ~83.000 $/min · 5 milioni di $/ora
Settore automobilistico $0 ~38.000 $/min · 2,3 milioni di $/ora
Grandi imprese 0 23.750 $/min · 1,4 milioni di $/ora
Media impresa 0 ~5.000 $/min · 300.000 $/ora
Finanza e sanità 5 milioni di dollari o più all'ora

I settori verticali più a rischio. Piattaforme di trading, sistemi di regolamento e sistemi clinici possono superare i 5 milioni di dollari all'ora durante un grave guasto, prima ancora di calcolare eventuali costi normativi o legali.

Fonte: Studio Gartner 2024 sulle aziende Fortune 500; ITIC 2024 Costo orario dei tempi di inattività.
Produzione automobilistica 2,3 milioni di dollari all'ora

Una linea di produzione ferma costa circa 640 dollari al secondo. L'interruzione di CrowdStrike nel luglio 2024 è costata alla sola Delta Air Lines 380 milioni di dollari in cinque giorni.

Fonte: Erwood Group, ripartizione settoriale 2025; Antithesis, analisi post-incidente CrowdStrike.
Grandi imprese (media) 1,4 milioni di dollari all'ora

Dato di BigPanda del 2024 sulle grandi imprese: 23.750 dollari al minuto. L'ITIC riferisce che il 41% delle grandi imprese perde tra 1 e 5 milioni di dollari all'ora di interruzione.

Fonte: Ricerca BigPanda 2024; 11° rapporto annuale ITIC sul costo orario dei tempi di inattività.
Global 2000 (Oxford Economics) 400 miliardi di dollari all'anno

Costo nascosto totale dei tempi di inattività non pianificati nelle 2.000 aziende più grandi del mondo, secondo lo studio di Oxford Economics del 2024 — con un impatto medio di 200 milioni di dollari per azienda sommando ricavi, produttività e costi di riparazione.

Fonte: Oxford Economics 2024, “I costi nascosti dei tempi di inattività”.
Medie e grandi imprese (ora tipica) 300.000+ dollari / ora

Sondaggio ITIC del 2024: oltre il 90% delle medie e grandi imprese ora valuta una singola ora di downtime non pianificato al di sopra di questa soglia — escluse le sanzioni legali, civili o normative.

Fonte: Rapporto ITIC 2024 sul costo orario dei tempi di inattività.
Piccole e medie imprese (PMI) 25.000–150.000 $ / ora

Lo studio congiunto ITIC / Calyptix del 2025 rileva che molte PMI perdono questa cifra all'ora; Siemens riferisce che le PMI colpite da interruzioni possono arrivare a 150.000 dollari all'ora. Un'interruzione dura in media 87 minuti.

Fonte: ITIC + Calyptix 2025; Siemens True Cost of Downtime 2024.
06 Lavori selezionati

Tre progetti. Tre sfide diverse.

Anonimizzati dove previsto dall'accordo di riservatezza, specifici dove lo consentono i risultati. Questi sono gli incarichi che mostreremmo per primi a un acquirente tecnico.

  1. Caso 01 Python Database Criptovalute GDPR

    Data vault fintech: 4 volte più piccolo, 5,5 volte più veloce, conforme agli standard globali.

    Il cliente gestiva un cluster Postgres da 1,8 TB gonfiato da colonne legacy, indici inattivi e BLOB crittografati in linea che si erano accumulati nel corso di sette anni. La crittografia funzionava su una libreria deprecata segnalata in tre audit distinti. L'esposizione normativa era reale; i revisori stavano girando intorno.

    Cosa abbiamo fatto

    • Schema completo + audit dell'utilizzo, eliminazione di colonne e indici inutilizzati, introduzione di un partizionamento adeguato.
    • Migrazione della pipeline di crittografia da una libreria legacy a uno stack AEAD moderno e sottoposto a audit con chiavi a rotazione.
    • Convertire la crittografia BLOB inline in crittografia a busta con riferimento + KMS dedicato.
    • Allineamento dei flussi di conservazione dei dati e di accesso dei soggetti al GDPR, al CCPA e all'APPI.
    Risultato

    Stessi dati, un quarto della spesa per lo storage, una velocità di trasmissione 5,5 volte superiore e un certificato di buona salute per il prossimo regolatore che fosse venuto a bussare alla porta.

  2. Caso 02 Rust C++ → Rust Sicurezza Archiviazione

    Servizio C++ riscritto in Rust: oltre 100 bug di classe CVE eliminati in 9 settimane.

    Servizio di elaborazione file rivolto agli utenti in C++, che andava in crash ogni 4–5 giorni e veniva patchato in loco ogni volta. La nostra verifica ha portato alla luce oltre 100 bug reali: percorsi di denial-of-service , buffer overflow, gestione delle richieste senza limiti. Gli errori 503 nelle ore di picco erano un rituale settimanale. Sul fronte dello storage, i caricamenti degli utenti si erano accumulati in una marea di file duplicati che consumavano il bucket.

    Cosa abbiamo fatto

    • Riscrittura completa in Rust (axum + tokio) con rigorosa convalida degli input e limiti di risorse definiti.
    • Test basati sulle proprietà + cargo-fuzz su ogni parser e confine del formato wire.
    • Livello di archiviazione indirizzato per contenuto con deduplicazione in fase di scrittura.
    • Implementazione blue-green in una finestra di integrazione di 4 ore, senza tempi di inattività.
    Risultato

    Il servizio è passato da "fragile e rattoppato settimanalmente" a "abbiamo smesso di guardare il cercapersone". I costi di archiviazione sono diminuiti grazie alla deduplicazione, i ticket di assistenza relativi a errori e 503 si sono esauriti e la riscrittura si è ripagata entro il trimestre.

  3. Caso 03 Rust Python eBPF / XDP CRM · 4.000 utenti

    CRM aziendale, ricostruito: da 18 server a 5, riduzione dei costi di oltre il 60%.

    CRM interno al servizio di oltre 4.000 utenti tra IAM, SOC, registrazione centralizzata, chat, condivisione file, VoIP e dati crittografati end-to-end. Diciotto server, Cloudflare in aggiunta e una fattura cloud che continuava a crescere indipendentemente dal numero di dipendenti. Abbiamo ricostruito il percorso principale in Rust, mantenendo Python a livello di integrazione e reporting, e abbiamo inserito un filtro eBPF/XDP direttamente davanti all'ingresso.

    Cosa abbiamo fatto

    • Servizi Rust per l'autenticazione (IAM), la messaggistica in tempo reale, la segnalazione VoIP e il trasferimento di file.
    • Python per interfacce amministrative, reportistica, correlazione degli eventi SOC, integrazione con le API dei fornitori.
    • Bot eBPF/XDP e filtraggio degli abusi a livello di kernel — ha sostituito Cloudflare per questo carico di lavoro.
    • Pipeline di logging strutturata riscritta attorno a uno schema zero-copy.
    Risultato

    Tredici server in meno, nessuna voce di spesa per Cloudflare, il team SOC vede un segnale più pulito attraverso la pipeline di logging e il CFO ha smesso di porre domande scomode sul budget dell'infrastruttura.

07 Come lavoriamo realmente

Regolate i parametri. Osservate il piano che cambia.

Ogni progetto bilancia velocità, costo e affidabilità. La stima in cinque fasi riportata di seguito è calibrata rispetto alle medie del settore (fase di scoperta 2–6 settimane, architettura 1–4 settimane, implementazione 4–20 settimane, consolidamento 2–8 settimane, consegna 1–2 settimane — secondo i rapporti 2024–2026 di NIX United, Agilie, SOLTECH, OTG Lab). Spostate i cursori; il piano si ricalibra in tempo reale.

01

Fase di scoperta

3 settimane

Leggi il tuo codice, intervista il tuo team operativo, elenca le incognite, scegli il linguaggio per ogni componente.

  • Interviste di dominio e audit del codice
  • Registro dei rischi e obiettivi SLA
  • Decisione sul linguaggio per ogni servizio
02

Architettura

2 settimane

I contratti prima del codice. OpenAPI / protobuf, modelli di dati, topologia di distribuzione, scheletri di runbook.

  • RFC per ogni appalto pubblico
  • Modello dei dati + piano di migrazione
  • Baseline "Infra-as-code"
03

Implementazione

8 settimane

Piccoli PR, CI verde fin dal primo giorno, distribuzioni ad ogni merge, revisione da parte di un secondo senior.

  • Rust: axum · tonic · sqlx
  • Python: FastAPI · Pydantic · SQLAlchemy
  • Demo settimanali + log delle modifiche
04

Rafforzamento

3 settimane

Fuzzing, test basati sulle proprietà, test di carico su traffico realistico, modello di minaccia.

  • cargo-fuzz · proptest · hypothesis
  • Test di carico k6 collegati agli SLO
  • Revisione della sicurezza e audit delle dipendenze
05

Consegna

1 settimana

Runbook, rotazione dei turni di reperibilità, ADR e un team che ha già rilasciato questo prodotto una volta.

  • Runbook + matrice dei turni di reperibilità
  • Registro ADR e diagrammi dell'architettura
  • Assistenza post-lancio per 30 giorni
08 Stesso problema, due linguaggi

Come appare lo stesso endpoint in ciascuna.

Recupera un utente, convalida l'input, salva su Postgres, restituisci JSON. Passa da una linguaggio all'altro — entrambi sono codice reale che useremmo davvero. 

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 già esistente") from exc
    if row is None:
        raise HTTPException(status_code=500, detail="inserimento fallito")
    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)))
}
Righe di codice
16 22
Throughput
1.185 richieste/s 21.030 richieste/s
Latenza p50
21,0 ms 1,6 ms
RAM inattiva
41,2 MB 8,5 MB
Rispondiamo entro 1 giorno lavorativo. Non scherziamo.

Hai letto tutta la pagina.
Realizziamo il progetto.

Dicci cosa non va nel tuo stack o cosa vuoi costruire da zero. Riceverai un parere tecnico concreto, non una presentazione commerciale.

hello@pwn-all.com Torna all'inizio
  • Nessun ingegnere junior. Nessun offshoring.
  • Opzioni a prezzo fisso su lavori definiti.
  • Accordo di riservatezza firmato prima di chiederti qualsiasi cosa.