R2F0ZS5pbyBBTUEgbWV0IFBvbGluYXRlIC0gRWVuIG5pZXV3ZSBtYW5pZXIgb20gZ2FtZXMsIGdpbGRlbiwgZmluYW5jaWVyaW5nIGVuIGdhbWVycyBtZXQgZWxrYWFyIHRlIHZlcmJpbmRlbg==

<p><img src="https://gimg2.gateimg.com/image/article/16896751541.jpg" alt=""><br><strong>Tijd: 8 november 2021, 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 Babar Shabir, CEO van Polinate en Azeem Khan, COO van Polinate 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://www.polinate.io/" rel="nofollow noopener noreferrer" target="_blank">https://www.polinate.io/</a></strong><br><strong>Twitter: <a href="https://twitter.com/polinate_io" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/polinate_io</a></strong><br><strong>Volg Polinate op <a href="https://twitter.com/polinate_io" rel="nofollow noopener noreferrer" target="_blank">Twitter</a> en <a href="https://t.me/polinate" rel="nofollow noopener noreferrer" target="_blank">Telegram</a></strong><br><strong>Gast</strong><img src="https://gimg2.gateimg.com/image/article/16896753392.png" alt=""><br><strong>Babar Shabir - CEO van Polinate</strong></p>
<h2 id="h2-QampA20van20Gateio599667"><a name="Q&amp;A van Gate.io" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q&amp;A van Gate.io</h2><h3 id="h3-Q120Kun20je20jezelf20en20Polinate20kort20voorstellen20en20waar20komt20de20projectnaam20vandaan20Wat20betekent20het20voor20jou20En20waarom20heb20je20deze20naam20voor20je20project20gekozen20Wat20is20je20missie20en20visie20om20dit20project20te20bouwen20Wat20wil20je20in20de20toekomst20bereiken20met20je20project295467"><a name="Q1: Kun je jezelf en Polinate kort voorstellen? en waar komt de projectnaam vandaan? Wat betekent het voor jou? En waarom heb je deze naam voor je project gekozen? Wat is je missie en visie om dit project te bouwen? Wat wil je in de toekomst bereiken met je project?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Kun je jezelf en Polinate kort voorstellen? en waar komt de projectnaam vandaan? Wat betekent het voor jou? En waarom heb je deze naam voor je project gekozen? Wat is je missie en visie om dit project te bouwen? Wat wil je in de toekomst bereiken met je project?</h3><p><strong>Babar</strong>: Ik ben Babar, de CEO en mede-oprichter van Polinate. Ik ben sinds 2017 actief in de cryptowereld en heb tal van projecten geholpen van concept tot markt. Ik heb een uitgebreid netwerk ontwikkeld in de opkomende technologieën, wat heeft geleid tot brede exposure en links op overheids-, zakelijk en professioneel niveau. Enkele voorbeelden hiervan zijn het begeleiden van de FCA bij regelgeving in de cryptowereld in het VK van 2018-2020, het helpen bij de uitbreiding van grote beurzen naar de Europese markt tussen 2018-2019 en het helpen van projecten bij het omzetten van hun ideeën in producten.</p>
<p>Het idee van Polinate werd bedacht tijdens een discussie met <a href="/price/terra-luna" rel="nofollow noopener noreferrer" target="_blank">Terra</a> Terwijl we spraken over de ontdekking van creativiteit, realiseerden we ons dat iedereen zo druk bezig is met het pushen van NFT’s dat er geen echte oplossing is om creativiteit te laten bloeien. Er zijn talloze creatievelingen die onbenut potentieel hebben, alleen omdat ze niet over de sociale of financiële middelen beschikken, zou geen belemmering mogen zijn voor iemand om een kans te krijgen. We wilden echter Polinate niet beperken tot alleen de ontdekking van creativiteit en Azeem, afkomstig uit de entertainment- en creatieve industrie, bracht het onderwerp ter sprake van de moeilijkheden van mensen in de entertainmentsector, zoals het hebben van rechten op hun intellectueel eigendom, masters en dergelijke, en dat is wanneer het concept van Polinate als geheel samenkwam en werd wat het vandaag de dag is.</p>
<p><strong>Azeem</strong>: Hallo allemaal, ik ben Azeem. Ik ben medeoprichter en CCO van Polinate.</p>
<p>Ik ben min of meer als grap in de cryptowereld terechtgekomen in 2014 toen ik probeerde Kim Coindashian te lanceren. Het bleek de vroegste voorloper te zijn van vermeldingen van Social Tokens tot nu toe en het heeft me zeker geïnteresseerd gemaakt in de ruimte. Het enige wat ik destijds echt deed, was een landingspagina maken, een logo laten ontwerpen en een Twitter-account aanmaken. We kregen enorme aandacht van de pers met dekking in Newsweek, CryptoCoin News, Daily Dot, The Escapist en Crikey, onder anderen. Sindsdien ben ik nieuwsgierig naar hoe de kruising van entertainment en crypto eruit zou zien.</p>
<p>Voorafgaand aan dit alles bracht ik tijd door in de sport- en entertainmentindustrie, meestal in de buurt van voornamelijk hiphopmensen. Ik leverde jarenlang een bijdrage aan de Huffington Post en begon geweldige relaties op te bouwen in de ruimte. Enkele van de mensen die ik heb geïnterviewd waren Mark Cuban, Big Sean, Bun B, Talib Kweli, Jermaine Dupri, TI, DJ Drama en meer.</p>
<p>Daarna heb ik een jaar lang een web/mobiele ontwikkelingswinkel gerund waar we werkten met Kanye West, Teyana Taylor, Rae Sremmurd, Bryson Tiller, enzovoort.</p>
<p>Heb wat tijd doorgebracht na het runnen van een esports-bureau dat mede-opgericht werd door een uitvoerende van Roc Nation, het sport- en entertainmentbedrijf van Jay Z. We waren onze eigen afzonderlijke entiteit maar kregen de kans om met hen samen te werken.<br><img src="https://gimg2.gateimg.com/image/article/16896753593.png" alt=""><br>Daarna heb ik een jaar lang gewerkt als hoofd groei en samenwerkingen bij een mobiel game bedrijf genaamd Aglet, wat lijkt op Pokemon Go voor sneakerheads. Het was een hele reis om hier vandaag te komen.</p>
<h3 id="h3-Q220Zeker20weten20En20hoe20zit20het20met20de20token20zelf20Kun20je20praten20over20tokens20Wat20zijn20de20voordelen20voor20investeerders20bij20het20vasthouden20van20tokens20Wat20zijn20de20gebruiksmogelijkheden697205"><a name="Q2: Zeker weten! En hoe zit het met de token zelf… Kun je praten over tokens? Wat zijn de voordelen voor investeerders bij het vasthouden van tokens? Wat zijn de gebruiksmogelijkheden?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Zeker weten! En hoe zit het met de token zelf… Kun je praten over tokens? Wat zijn de voordelen voor investeerders bij het vasthouden van tokens? Wat zijn de gebruiksmogelijkheden?</h3><p><strong>Babar</strong>: De POLI-token is een integraal onderdeel van het ecosysteem waarmee gebruikers kunnen genieten van de talrijke voordelen ervan, deelnemen aan verschillende functies en beloningen verdienen voor deelname. De waarde ervan komt voort uit het bieden van een handige en veilige betaal- en afwikkelingsmethode tussen verschillende deelnemers van het Polinate-netwerk.</p>
<p>De omvang van de beloning hangt af van de geïnvesteerde waarde of de hoeveelheid POLI-tokens die in het ecosysteem zijn gestoken. De tokens worden ook gebruikt als economische prikkels om deelnemers aan te moedigen bij te dragen aan en het netwerk te onderhouden. Het dient als een token voor gebruikers om deel te nemen aan activiteiten om vervolgens te genieten van voordelen, privileges en lidmaatschappen. Daarnaast groeit de waarde van de POLI-token ook door het te gebruiken als liquiditeitspaar voor pTKN.</p>
<p>De deelnemers van Polinate, zoals gebruikers en makers, kunnen ook hun tokens vergrendelen om toegang te krijgen tot lidmaatschapstiers en vervolgens beloningen met betrekking tot verschillende tiers. Het zal tokenhouders in staat stellen om vroeg of beperkt toegang te krijgen tot verschillende tokenpools voor beloninguitgifte, evenals willekeurige airdrops van makers in het Polinate-ecosysteem.</p>
<p>POLI-tokens worden gebruikt voor de financiering van verschillende projecten en voor het “Polinate Seeders Programme”. Deelnemers van het Polinate-ecosysteem die digitale activa inzetten, projecten promoten of deelnemen aan liquiditeitspools voor projectfinanciering, worden beloond met POLI-tokens, afhankelijk van de bijdrage van de gebruiker. De POLI-token zal ook worden gebruikt in ons stakingsmodel, waarbij de voordelen die je ontvangt (Airdrops) en het niveau van financiering waarin je kunt deelnemen, afhangen van het niveau van lidmaatschap binnen de sociale hive!</p>
<h3 id="h3-Q320En20hoe20zit20het20met20wat20er20komen20gaat20We20horen20graag20wat20meer20over20jullie20aankomende20roadmap20Welke20belangrijke20functies20ontwikkelen20jullie132465"><a name="Q3: En hoe zit het met wat er komen gaat? We horen graag wat meer over jullie aankomende roadmap. Welke belangrijke functies ontwikkelen jullie?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: En hoe zit het met wat er komen gaat? We horen graag wat meer over jullie aankomende roadmap. Welke belangrijke functies ontwikkelen jullie?</h3><p><strong>Babar</strong>: Q3 - Platform V1 Lancering - Voltooid</p>
<ul>
<li>Lidmaatschap is live</li><li>Liquidity Mining live</li><li>V1 van Token als Event-platform lancering</li><li>Mogelijkheid om product te distribueren naar meerdere adressen</li><li>Mogelijkheid om evenementen te zaaien</li></ul>
<p>Q4 - Token als een Event V2 - In Progress</p>
<ul>
<li>Introduceer meerdere verkoopstypes</li><li>Whitelist-integratie</li><li>Integratie van campagne reputatiescore</li><li>KYC/ID-integratie</li><li>Token als een Event V2</li></ul>
<p>Q1 2022 - In Uitvoering</p>
<ul>
<li>On Chain distributie</li><li>On-Chain geschillenbeslechting</li><li>Curatable Campagnes platform</li><li>Iedereen kan maken, platform cureert<br>We werken al een tijdje aan Polinate en hopelijk hebben we niet al te lang na de IDO zelf een product, zodat gebruikers kunnen profiteren van wat we aan het bouwen zijn zonder maanden te hoeven wachten om uiteindelijk de token zelf te kunnen gebruiken.</li></ul>
<h3 id="h3-Q420Welke20functie20van20Polinate20vind20je20het20meest20opvallend449498"><a name="Q4: Welke functie van Polinate vind je het meest opvallend?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Welke functie van Polinate vind je het meest opvallend?</h3><p><strong>Azeem</strong>: Voor mij is het meest opvallende kenmerk hoe eenvoudig het is om te gebruiken. Het product is nu live en het is zo eenvoudig als gewoon naar binnen gaan en een aanvraag schrijven voor wat je wilt lanceren.</p>
<p>Het is niet nodig om een bankrekening of permanent adres te hebben, wat dit allemaal veel sneller maakt dan wat er momenteel op de markt is. Er zijn miljarden mensen over de hele wereld die geen bankrekening hebben of onderbank zijn. Dit is gunstig voor hen. Maar dit werkt ook voor mensen met een grote aanhang.</p>
<p>Bovendien is het bij dit project geweldig dat er adviseurs en andere mensen bij betrokken zijn. Er zijn geen andere projecten die dit op de authentieke manier doen zoals wij dat doen. Als u naar onze lijst kijkt, hebben we meer dan 40 zeer erkende adviseurs uit de sector, met binnenkort meer namen op de lijst.</p>
<p>Alles bij elkaar genomen is het moeilijk te zeggen wat de meest opvallende eigenschap is, omdat we zoveel goede dingen aan de gang hebben.</p>
<h3 id="h3-Q520OkKunt20u201320killer20features20van20uw20project20noemen20die20het20voorloopt20op20zijn20concurrenten464571"><a name="Q5: Ok…Kunt u 1-3 killer features van uw project noemen die het voorloopt op zijn concurrenten?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Ok…Kunt u 1-3 killer features van uw project noemen die het voorloopt op zijn concurrenten?</h3><p><strong>Azeem</strong>: Het vermelden van slechts 1-3 killer features voor dit project is een beetje te gemakkelijk.</p>
<p>Allereerst, kijk naar andere projecten in deze ruimte en blader door hun lijst van adviseurs of mensen in hun teams. Niemand zal iets in de buurt hebben van de vereiste branche-ervaring om deel te nemen aan het laten slagen van dit project. Mensen die platenlabels runnen tot anderen die de VP of Entertainment zijn bij Fox, zijn geen gemakkelijke mensen om tegen te komen, noch zijn ze typisch gezien zelfs toegestaan om deel uit te maken van dit soort projecten, simpelweg omdat hun functies het niet toestaan. Welnu, onze lijst met adviseurs is tot aan de rand gevuld vanwege de ervaring en relaties van het team.</p>
<p>Dan is het de technologie zelf. We hebben wereldklasse bouwers aan boord met mensen zoals David Atkinson. Het team dat achter ons staat en het product ontwikkelt, kan echt niet beter zijn. Hoewel het product zelf misschien eenvoudig lijkt, is het mijlenver voor op andere mensen in de branche die dingen gebruiken zoals onze <a href="/price/balancer-bal" rel="nofollow noopener noreferrer" target="_blank">Balancer</a> voor transacties. Hoewel het product veel weg heeft van Kickstarter, zijn de vraag en aanbod van maker-tokens behoorlijk vergelijkbaar met een DEX voor elk creatief project, wat een briljante benadering is als je erover nadenkt.</p>
<p>Ik was vorige week op NFT NYC en luisterde naar gesprekken en ontmoette mensen. Ik kan je niet vertellen hoe vaak ik heb gehoord dat we echt goede plekken nodig hebben om crowdfunding te laten gebeuren. Van mensen zoals Gary Vee, Mike Novogratz, en zelfs filmregisseurs zoals Quentin Tarantino.</p>
<p>Last but not least, de mensen in ons team zijn ervaren bouwers en we hebben al een product. Veel bedrijven hebben munten die pas gelanceerd worden en daarna pas beginnen met het bouwen van het product. Wij zijn in een positie waar we al drie succesvolle rondes hebben afgerond, met nog meerdere te gaan. We zijn bij de lancering klaar om een product los te laten in het wild.<br>Dat zijn enkele geweldige kenmerken, als die er ooit waren.</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 mening van de onderzoeker en vormt geen beleggingsadvies.<br></em><div><em></em>Gate.io behoudt alle rechten op dit artikel. Het opnieuw plaatsen van het artikel is toegestaan mits Gate.io wordt vermeld. In alle glen zal juridische actie worden ondernomen wegens schending van het auteursrecht.<br></div><p></p><br></div></div></div>