R2F0ZS5pbyBBTUEgY29uIE1lYW5GaS1HZXN0aXNjaSBpbCB0dW8gdGVzb3JvIGNvbiBmaW5hbnphIGluIHRlbXBvIHJlYWxl

<p><img src="https://gimg2.gateimg.com/image/article/16849069751.jpg" alt=""><br><strong>Ora: 27 gennaio 2022, 13:00 UTC</strong><br><strong><a href="https://www.gate.io" target="_blank">Gate.io</a> ha ospitato una sessione AMA (Ask-Me-Anything) con Michel Triana, CEO di MeanFi nel <a href="https://t.me/gateio" rel="nofollow noopener noreferrer" target="_blank">Comunità di scambio Gate.io</a>.</strong><br><strong>Sito Web Ufficiale: <a href="https://meanfi.com/" rel="nofollow noopener noreferrer" target="_blank">https://meanfi.com/</a></strong><br><strong>Twitter: <a href="https://twitter.com/meanfinance" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/meanfinance</a></strong><br><strong>Segui MeanFi su <a href="https://twitter.com/meanfinance" rel="nofollow noopener noreferrer" target="_blank">Twitter</a> e <a href="https://discord.com/invite/8P4vK6SWz3" rel="nofollow noopener noreferrer" target="_blank">Discord</a></strong><br><strong>Ospite</strong><img src="https://gimg2.gateimg.com/image/article/16849071722.png" alt=""><br><strong>Michel Triana — CEO di MeanFi</strong></p>
<h2 id="h2-QampA20da20Gateio799046"><a name="Q&amp;A da Gate.io" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q&amp;A da Gate.io</h2><h3 id="h3-Q120Potresti20spiegarci20cos20MeanFi643155"><a name="Q1: Potresti spiegarci cos’è MeanFi?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Potresti spiegarci cos’è MeanFi?</h3><p><img src="https://gimg2.gateimg.com/image/article/16849072173.png" alt=""><br><strong>Michel</strong> MeanFi è una banca crittografica senza autorizzazioni, senza fiducia, resistente alla censura e auto-custodita che consente flussi di lavoro quotidiani per il commercio al dettaglio e le imprese su crittografia. Ed è il modo più semplice per iniziare il tuo viaggio crittografico.</p>
<h3 id="h3-Q220Ok20sembra20sicuramente20entusiasmante20e20molto20utile20Ma20qual2020la20salsa20segreta20che20rende20MeanFi20speciale503561"><a name="Q2: Ok, sembra sicuramente entusiasmante… e molto utile. Ma qual è la salsa segreta che rende MeanFi speciale?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Ok, sembra sicuramente entusiasmante… e molto utile. Ma qual è la salsa segreta che rende MeanFi speciale?</h3><p><strong>Michel</strong>: La nostra tecnologia principale sono i flussi di denaro, che sono uno strato di regolamento in tempo reale per i pagamenti e le infrastrutture di pagamento. I flussi di denaro hanno molte applicazioni, ma alcune delle più utili sono Paghe e Gestione del Tesoro. Con le Paghe le persone possono ricevere il loro stipendio al secondo, invece di ogni 15 settimane, rendendo il loro capitale lavorativo molto più efficiente. Con la gestione del Tesoro, le aziende e i DAO possono beneficiare dalla distribuzione degli asset e dei guadagni futuri dei loro asset per massima efficienza del capitale.</p>
<p>Qualsiasi progetto può sfruttare Money Streams per costruire qualsiasi struttura di pagamento che può sfruttare componenti in tempo reale, come lo streaming di NFT, app di consumo media a pagamento al secondo (pensa a Netflix dove paghi solo per i secondi che guardi) e molto altro.</p>
<p>Tutti sono alimentati dalla stessa tecnologia di base, che è il Protocollo Mean Money Streams.</p>
<h3 id="h3-Q320Ok20sembra20una20piattaforma20molto20completa20Deve20avere20un20team20robusto20alle20spalle20Qual2020la20tua20formazione20e20raccontaci20del20team306139"><a name="Q3: Ok sembra una piattaforma molto completa. Deve avere un team robusto alle spalle. Qual è la tua formazione e raccontaci del team?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Ok sembra una piattaforma molto completa. Deve avere un team robusto alle spalle. Qual è la tua formazione e raccontaci del team?</h3><p><strong>Michel</strong>: Attualmente siamo un team di 16 persone, tutte altamente tecniche. Il CEO (io stesso) e il CTO (Eydel) hanno studiato insieme informatica. Questo è il mio terzo progetto nello spazio cripto, il primo è stato Paymesh nel lontano 2011 - immagino che questo mostri un po’ la mia età.</p>
<p>Siamo un team globale con persone in quasi ogni fuso orario e abbiamo una comunità fiorente di oltre 70.000 persone nel nostro server Discord con 29 ambasciatori straordinari che gestiscono tutto per la comunità DAO.</p>
<h3 id="h3-Q420E20cosa20stai20cercando20Qual2020la20visione20di20Mean20DAO20perch20esisti744060"><a name="Q4: E cosa stai cercando? Qual è la visione di Mean DAO, perché esisti?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: E cosa stai cercando? Qual è la visione di Mean DAO, perché esisti?</h3><p><strong>Michel</strong> Il nostro obiettivo è essere i livellatori finanziari per le persone e le aziende in tutto il mondo.</p>
<p>Costruiamo gli strumenti e la tecnologia necessari per dare a tutti lo stesso accesso per raggiungere l’indipendenza finanziaria. Lo facciamo con un grande enfasi sull’educazione e sull’esperienza degli utenti, in modo che chiunque, dalle persone non bancarizzate alle istituzioni sofisticate, possa sfruttare i nostri strumenti e prodotti con gli stessi vantaggi.</p>
<p>Per la prima volta ora puoi passare da NON-avere una banca ad avere un conto con migliaia di token in pochi minuti. Non è richiesto un ID, poiché tutto è autogestito e senza autorizzazioni.</p>
<p>Puoi scambiare qualsiasi token o stabile con una liquidità molto profonda con solo un paio di clic su meanfi.com.</p>
<p>E vedi i tuoi asset, flussi di denaro, performance e altro, tutto sotto lo stesso tetto.</p>
<p>Effettuare un pagamento di trasferimento a una persona cara è facile come impostare un trasferimento ricorrente che l’altra persona può richiedere quando ha bisogno di denaro, e ci vogliono solo 1 minuto per farlo e frazioni di centesimo per completarlo.</p>
<p>Se sei un appaltatore che desidera ricevere il pagamento per i tuoi servizi, basta impostare un flusso di denaro e ricevere il pagamento mentre lavori, o chiedi al tuo cliente di pianificarne uno per te quando è dovuto il pagamento… tutto questo senza KYC, senza login, pura autogestione DeFi.</p>
<h3 id="h3-Q520Sembra20davvero20incredibile20Ho20cercato20una20soluzione20del20genere20da20un20po20di20tempo20Le20banche20tradizionali20non20sono20pi20una20buona20soluzione20per20le20esigenze20del20mondo20attuale20Davvero20un20prodotto20entusiasmante931303"><a name="Q5: Sembra davvero incredibile… Ho cercato una soluzione del genere da un po’ di tempo. Le banche tradizionali non sono più una buona soluzione per le esigenze del mondo attuale. Davvero un prodotto entusiasmante!" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Sembra davvero incredibile… Ho cercato una soluzione del genere da un po’ di tempo. Le banche tradizionali non sono più una buona soluzione per le esigenze del mondo attuale. Davvero un prodotto entusiasmante!</h3><p><img src="https://gimg2.gateimg.com/image/article/16849071914.png" alt=""><br><strong>Michel</strong>: Se sei un’azienda e vuoi impostare la pa…re e iniziare un flusso di denaro per ciascuno a tariffe diverse e potenzialmente con token diversi se lo desideri… potranno vedere il loro stipendio arrivare in tempo reale sul loro conto. Benvenuti a bordo! <a href="https://app.MeanFi.com" rel="nofollow noopener noreferrer" target="_blank">https://app.MeanFi.com</a></p>
<div class="blog-details-info"><br><div>Autore: <strong>Rio Fu.</strong>, Comunità di Gate.io<br><div class="info-tips"><em>Questo articolo rappresenta solo le opinioni del ricercatore e non costituisce alcun suggerimento di investimento.<br></em><div><em></em>Gate.io si riserva tutti i diritti su questo articolo. La ripubblicazione dell'articolo sarà consentita a condizione che si faccia riferimento a Gate.io. In tutti i casi, verranno intraprese azioni legali a causa di violazione del copyright.<br></div><p></p><br></div></div></div>