R2F0ZS5pbyBBTUEgbWV0IFppZ25hbHktQWxsZSBXaW5zdCwgR2VlbiB2YW4gaGV0IFdlcms=

<p><img src="https://gimg2.gateimg.com/image/article/16848255231.jpg" alt=""><br><strong>Tijd: 22 januari 2022, 13:00 UTC</strong><br><strong><a href="https://www.gate.io" target="_blank">Gate.io</a> hield een AMA (Vraag-Me-Alles) sessie met Bartolome R Bordallo, mede-oprichter &amp; CEO van Zignaly 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://zignaly.com/" rel="nofollow noopener noreferrer" target="_blank">https://zignaly.com/</a></strong><br><strong>Twitter: <a href="https://twitter.com/zignaly" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/zignaly</a></strong><br><strong>Volg Zignaly op <a href="https://t.me/ZignalyHQ" rel="nofollow noopener noreferrer" target="_blank">Telegram</a> en <a href="https://www.facebook.com/zignaly" rel="nofollow noopener noreferrer" target="_blank">Facebook</a></strong><br><strong>Gast</strong><img src="https://gimg2.gateimg.com/image/article/16848257362.png" alt=""><br><strong>Bartolome R Bordallo — Medeoprichter &amp; CEO van Zignaly</strong></p>
<h2 id="h2-Vraag20en20Antwoord20van20Gateio789352"><a name="Vraag en Antwoord van Gate.io" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Vraag en Antwoord van Gate.io</h2><h3 id="h3-Q120Kun20je20ons20een20korte20introductie20geven20van20het20product20en20het20team637574"><a name="Q1: Kun je ons een korte introductie geven van het product en het team?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Kun je ons een korte introductie geven van het product en het team?</h3><p><strong>Tol</strong> Ik ben Bartolome R. Bordallo, medeoprichter en CEO van Zignaly. Ik ben een zelflerende, op data gerichte, seriële ondernemer met al mijn energie gericht op de passieve inkomensrevolutie geleid door Zignaly.com.</p>
<p>Naast mezelf hebben we 2 medeoprichters bij Zignaly.</p>
<p>David Rodriguez - een oude vriend en een gepassioneerde ondernemer, met wie ik twee succesvolle bedrijven heb opgericht. Hij zorgt voor alles op het gebied van marketing en data bij Zignaly. Hij helpt vooral met de gegevens om de meest rationele belangrijke zakelijke beslissingen te nemen.</p>
<p>Abdul Rafay Gadit, onze medeoprichter is een voormalig bankier met een succesvolle staat van dienst in het starten en grootschalig uitbreiden van verschillende bedrijven die actief zijn in verschillende sectoren. Bij Zignaly houdt hij zich bezig met financiën en bedrijfsontwikkeling.</p>
<p>Het is belangrijk om het zeer gepassioneerde en energieke team van meer dan 30 mensen bij Zignaly te vermelden, dat opereert vanuit 11 verschillende landen. Bij Zignaly houden we ons hoofd naar beneden en bouwen we.</p>
<p>Over het product:<br>Het Zignaly-platform en de marktplaats verbinden alledaagse consumenten met ‘s werelds beste, bewezen crypto-investeerders in een vertrouwd, gefaciliteerd systeem dat consumenten in staat stelt om de expertise, hefboomwerking en schaal van top handelaren en fondsen te benutten die hun handel behandelen – in ruil voor een deel van de gedeelde winsten. Voor professionele handelaren en fondsen biedt Zignaly ongekende toegang tot nieuwe bronnen van fondsen &amp; volgers, als schaalbaar kapitaal voor aanzienlijk hoger winstpotentieel. Op dit moment bedienen meer dan 300 professionele handelaren meer dan 400.000 gebruikers die meer dan USD125M hebben toegewezen aan crypto-activa.</p>
<p>Zignaly ondergaat nu zijn grootste transformatie ooit met de ZignalyDAO (Zignaly wordt volledig gedecentraliseerd), wat volgens ons niets minder is dan een sociale beleggingsrevolutie - ons doel is simpel: ‘Iedereen, overal ter wereld, in staat stellen om gelijke toegang te hebben tot dezelfde soorten door experts beheerde, passieve beleggingsmogelijkheden die voorheen alleen beschikbaar waren voor de top 1%.’</p>
<h3 id="h3-Q220Kun20je20ons20iets20vertellen20over20de20doelen20van20het20project20en20wat20je20tot20nu20toe20hebt20bereikt836499"><a name="Q2: Kun je ons iets vertellen over de doelen van het project en wat je tot nu toe hebt bereikt?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Kun je ons iets vertellen over de doelen van het project en wat je tot nu toe hebt bereikt?</h3><p><strong>Tole</strong>: Dus ik heb ons doel voor de toekomst genoemd, maar er zijn al veel doelen die we al hebben bereikt.</p>
<p>Zignaly heeft zeker een lange weg afgelegd, maar er is nog veel te doen. We danken onze 430.000 en groeiende Zignaly-gebruikers die ons hebben toevertrouwd als hun one-stop Crypto Investment management oplossing.</p>
<p>Gesteund door uw geloof in het Zignaly ecosysteem, en nog belangrijker, uw feedback, zijn we tot zover gekomen. Onze gebruikers hebben meer dan $125 miljoen geïnvesteerd bij onze top-expert traders, die erin geslaagd zijn rendementen te behalen van meer dan 700% alleen al dit jaar.</p>
<p>Afgezien daarvan hebben we 22 verschillende kluisjes geïntroduceerd onder de kluis 2.0 van Zignaly, waarbij meer dan $1,2 miljoen aan stakingbeloningen wordt verdeeld, dit sluit perfect aan bij onze “Passive income revolution”. We hebben ook geholpen bij de financiering van 3 IDO-projecten door een half miljoen dollar op te halen en een overinschrijving van 3000% op de ZIGPad. Tijdens onze reis zijn we erkend door Binance als een van hun topmakelaarspartners en door Bitmex als hun vertrouwde handelspartners, naast dekking door topmedia zoals Yahoo Finance, coindesk, Investing.com en anderen. Maar we zijn hier pas net begonnen.</p>
<p>Net zoals onze evolutie van signaalproviderplatform naar winstdelende marktplaats naast de ZIGPad en vaults, blijven we werken aan onze grootste transformatie tot nu toe - ZignalyDAO</p>
<p>Het is een frisse benadering van investeringen en passief inkomen, die zich uitbreidt naar de wereld van DeFi.</p>
<p>Het idee is om investeerders en handelaren in staat te stellen de barrières voor crypto-investeringen te doorbreken. De ZIG-munt zal een cruciale rol spelen in het zich ontwikkelende Zignaly-ecosysteem.</p>
<p>Om uw vraag te beantwoorden, zullen we blijven bouwen en economische gelijkheid voor iedereen ter wereld herdefiniëren, en om dat te meten, hebben we zeer duidelijke doelstellingen voor de ZignalyDAO opgesteld: ‘$10 miljard TVL en 100 miljoen+ transacties per maand, met een doorvoer van 30% inkomsten tegen het vierde kwartaal van 2023’</p>
<p>We zijn klaar en toegewijd om onze doelen te bereiken.</p>
<h3 id="h3-Q320Er20was20ook20gisteren20een20aankondiging20van20de20ZignalyDAO2020We20zijn20benieuwd20waarom20DAO20Wat20is20de20motivatie20erachter701581"><a name="Q3: Er was ook gisteren een aankondiging van de ZignalyDAO - We zijn benieuwd waarom DAO? Wat is de motivatie erachter?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Er was ook gisteren een aankondiging van de ZignalyDAO - We zijn benieuwd waarom DAO? Wat is de motivatie erachter?</h3><p><strong>Tole</strong>: Interessante vraag, Tom!</p>
<p>Waarom DAO? Bij Zignaly geloven we niet in grenzen, en een gedecentraliseerd model opent deuren voor eindeloze mogelijkheden. Waarom vasthouden aan alleen handelen wanneer expert fondsbeheerders je kunnen helpen het beste rendement te behalen, een klapper te maken op NFT’s of winst te behalen op die s&amp;p500 synthetica?</p>
<p>Dit is allemaal haalbaar alleen als we Defi gaan, en hier zijn we, nemen onze eerste stap naar onze visie om grenzen te verwijderen uit uw beleggingsportefeuille. Zoals ik eerder al zei, is ons op DAO gebaseerde model niet alleen een nieuw product of een update, het is niets minder dan een passieve inkomensrevolutie die de barrières voor crypto-investeringen zal wegnemen.</p>
<p>Bovendien hebben we altijd serieus naar communityfeedback geluisterd, zodanig dat de meeste van onze producten grondig worden gescreend en getest door onze powergebruikers voordat ze bij de community terechtkomen. Ten tweede stond door de community gedreven governance altijd centraal in onze strategie, sinds de lancering van de ZIG coin.</p>
<p>Met de DAO stellen we ZIG-houders echt in staat met governance en echte eigendom dat ze verdienen.</p>
<p>Natuurlijk zal de ZIG-munt het middelpunt vormen, blijf afgestemd op onze sociale media om meer te weten te komen over de werking.</p>
<h3 id="h3-Q420Hoe20zal20investeren20via20ZignalyDAO20verschillen20van20investeren20via20een20gedecentraliseerde20of20gecentraliseerde20exchange270591"><a name="Q4: Hoe zal investeren via ZignalyDAO verschillen van investeren via een gedecentraliseerde of gecentraliseerde exchange?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Hoe zal investeren via ZignalyDAO verschillen van investeren via een gedecentraliseerde of gecentraliseerde exchange?</h3><p><strong>Toel</strong>: We zien voor ons dat we het platform zijn met de grote groene ‘Investeer’ knop</p>
<p>Eerlijk gezegd is dat alles wat een uitwisseling niet is. Bij ZignalyDAO willen we complexiteiten wegnemen en investeringen omzetten in een ‘naadloze ervaring’.</p>
<p>Om te beginnen vind je geen professionele handelaren op beurzen (vooral niet op DEXs) met bewezen trackrecords en een georganiseerde marktplaats voor het delen van winst. Zignaly draait echter helemaal om het benutten van de expertise van deze professionele handelaren in ruil voor een deel van de gedeelde winsten. Terwijl er iemand is die uw financiële belangen behartigt bij Zignaly, staat u er alleen voor op de beurzen, waar de sterksten overleven en de zwakken geliquideerd worden. Ondertussen leiden de sterksten bij Zignaly, terwijl degenen die niet goed thuis zijn in investeringen hen volgen.</p>
<p>Eén raamsoplossing voor al uw investeringsbehoeften - Terwijl beurzen tegemoetkomen aan de behoefte van gebruikers om tokens te verhandelen/ruilen of liquiditeit aan pools toe te voegen - gaat Zignaly verder dan dat. Of het nu gaat om portefeuillebeheer via onze winstdelingsmarkt, staking op zignaly vault, NFT-witlistverlotingen, of investeren in IDO’s op de ZIGPad, wij dekken alles, met de ZIG-token die onze producten versterkt.</p>
<p>Meld je aan op verschillende platforms of slechts op één; Zignaly.com - het is de keuze van de gebruiker. Met de DAO breiden we uit en denken we zonder beperkingen in zicht - verwacht meer activaklassen, beleggingsmogelijkheden en nog veel meer. De ideologie blijft hetzelfde, maar het bereik wordt uitgebreid naar meer activa en is niet langer beperkt tot handel.</p>
<p>Top notch beveiliging - in tegenstelling tot specifieke DEXs, is Zignaly een volledig beveiligd en beschermd platform. We hebben meerdere lagen van beveiliging. Het is een eerlijk en rechtvaardig platform dat voldoet aan al uw investeringsbehoeften van begin tot eind.</p>
<p>Community-gedreven aanpak - Onze gemeenschap is ons belangrijkste bezit. Zignaly is niet alleen een platform, het is een groep van meer dan 430.000 mensen met één missie - ‘echte financiële vrijheid bereiken’. Met ons DAO-model willen we onze gemeenschap en ZIG-houders echt in staat stellen, waarbij belangrijke zakelijke beslissingen in hun handen worden gelegd, samen met het werkelijke eigendom van het bedrijf. Het gevoel deel uit te maken van een hechte gemeenschap is ongeëvenaard en we begrijpen dat.</p>
<h3 id="h3-V520We20begrijpen20de20cruciale20rol20die20deskundige20handelaren20en20fondsbeheerders20zullen20spelen20bij20ZignalyDAO2020hoe20vertrouwen20uw20potentile20gebruikers20deze20experts20Zijn20er20statistieken20of20feiten20die20hun20prestaties20ondersteunen520576"><a name="V5: We begrijpen de cruciale rol die deskundige handelaren en fondsbeheerders zullen spelen bij ZignalyDAO - hoe vertrouwen uw potentiële gebruikers deze experts? Zijn er statistieken of feiten die hun prestaties ondersteunen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>V5: We begrijpen de cruciale rol die deskundige handelaren en fondsbeheerders zullen spelen bij ZignalyDAO - hoe vertrouwen uw potentiële gebruikers deze experts? Zijn er statistieken of feiten die hun prestaties ondersteunen?</h3><p><strong>Tole</strong>: Dat is een zeer belangrijke vraag en ik ben blij dat je het hebt gevraagd.</p>
<p>Ik herinner me niet dat ik dit heb beantwoord in andere interviews / AMAs.</p>
<p>Om dat te beantwoorden, laat me eerst zeggen dat bij Zignaly risicobeheer boven en buiten de ‘rendementen’ komt die een handelaar kan genereren.</p>
<p>Bij het vermelden van een nieuwe handelaar/dienst beoordelen we het prestatieniveau vanuit meerdere perspectieven en onze hoogste prioriteit is hoe goed ze het risico beheren. Onze gebruikers vertrouwen ons hun investeringsfondsen toe en het spreekt voor zich dat de verantwoordelijkheid om de best mogelijke due diligence uit te voeren bij ons ligt. Hier is hoe we onze handelaren beoordelen: <a href="https://medium.com/zignaly/risk-managers-not-gamblers-f0c14ef36c1f" rel="nofollow noopener noreferrer" target="_blank">https://medium.com/zignaly/risk-managers-not-gamblers-f0c14ef36c1f</a></p>
<p>Zoals je kunt zien, gaan onze richtlijnen voor servicevermelding allemaal over risicobeheer. Wat betreft vermogensbewaring is Zignaly momenteel een volledig niet-custodiaal platform op basis van het Binance-makelaarsprogramma. In simpelere woorden, een zignaly-uitwisselingsaccount is net zo goed als een Binance-account en de fondsen die je toewijst aan handelaren zijn niet door hen opvraagbaar. Wat betreft ZignalyDAO, we zullen binnenkort onze beveiligingsplannen delen, wees gerust dat de veiligheid van gebruikersactiva onze topprioriteit blijft.</p>
<p>Ten tweede en het belangrijkste:<br>Onder ons winstdelingsmodel krijgt de handelaar geen betaald tenzij ze presteren.</p>
<p>Ze verdienen geld voor zichzelf, zo simpel is het.</p>
<p>Vergeet ook niet dat onze deskundige handelaren verplicht zijn om hun eigen geld in hun dienst te steken, dus ze hebben er belang bij. Niet te vergeten dat we Profit-sharing 2.0 uitrollen om de zignaly-investeringservaring verder te verbeteren.<br><img src="https://gimg2.gateimg.com/image/article/16848257473.jpg" alt=""><br>Ik begrijp dat louter woorden zonder ondersteunende gegevens nutteloos zijn, dus hier gaat het: Dus hier is de prestatie van onze toptrader van juni ‘21 tot juni ‘22 Van ~300% tot bijna ~800%, allemaal terwijl <a href="/price/bitcoin-btc" rel="nofollow noopener noreferrer" target="_blank">Bitcoin</a> gedaald met ~40% na een stijging van 100%, dat is een risicobeheer van wereldklasse van onze handelaren.</p>
<div class="blog-details-info"><br><div>Auteur: <strong>Rio Fu.</strong>, Gate.io Community<br><div class="info-tips"><em>Dit artikel vertegenwoordigt alleen de mening van de onderzoeker en vormt geen enkele beleggingssuggestie.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel is toegestaan op voorwaarde dat Gate.io wordt vermeld. In alle glen zullen juridische stappen worden ondernomen wegens schending van het auteursrecht.<br></div><p></p><br></div></div></div>