R2F0ZS5pbyBBTUEgbWV0IFplYmVjIC0gU3RyZWFtaW5nIEZpbmFuY2UgZW4gUmVhbC1UaW1lIFBheXJvbGw=

<p><img src="https://gimg2.gateimg.com/image/article/16814536211.jpg" alt=""><br><strong>Tijd: 31 maart 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 Subash Gautam, Head of Growth bij Zebec 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://zebec.io/" rel="nofollow noopener noreferrer" target="_blank">https://zebec.io/</a></strong><br><strong>Twitter: <a href="https://twitter.com/Zebec_HQ" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/Zebec_HQ</a></strong><br><strong>Volg Zebec op <a href="https://twitter.com/Zebec_HQ" rel="nofollow noopener noreferrer" target="_blank">Twitter</a> en <a href="https://t.me/zebecprotocol" rel="nofollow noopener noreferrer" target="_blank">Telegram</a></strong><br><strong>Gast</strong><img src="https://gimg2.gateimg.com/image/article/16814538802.jpg" alt=""><br><strong>Subash Gautam — Hoofd Groei bij Zebec</strong></p>
<h2 id="h2-Vraag20en20antwoord20van20Gateio349739"><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-Q120Kunt20u20ons20alstublieft20een20introductie20geven20over20Zebec978196"><a name="Q1: Kunt u ons alstublieft een introductie geven over Zebec?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Kunt u ons alstublieft een introductie geven over Zebec?</h3><p><strong>Subash</strong>: Zebec is een protocol voor continue afwikkeling dat salarisadministratie, contant geld zal transformeren <a href="/price/flow-flow" rel="nofollow noopener noreferrer" target="_blank">Stroom</a>, en token vesting door gebruikers in staat te stellen betalingen en distributies elke seconde te verzenden.</p>
<p>Als ecosysteem heeft Zebec meer dan 250 projecten die verschillende bedrijven er bovenop bouwen. Sinds de Zebec Hackathon hebben deze bedrijven meer dan 2M$ opgehaald van onder meer A16Z Partner Fund, Y-Combinator, Shima Capital, en meer.<br><img src="https://gimg2.gateimg.com/image/article/16814539123.png" alt=""><br>Naast het streamen van betalingen op een per seconde basis hebben we ook een Multisig.</p>
<h3 id="h3-Q220En20kunt20u20ons20iets20vertellen20over20het20team20wat20hun20achtergronden20zijn883305"><a name="Q2: En kunt u ons iets vertellen over het team, wat hun achtergronden zijn?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: En kunt u ons iets vertellen over het team, wat hun achtergronden zijn?</h3><p><strong>Subash</strong>: We hebben Sam Thapaliya (CEO), Sajjan Thapaliya (COO), Ajay Gautam (CTO) en Subash Gautam (Head of Growth) in het kernteam. En we hebben Joe McCan (Microsoft), Joe Regan (Ploygon Capital) en Lily Lui ( <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> Foundation) als adviseurs.</p>
<p>Sam is ook mede-oprichter van ASMI Corp, een AI- en Video Analytics Platform, en heeft 4 Amerikaanse octrooien op zijn naam.</p>
<p>Sajjan is de CEO van Selcouth Technology, een van de grootste blockchain-softwareontwikkelingslabs in Zuid-Azië.</p>
<p>Ajay is verbonden geweest met <a href="/price/harmony-one" rel="nofollow noopener noreferrer" target="_blank">Harmonie</a> en <a href="/price/icon-icx" rel="nofollow noopener noreferrer" target="_blank">ICON</a> Blockchains als onderzoeker in het verleden. Hij is ook een ethische hacker erkend door Facebook, Microsoft, Sony &amp; Esty en medeoprichter van cyberbeveiligingsstartups ReconwithMe &amp; Nassec.</p>
<p>Subash is de medeoprichter van ReconwithMe &amp; Nassec &amp; heeft een onderzoeksartikel gepubliceerd over het gebruik van blockchaintechnologie om de kosten en tijd van het verzenden van geldovermakingen te verlagen als onderdeel van zijn afstudeerie.</p>
<h3 id="h3-Q320Over20voortgang20gesproken20wat20heeft20Zebec20tot20nu20toe20op20productgebied20kunnen20bereiken140263"><a name="Q3: Over voortgang gesproken, wat heeft Zebec tot nu toe op productgebied kunnen bereiken?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Over voortgang gesproken, wat heeft Zebec tot nu toe op productgebied kunnen bereiken?</h3><p><strong>Subash</strong> Tot nu toe hebben we echt goede vooruitgang kunnen boeken.</p>
<p>In 7 maanden sinds we met Zebec zijn begonnen, hebben we twee productlijnen op de markt kunnen brengen en $28m aan financiering opgehaald.</p>
<p>We hebben ook twee hackathons kunnen organiseren, waar mensen geweldige producten bouwen bovenop Zebec.</p>
<p>En als gemeenschap zijn we gegroeid van een paar mensen naar duizenden.</p>
<h3 id="h3-Q420Welke20doelen20streeft20Zebec20na20om20te20bereiken20in202022303469"><a name="Q4: Welke doelen streeft Zebec na om te bereiken in 2022?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: Welke doelen streeft Zebec na om te bereiken in 2022?</h3><p><strong>Subash</strong> Voor 2022 zullen meer DeFi-partnerschappen en ecosysteemintegratie de prioriteit hebben.</p>
<p>Tegen 2022 willen we ook onze eigen debetkaart lanceren, waarmee Zebec-gebruikers crypto rechtstreeks in fiatvaluta kunnen omzetten.</p>
<p>We zouden ook mikken op het verwerven van duizenden gebruikers voor onze producten.</p>
<h2 id="h2-Live20QampA20van20de20gemeenschap425328"><a name="Live Q&amp;A van de gemeenschap" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Live Q&amp;A van de gemeenschap</h2><h3 id="h3-Q120Wat20is20momenteel20uw20belangrijkste20focus20bent20u20gericht20op20de20gemeenschap20of20de20marktbeurs20of20de20producten47936"><a name="Q1: Wat is momenteel uw belangrijkste focus, bent u gericht op de gemeenschap of de markt/beurs of de producten?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Wat is momenteel uw belangrijkste focus, bent u gericht op de gemeenschap of de markt/beurs of de producten?</h3><p><strong>Subash</strong>: Onze focus ligt op dit moment natuurlijk op het product. Maar we zijn ook van plan om alles parallel te doen; gemeenschap, vermeldingen en tokenprijs.</p>
<h3 id="h3-Q220Heeft20u20AUDITcertificaten768538"><a name="Q2: Heeft u AUDIT-certificaten?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Heeft u AUDIT-certificaten?</h3><p><strong>Subash</strong>: Ja. We hebben al een beveiligingsaudit uitgevoerd voor onze producten bij twee gerenommeerde beveiligingsauditbedrijven in de <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a> Blockchain.</p>
<h3 id="h3-Q320PARTNERSCHAP20en20SAMENWERKINGEN20vormen20de20ruggengraat20om20elk20project20meer20wijdverbreid20te20maken20Kunt20u20enkele20van20uw20partners20bij20ons20opsommen861570"><a name="Q3: PARTNERSCHAP en SAMENWERKINGEN vormen de ruggengraat om elk project meer wijdverbreid te maken. Kunt u enkele van uw partners bij ons opsommen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: PARTNERSCHAP en SAMENWERKINGEN vormen de ruggengraat om elk project meer wijdverbreid te maken. Kunt u enkele van uw partners bij ons opsommen?</h3><p><strong>Subash</strong>: Inderdaad. We hebben al een partnerschap gesloten met Visa (voor debetkaart) en <a href="/price/chainlink-link" rel="nofollow noopener noreferrer" target="_blank">Chainlink</a> (voor prijsvoer). We zullen de komende dagen meer partnerschappen aankondigen.</p>
<h3 id="h3-V420Mijn20vraag20is20dat20dit20uw20project20alleen20is20voor20eliteinvesteerders20Hoe20zit20het20met20andere20kleine20fondsen20die20voor20iedereen20toegankelijk20zijn44355"><a name="V4: Mijn vraag is dat dit uw project alleen is voor elite-investeerders. Hoe zit het met andere kleine fondsen die voor iedereen toegankelijk zijn?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>V4: Mijn vraag is dat dit uw project alleen is voor elite-investeerders. Hoe zit het met andere kleine fondsen die voor iedereen toegankelijk zijn?</h3><p><strong>Subash</strong>: Ons project is bedoeld voor zowel zakelijke als particuliere beleggers.</p>
<h3 id="h3-Q520Er20is20felle20concurrentie20in20de20financile20sector20Natuurlijk20zijn20er20andere20projecten20die20op20jou20lijken20Hoe20zal20Zebec20omgaan20met20zijn20rivalen20Heb20je20details20om20gebruikers20naar20jou20te20leiden5433"><a name="Q5: Er is felle concurrentie in de financiële sector. Natuurlijk zijn er andere projecten die op jou lijken. Hoe zal Zebec omgaan met zijn rivalen? Heb je details om gebruikers naar jou te leiden?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Er is felle concurrentie in de financiële sector. Natuurlijk zijn er andere projecten die op jou lijken. Hoe zal Zebec omgaan met zijn rivalen? Heb je details om gebruikers naar jou te leiden?</h3><p><strong>Subash</strong>: Er is een hevige concurrentie. We zullen ermee omgaan door geweldige producten te bouwen.</p>
<h3 id="h3-Q620Heeft20de20naam20Zebec20enige20betekenis20Waarom20heb20je20zon20naam20gekozen20Kun20je20ook20uitleggen20hoe20je20tokenomics20distributie20is20Hoeveel20tokens20worden20er20gemunt20En20hoeveel20tokens20worden20er20door20het20team20vergrendeld601637"><a name="Q6: Heeft de naam ‘Zebec’ enige betekenis? Waarom heb je zo’n naam gekozen? Kun je ook uitleggen hoe je tokenomics distributie is? Hoeveel tokens worden er gemunt? En hoeveel tokens worden er door het team vergrendeld?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q6: Heeft de naam ‘Zebec’ enige betekenis? Waarom heb je zo’n naam gekozen? Kun je ook uitleggen hoe je tokenomics distributie is? Hoeveel tokens worden er gemunt? En hoeveel tokens worden er door het team vergrendeld?</h3><p><strong>Subash</strong> Het heeft. Zebec is afgeleid van de Arabische term ‘xebec’ of ‘shabbak’ wat een klein maar snel vaartuig aanduidt dat werd gebruikt voor handel in de Middellandse Zee van de zeventiende tot de negentiende eeuw. In de eenentwintigste eeuw vaart Zebec samen met <a href="/price/solana-sol" rel="nofollow noopener noreferrer" target="_blank">Solana</a>.</p>
<h3 id="h3-Q720Als20de20gemeenschap20op20de20hoogte20wil20blijven20van20het20laatste20nieuws20hoe20kunnen20ze20Zebec20volgen7820"><a name="Q7: Als de gemeenschap op de hoogte wil blijven van het laatste nieuws, hoe kunnen ze Zebec volgen?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q7: Als de gemeenschap op de hoogte wil blijven van het laatste nieuws, hoe kunnen ze Zebec volgen?</h3><p><strong>Subas</strong>: Mensen kunnen ons volgen op deze sociale media.<br>Twitter - <a href="https://twitter.com/Zebec_HQ" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/Zebec_HQ</a><br>Discord - <a href="https://discord.com/invite/jUwZ3cHauZ" rel="nofollow noopener noreferrer" target="_blank">https://discord.com/invite/jUwZ3cHauZ</a></p>
<p>Telegram- <a href="https://t.me/zebececo" rel="nofollow noopener noreferrer" target="_blank">https://t.me/zebececo</a><br>Medium - <a href="https://medium.com/zebec-protocol/latest" rel="nofollow noopener noreferrer" target="_blank">https://medium.com/zebec-protocol/latest</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 mening van de onderzoeker en vormt geen beleggingsadvies.<br></em><div><em></em>Gate.io behoudt alle rechten van dit artikel. Het opnieuw plaatsen van het artikel is toegestaan onder vermelding van Gate.io. In alle glen zal juridische actie worden ondernomen wegens inbreuk op het auteursrecht.<br></div><p></p><br></div></div></div>