R2F0ZS5pbyBBTUEgbWV0IE1lYW5GaS1CZWhlZXIgdXcgc2NoYXRraXN0IG1ldCByZWFsdGltZSBmaW5hbmNpw6tu

<p><img src="https://gimg2.gateimg.com/image/article/16849069751.jpg" alt=""><br><strong>Tijd: 27 januari 2022, 13:00 UTC</strong><br><strong><a href="https://www.gate.io" target="_blank">Gate.io</a> organiseerde een AMA (Ask-Me-Anything) sessie met Michel Triana, CEO van MeanFi in de <a href="https://t.me/gateio" rel="nofollow noopener noreferrer" target="_blank">Gate.io Exchange Gemeenschap</a>.</strong><br><strong>Officiële Website: <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>Volg MeanFi op <a href="https://twitter.com/meanfinance" rel="nofollow noopener noreferrer" target="_blank">Twitter</a> en <a href="https://discord.com/invite/8P4vK6SWz3" rel="nofollow noopener noreferrer" target="_blank">Discord</a></strong><br><strong>Gast</strong><img src="https://gimg2.gateimg.com/image/article/16849071722.png" alt=""><br><strong>Michel Triana — CEO van MeanFi</strong></p>
<h2 id="h2-Vraag20amp20Antwoord20van20Gateio446497"><a name="Vraag &amp; Antwoord van Gate.io" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Vraag &amp; Antwoord van Gate.io</h2><h3 id="h3-V120Kunt20u20ons20uitleggen20wat20MeanFi20is360204"><a name="V1: Kunt u ons uitleggen wat MeanFi is?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>V1: Kunt u ons uitleggen wat MeanFi is?</h3><p><img src="https://gimg2.gateimg.com/image/article/16849072173.png" alt=""><br><strong>Michel</strong>: MeanFi is een toestemmingsloze, vertrouwensloze, censuur-resistente en zelfbewaar crypto bank die dagelijkse werkstromen mogelijk maakt voor particulieren en bedrijven in crypto. En de gemakkelijkste manier om te beginnen met je crypto-reis.</p>
<h3 id="h3-Q220Ok20klinkt20zeker20spannend2020en20erg20nuttig20Maar20wat20is20de20geheime20saus20die20MeanFi20zo20speciaal20maakt458422"><a name="Q2: Ok klinkt zeker spannend … en erg nuttig. Maar wat is de geheime saus die MeanFi zo speciaal maakt?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Ok klinkt zeker spannend … en erg nuttig. Maar wat is de geheime saus die MeanFi zo speciaal maakt?</h3><p><strong>Michel</strong>: Onze kerntechnologie is Money Streams, dat een real-time afwikkelingslaag is voor betalingen en betalingsinfrastructuur. Money Streams hebben vele toepassingen, maar enkele van de meer nuttige zijn salarisadministratie en treasury beheer. Met salarisadministratie kunnen mensen hun salaris per seconde ontvangen, in plaats van elke 15 weken, waardoor hun werkkapitaal veel efficiënter is. Met treasury beheer kunnen bedrijven en DAO’s profiteren van vermogensverdelingen en toekomstige inkomsten van hun activa voor maximale kapitaalefficiëntie.</p>
<p>Elk project kan gebruikmaken van Money Streams om elke betalingsstructuur op te bouwen die gebruik kan maken van real-time componenten, zoals het streamen van NFT’s, betaal-per-seconde Media Consumption Apps (denk aan Netflix waar je alleen betaalt voor de seconden die je kijkt), en nog veel meer.</p>
<p>Ze worden allemaal aangedreven door dezelfde kern technologie, namelijk de Mean Protocol Money Streams.</p>
<h3 id="h3-Q320Ok20klinkt20als20een20zeer20uitgebreid20platform20IT20moet20een20robuust20team20erachter20hebben20Wat20is20je20achtergrond20en20vertel20ons20over20het20team351027"><a name="Q3: Ok klinkt als een zeer uitgebreid platform. IT moet een robuust team erachter hebben. Wat is je achtergrond en vertel ons over het team?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Ok klinkt als een zeer uitgebreid platform. IT moet een robuust team erachter hebben. Wat is je achtergrond en vertel ons over het team?</h3><p><strong>Michel</strong> We zijn momenteel een team van 16, allemaal zeer technisch. CEO (ikzelf) en CTO (Eydel) gingen samen naar school voor informatica. Dit is mijn derde onderneming in de crypto-ruimte, mijn eerste was Paymesh helemaal terug in 2011 - dat laat wel een beetje mijn leeftijd zien.</p>
<p>We zijn een wereldwijd team met mensen in bijna elke tijdzone en hebben een bloeiende community van meer dan 70.000 mensen in onze Discord-server met 29 geweldige ambassadeurs die alles beheren voor de DAO-community.</p>
<h3 id="h3-Vraag20420En20waar20ben20je20naar20op20zoek20Wat20is20de20visie20van20Mean20DAO20waarom20besta20je255342"><a name="Vraag 4: En waar ben je naar op zoek? Wat is de visie van Mean DAO, waarom besta je?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Vraag 4: En waar ben je naar op zoek? Wat is de visie van Mean DAO, waarom besta je?</h3><p><strong>Michel</strong> Ons doel is om de financiële gelijkmakers te zijn voor mensen en bedrijven over de hele wereld.</p>
<p>Wij bouwen de tools en technologie die nodig zijn om iedereen dezelfde toegang te geven om financiële onafhankelijkheid te bereiken. We doen dit met een grote nadruk op onderwijs en gebruikerservaring, zodat iedereen, van de niet-gebankierden tot geavanceerde instellingen, onze tools en producten kan benutten met dezelfde voordelen.</p>
<p>Voor het eerst kunt u nu van GEEN bank hebben naar een account hebben met duizenden tokens in een kwestie van minuten. Geen ID vereist, aangezien alles zelfbewarend en toestemmingsloos is.</p>
<p>Je kunt elke token of stablecoin met zeer diepe liquiditeit omwisselen met slechts een paar klikken op meanfi.com.</p>
<p>En zie al je activa, geldstromen, prestaties en meer allemaal onder één dak.</p>
<p>Een betaling voor een overmaking naar een geliefde maken, is net zo eenvoudig als het instellen van een terugkerende overboeking die de andere persoon kan claimen wanneer ze het geld nodig hebben, en het kost 1 minuut om te doen en een fractie van een cent om te voltooien.</p>
<p>Als u een aannemer bent die betaling wil ontvangen voor uw diensten, stel dan eenvoudig een geldstroom in en ontvang betaald terwijl u werkt, of vraag uw klant er een voor u te plannen wanneer de betaling verschuldigd is… Dit alles zonder enige KYC, geen login, pure DeFi zelfbewaring.</p>
<h3 id="h3-Q520Klinkt20eigenlijk20heel20geweldig20Ik20ben20al20een20tijdje20op20zoek20naar20een20oplossing20zoals20deze20Traditionele20banken20zijn20niet20langer20een20goede20oplossing20voor20de20huidige20behoeften20van20de20wereld20Echt20een20spannend20product496213"><a name="Q5: Klinkt eigenlijk heel geweldig… Ik ben al een tijdje op zoek naar een oplossing zoals deze. Traditionele banken zijn niet langer een goede oplossing voor de huidige behoeften van de wereld. Echt een spannend product!" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Klinkt eigenlijk heel geweldig… Ik ben al een tijdje op zoek naar een oplossing zoals deze. Traditionele banken zijn niet langer een goede oplossing voor de huidige behoeften van de wereld. Echt een spannend product!</h3><p><img src="https://gimg2.gateimg.com/image/article/16849071914.png" alt=""><br><strong>Michel</strong>: Als u een bedrijf bent en de loonlijst voor uw werknemers wilt instellen, is het eenvoudig om een loonschatkist te maken, de adressen van uw werknemers toe te voegen en voor elk van hen één geldstroom te starten tegen verschillende tarieven en mogelijk met verschillende tokens als u dat wilt… Ze krijgen hun salaris in realtime op hun rekening te zien. Welkom aan boord! <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>Auteur:<strong> Rio Fu.</strong>, Gate.io Gemeenschap<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de opvattingen van de onderzoeker en vormt geen enkele beleggingssuggestie.<br></em><div><em></em>Gate.io behoudt zich alle rechten op dit artikel voor. Herplaatsing van het artikel is toegestaan, op voorwaarde dat Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen vanwege inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div>