Che cos'è lo sviluppo multipiattaforma?

Lo sviluppo multipiattaforma è un modo di costruire un’app da un’unica codebase condivisa che gira su più piattaforme – iOS, Android, web, desktop. Lo slogan è “write once, run anywhere”; la realtà aggiunge “write once, debug everywhere”. Eppure l’intera conversazione sul tema, da una guida ben posizionata all’altra, tratta il multipiattaforma come una questione di frontend – quale framework UI scegliere. Questa voce aggiunge la parte che tutte saltano: il guadagno di riuso del codice più grande e più affidabile non è la UI, è un backend condiviso – e quel guadagno è disponibile anche per le app completamente native.

Punti chiave

Lo stesso backend, per ogni frontend

// JavaScript / React Native / web — Back4app JS SDK
// The SAME backend call, whatever the frontend framework
const query = new Parse.Query('Task');
query.equalTo('done', false);
const tasks = await query.find();
// This exact query runs from React Native, a web SPA, or Node —
// because the backend is written ONCE and every client shares it.

// Flutter / Dart — Back4app Flutter SDK
// Same data, same auth, same rules — a different frontend framework
final tasks = await QueryBuilder<ParseObject>(ParseObject('Task'))
    .whereEqualTo('done', false)
    .query();
// The Flutter app and the native iOS app can differ entirely on the frontend
// and still share ONE backend — the cross-platform win nobody talks about.

// iOS / Swift (native) — Back4app Swift SDK
// A fully NATIVE iOS app — still cross-platform at the backend layer
let tasks = try await Task_.query("done" == false).find()
// Native iOS + native Android + web can each pick their own UI stack
// and share the identical backend API — write the backend once.

// Android / Kotlin (native) — Back4app Android SDK
// A fully NATIVE Android app — still cross-platform at the backend layer
val tasks = ParseQuery.getQuery<ParseObject>("Task")
    .whereEqualTo("done", false)
    .find()
// Native iOS + native Android + web can each pick their own UI stack
// and share the identical backend API — write the backend once.

Quattro frontend diversi – una web app in JS, Flutter, Swift nativo, Kotlin nativo – e una sola query, perché parlano tutti con lo stesso backend. È l’architettura che i risultati di ricerca non disegnano mai: frontend multipiattaforma (o perfino frontend nativi) + un unico backend condiviso. Il framework frontend è una decisione vera con trade-off veri; il riuso del backend è quasi gratuito e quasi universale.

I tre approcci frontend

La tassonomia che la maggior parte delle guide confonde: un framework compilato disegna ogni pixel da sé (coerente ovunque, veloce come il nativo); un framework a bridge nativo chiede al sistema operativo di disegnare i propri widget (aspetto nativo per piattaforma); un’app WebView/ibrida renderizza HTML in un involucro (un sito web travestito da app). “Multipiattaforma” indica di solito le prime due; “ibrido” la terza – e la differenza sta esattamente in che cosa gira: vero codice nativo o un motore di browser.

Nativo vs. multipiattaforma, onestamente

L’ultima riga è tutto il senso di questo articolo. La scelta del frontend è un vero trade-off tra UX e prestazioni, da prendere con cognizione di causa – ma qualunque sia il lato scelto, il backend si scrive una volta sola ed è condiviso da tutti i client. Il che significa che il riuso più difficile e più prezioso dello sviluppo multipiattaforma è quello che nessuno presenta come multipiattaforma.

Come il backend diventa multipiattaforma: SDK e un’API

Il meccanismo è a due livelli. Un backend espone un’API neutra rispetto alla piattaforma – REST e GraphQL parlano JSON con qualsiasi cosa – e, sopra di essa, SDK per piattaforma che avvolgono l’API negli idiomi di ciascun linguaggio: un SDK Swift per iOS, Kotlin per Android, JavaScript per web e React Native, Dart per Flutter. Ogni SDK è un client sottile sopra gli stessi endpoint, così il modello dei dati, l’autenticazione, i permessi e la logica di business vivono una sola volta sul server e ogni frontend li eredita. È per questo che un BaaS è il backend naturale per il lavoro multipiattaforma: è il backend condiviso, con gli SDK già scritti. Una PWA è semplicemente un’altra via di distribuzione multipiattaforma – un’unica web app installabile su tutte le piattaforme – che parla con quello stesso backend.

Casi d’uso comuni

• Startup e MVP – coprire iOS e Android con un solo team e un solo calendario.
• App di contenuti e di business – UI standard dove il 90 % di codice riusato è puro risparmio.
• Suite di prodotti multipiattaforma – client mobile, web e desktop sopra un unico backend.
• App native che condividono comunque un backend – frontend a prestazioni massime, un’unica API dietro.
• PWA più nativo – la copertura del web e la profondità del nativo, con lo stesso backend.

Conviene passare al multipiattaforma? Matrice decisionale

Limiti e trade-off

• Il ritardo dei framework frontend. Le novità del sistema operativo arrivano prima nel nativo; i framework multipiattaforma seguono – un costo reale per le app che devono adottarle dal primo giorno.
• Gli ultimi punti percentuali di prestazioni. Le app ad alta intensità grafica e in tempo reale sentono il divario dal nativo; la maggior parte delle app non lo sente mai.
• Le convenzioni UX affiorano. Gesti e pattern specifici per piattaforma richiedono attenzione per piattaforma anche nel codice UI “condiviso”.
• Dimensione dell’app e dipendenze. I runtime multipiattaforma aggiungono peso e una dipendenza mantenuta dalla community che non si controlla.
• Niente di tutto questo tocca il backend. Ogni limite qui sopra è un limite frontend; il guadagno del backend condiviso resta intatto, ed è per questo che è la scommessa sicura in una decisione frontend incerta.

Lo sviluppo multipiattaforma su Back4app

Back4app è una piattaforma open-source di Backend as a Service (BaaS) che combina database gestito, API REST e GraphQL generate automaticamente, autenticazione, archiviazione di file e funzioni serverless con Cloud Code. È la metà “backend condiviso” di questo articolo resa concreta: Back4app fornisce SDK per Flutter, React Native, iOS (Swift), Android (Kotlin) e JavaScript sopra un’unica API REST/GraphQL, così – come mostrano le schede di codice – la stessa query, la stessa autenticazione e le stesse regole ACL servono ogni client, sia che il frontend sia un’unica codebase multipiattaforma o quattro codebase native separate. La decisione sul frontend resta in mano a chi sviluppa, su criteri di UX e prestazioni; il backend si scrive una volta sola in ogni caso, ed è il guadagno multipiattaforma che vale di più e di cui si parla di meno.