DEV Community: Jose Toscano

Cursor, but for Document Vibe-Editing

Jose Toscano — Fri, 21 Mar 2025 21:28:32 +0000

This is a submission for the KendoReact Free Components Challenge.

AI-Powered Document "Vibe" Editor

SmartDocs is an intelligent document editor that combines the power of AI with KendoReact's UI components to create a seamless writing experience.
Just like Cursor enables Vibe Coding, SmartDocs brings you Vibe Writing - a flow state where you and AI work together naturally, making document creation feel effortless and enjoyable.

Think of it as having an AI writing assistant that understands your document's context and helps you create, edit, and enhance content while you're just vibing with your work.

Demo

(Make sure to watch in HD for full quality.)

🔗 Live Demo
🔗 GitHub Repository

KendoReact Experience

SmartDocs leverages KendoReact free components to deliver a sleek, professional, and intuitive user experience:

AppBar – Used as the main navigation
Avatar – Displays the user profile in the header
Button – Drives interactions across the UI
Card – Showcases document previews
Dialog – For File upload Modal
DropDownList – Allows users to select and configure document's page and format
Input – Used for titles and siemple text fields
NumericTextBox - Used for page settings configuration
TextArea - Used for AI chatbot
Popup – Powers context menus like user's dropdown and page configuration
Progress Bar - To track how the AI process each request
Tooltip – Provides helpful context and in-app guidance

Pro tip here: To speed up development, I leveraged Cursor’s MCP capabilities to integrate these components efficiently. In many cases, simply pasting the KendoReact component documentation URL was enough—my AI agent understood exactly how to implement it in context, dramatically reducing integration time.

Additionally, I used a premium KendoReact component for the main document editor, providing a seamless and powerful writing experience at the core of SmartDocs.

The free components provided by KendoReact were instrumental in building a professional-grade application. The consistent design language and out-of-the-box functionality allowed us to focus on the core features while maintaining a polished look.

AIm to Impress

SmartDocs integrates Anthropic’s AI models to deliver a writing experience that feels intuitive, helpful, and totally in sync with the user’s flow:

Context-Aware Assistance: The AI understands your document’s structure and content to give relevant, in-the-moment suggestions.
Flow State Friendly: It helps you write faster without breaking your rhythm—just type and vibe.
Smart Formatting: From headings to tone, the AI makes formatting feel effortless.

The GenAI features are built right into the interface; no context switching, no extra windows. It's just a natural, real-time collaboration with AI.

This fits perfectly in the Generative AI category, as the core of the product revolves around generating, editing, and adapting content using AI. It’s not just an add-on—it’s the engine that powers the whole experience.

Capture Your Best Ideas Anytime, Anywhere with Brain Dump: The AI-Powered Writing Assistant for Effortless Content Creation!

Jose Toscano — Sun, 26 Jan 2025 14:05:57 +0000

This is a submission for the Agent.ai Challenge: Full-Stack Agent (See Details)
Overview
It all started with a simple conversation with my non-technical business partner:

"You know... I get random ideas and thoughts at the most unexpected times during the day. I wish I could just send them as voice notes and later use them to write my blog posts. But it's tough to find the time to sit down and go through all of them."

This sparked an idea—to create an AI-powered writing assistant that captures these spontaneous thoughts and transforms them into structured content, helping busy professionals stay consistent with their content creation efforts.

What I Built

I developed a full-stack multi- AI agent that seamlessly integrates with Telegram and Agent.ai to capture, process, and draft LinkedIn posts based on voice notes.

Why It Matters

One of the things I love about this solution is how incredibly convenient it is. I genuinely see myself using it over the next few months because of its effortless accessibility. With just a simple voice note, I can capture my thoughts anytime, anywhere, and have an AI agent ready to process them—whether I’m commuting, taking a walk, or in between meetings.

The best part? No need to log into any extra dashboards or complicated tools. Although Agent.ai’s dashboards provide valuable insights and controls, the ability to manage everything directly from my phone via Telegram makes it a game-changer for productivity on the go.

Voice Note Capture via Telegram Chatbot:

We understand that the best ideas can strike at any moment. That’s why we’ve built a tool that lets users capture them effortlessly through a Telegram bot. Simply by sending a voice note, and it will be transcribed and securely stored as an “idea” for future content. Behind the scenes, a webhook triggers an Agent.ai process to analyze and categorize the user's thoughts, ensuring they’re ready when they need them.

AI-Powered Writing Profile:

Your unique voice matters, and our AI ensures it shines through. Brain Dump continuously refines your writing style by analyzing your past LinkedIn posts and transcribed voice notes. It learns your tone, favorite phrases, and writing patterns to generate content that truly reflects your personality and professional brand.

Automated LinkedIn Post Drafting:

When the user is ready to post, they can request the AI agent to generate a draft based on stored ideas, again, all through a simple text or voice message.

The agent will then go through the user's profile and previous ideas to produce a well-structured draft using the user's tone of voice, preferred topics, and content style.

Demo

To bring Brain Dump to life, I utilized a set of specialized AI Agents, each playing a crucial role in processing and generating content seamlessly. Below are the key agents used in the system, along with their respective functions:

Orchestrator Agent
The brain behind Brain Dump, this agent is responsible for processing all incoming inputs from the Telegram chatbot. It analyzes whether the message is a new idea, a request for a summary, or an instruction to generate a post, and then routes it to the appropriate AI agent for further action.

Summarizer Agent
This agent provides users with concise and meaningful summaries of their stored ideas. Whether they need a quick recap of recent thoughts or an overview of specific topics, the Summarizer Agent extracts key insights to keep their content organized and accessible.

Linkedin Master
A specialized AI agent that focuses on analyzing the user’s LinkedIn activity, including past posts and writing patterns. It helps refine the user's writing profile, ensuring that generated content matches their tone, style, and frequently used phrases.

Simple LLM Fallback
Acting as a safety net, this agent ensures smooth handling of unexpected queries or when other agents are unable to provide a precise response. It helps maintain a seamless user experience by offering relevant suggestions and fallback responses when needed.

Telegram Chatbot API Gateway

In addition to the AI Agents, I developed a Telegram chatbot, which serves as the main interface for users to interact with Brain Dump. It acts as an API Gateway, forwarding user prompts—whether as text or voice notes—directly to the AI agents for processing.

You can test the implementation here 👉: t.me/YourBrainDumpBot

You can explore the chatbot’s implementation here:
👉 GitHub Repository

JoseCToscano / braindump

Simple Telegram Chatbot to send random voice notes with ideas for LinkedIn Posts

🚀 Brain Dump Telegram Chatbot

Brain Dump is a Telegram chatbot designed to help users capture their ideas effortlessly and turn them into engaging LinkedIn posts with the power of AI. Whether you’re on the go or brainstorming at your desk, simply send a voice note or text message, and let the AI do the rest!

🛠️ How It Works

Capture Ideas:
- Send a voice note or text message to the chatbot via Telegram.
- Your input is forwarded to an AI Orchestrator for processing.
Processing & Categorization:
- The orchestrator determines whether the input is
  - A new idea to be stored.
  - A request to summarize existing ideas.
  - A command to generate a LinkedIn post.
- It routes the request to the appropriate AI Agent for further action.
AI-Driven Insights:
- Specialized AI agents analyze your past LinkedIn posts and voice notes to refine your writing style.
- When you're ready, Brain Dump generates a…

View on GitHub

How It Works

Idea Capture:

The user sends a voice note via Telegram.

Processing & Orchestration:

The Telegram bot forwards the message to an AI Orchestrator via a webhook.
The orchestrator analyzes the input and determines the appropriate next step.

Specialized AI Agents:

Depending on the input, different AI agents are triggered to:
Process and categorize new ideas.
Analyze existing ideas for insights.
Generate an initial draft if enough content has been collected.
Continuous Learning:

The AI refines the user's writing profile by analyzing voice notes and past LinkedIn posts, ensuring content stays aligned with their style.

Content Generation:

When the user requests a post, the AI drafts it based on their tone, writing patterns, and key themes.

Agent.ai Experience

I wasn't quite sure where to start, so I decided to dive in from scratch and explore everything. To my surprise, building AI Agents was way easier than I expected. Based on my past experience, I assumed I’d have to deal with API keys, set up Python integrations, and rely on APIs or SDKs to connect with AI models. However, the Builder made it as simple as selecting the features I needed, prompting for user inputs, and seamlessly passing them to other actions. Calling AI models was incredibly straightforward.

Once I figured out my application's needs, it was just a matter of sitting down and building it. I opted to use multiple AI Agents instead of one large agent to simplify debugging and allow for easier feature expansion down the line.

Getting everything to work via webhooks did take some effort, and I encountered a few challenges along the way. However, the Agent.ai team was super responsive and supportive, helping me resolve issues quickly.

PRO TIP HERE: When setting up a webhook, start by testing it with minimal or no user inputs. Once you confirm it's working correctly, gradually add inputs one at a time, testing each step along the way. Initially, I tried adding everything at once and testing the trigger, but I encountered several issues that needed to be fixed on the server. Taking a step-by-step approach can help prevent unexpected errors and streamline the setup process.

One of the things I love most is that you don’t need to know how to code to build AI Agents. I’m confident my non-technical co-founder will be thrilled with how intuitive it is. That said, having some coding experience really opens up possibilities for creating awesome features like Brain Dump and integrating with various services.

Whats next?

As Brain Dump continues to evolve, the focus remains on refining its ability to capture authentic tone and maintain consistency with the user's unique professional branding. Striking the right balance between automation and user control has been key to ensuring a seamless experience. Looking ahead, future improvements include expanding to other platforms like Twitter and Medium, incorporating sentiment analysis to better capture emotions, and providing context-aware recommendations based on industry trends.

Ultimately, Brain Dump empowers busy entrepreneurs and professionals by turning spontaneous ideas into engaging content effortlessly, helping them stay consistent and boost their online presence.

Life in Dots: A Visual Journey of Time and Transformation

Jose Toscano — Mon, 20 Jan 2025 02:50:22 +0000

This is a submission for the GitHub Copilot Challenge : Transitions and Transformations

What I Built

Life in Dots: A Visual Journey of Time and Transformation

In the hustle of daily life, it’s easy to lose sight of the fact that our time here is finite. We get caught up in work, responsibilities, and distractions, often forgetting that each passing week is a piece of a much larger picture. Life in Dots is a creative tool that offers a gentle yet profound reminder of our journey through life, helping us visualize the precious time we have and encouraging us to make the most of it.

Demo

Try the demo here: https://www.dotsjourney.me/

Embracing Transitions and Transformations

Life is a series of transitions and transformations. From childhood to adulthood, from moments of joy to periods of struggle, each phase brings its own lessons and opportunities. This app serves as a visual representation of these stages—each dot symbolizing a week of our lives. It allows us to step back and see our journey from a broader perspective, acknowledging where we've been, where we are, and where we’re headed.

The beauty of change lies in its inevitability. We cannot stop time, but we can choose how we engage with it. Life in Dots invites us to embrace the transitions of life with mindfulness and purpose, celebrating growth rather than fearing it.

A Simple Habit for a Complex Life

Tracking every single day of our lives can feel overwhelming. Between work deadlines, social commitments, and personal goals, it’s easy to feel like there’s no room left for reflection. But what if we took just one day a week—perhaps Sundays—to look back and set light intentions for the future?

This app is designed with simplicity in mind. Every week, you can hover over a dot to reflect on the past seven days, reminding yourself of the highs and lows, the lessons learned, and the moments cherished. Clicking on a dot allows you to plan lightly for the upcoming week—whether it’s reconnecting with loved ones, taking a moment for self-care, or setting a small personal goal.

By making this a weekly habit, Life in Dots helps us stay connected with our journey without the burden of daily tracking. It becomes a ritual—an opportunity to pause, breathe, and appreciate the present moment while preparing for the future with intention.

A Tool for New Beginnings

Every new week is an opportunity for a fresh start. Whether you’re embarking on a new career, forming healthier habits, or simply striving to be more present in your relationships, Life in Dots serves as a gentle guide to help you navigate your journey.

With a minimalist design and an intuitive interface, the app provides clarity and perspective. It’s not just about productivity; it’s about aligning our actions with our values and ensuring that, amidst the chaos of life, we don’t lose sight of what truly matters.

Repo

Checkout the full code for it here:
https://github.com/JoseCToscano/life-dots

Copilot Experience

I love leveraging powerful tools that make me a super-fast developer. My approach is to use project scaffolds and robust CLI tools like ShadCN to quickly add components and accelerate development. GitHub Copilot perfectly complemented my workflow by assisting with debugging, adding new pages, and refactoring code efficiently.

Initially, I started by saving journal entries and reminders in local storage, but as the project evolved, I consulted Copilot's chat feature to help me design a Prisma schema and transition everything to a database for better persistence. The guidance provided by Copilot made the migration seamless and well-structured.

Authentication was another area where Copilot proved invaluable. I initially implemented NextAuth but later decided to switch to Clerk for a smoother user experience. Copilot made this transition effortless by suggesting the necessary changes and even assisting with Clerk's API integration.

The speed and efficiency with which I can code with Copilot's assistance are incredible. From writing new components and pages to offering insightful suggestions for best practices, Copilot has truly amplified my productivity and allowed me to focus on building impactful features rather than getting bogged down in repetitive tasks.

Conclusion

Using GitHub Copilot has been an invaluable experience, enabling me to build things faster and more efficiently. It has empowered me to focus on what truly matters—creating meaningful and impactful tools like Life in Dots. With Copilot's assistance in debugging, refactoring, and even guiding major architectural decisions like transitioning from local storage to a database, I was able to turn an idea into a fully functional tool that helps people reflect on their lives and plan with intention.

Life in Dots is more than just a visual productivity app; it’s a spiritual reflection on the passing of time and a reminder to live with purpose. In a world filled with noise and distractions, it invites us to step back, embrace life's transitions, and make the most of every moment. The speed at which I could iterate with Copilot allowed me to bring this concept to life quickly—turning a simple vision into a life-changing tool that encourages users to pause, reflect, and turn each week into a meaningful stepping stone on their journey.

Because in the end, our life is nothing but a beautiful constellation of moments—each dot a gentle reminder that our time here is precious.

Neon Meets `create-t3-app`: The PostgreSQL Solution for Modern Developers

Jose Toscano — Sun, 01 Sep 2024 20:45:11 +0000

This is a submission for the Neon Open Source Starter Kit Challenge : Ultimate Starter Kit

My Kit

As developers, we understand the importance of having a reliable and flexible starter kit to kickstart our projects. The create-t3-app CLI tool has become a beloved choice for many in the developer community, boasting over 24.7k stars on GitHub. This popularity is a testament to its effectiveness in helping developers build full-stack TypeScript applications with ease. Instead of starting from scratch to create a new CLI tool, it makes perfect sense to build on top of such a well-established and widely adopted project.

That's why we're excited to introduce a powerful enhancement to create-t3-app—one that preserves its versatility while integrating Neon as a robust PostgreSQL database provider, offering developers an additional, seamless solution for serverless PostgreSQL.

Why We Forked create-t3-app

The open-source nature of create-t3-app allows it to evolve alongside the needs of the community. Our team saw an opportunity to build upon this amazing foundation by integrating Neon as a database provider. The goal of our fork was not to diverge from the original project but to contribute an enhancement that we hope will eventually be merged back into the main repository.

Two-Part Challenge Submission

Our challenge submission for the Neon Open Source Starter Kit Challenge consists of two distinct parts:

create-neon-t3 CLI alternative

We created a fork of the original create-t3-app called create-neon-t3, which sets Neon as the default database provider. This fork is accessible as an npm package through:

npm create neon-t3

This version is tailored for developers who already know they'll be using a PostgreSQL database in a serverless environment. It retains all the original flexibility of create-t3-app, allowing you to scaffold your Next.js project with built-in authorization and type safety (while optional, tRPC hugely recommended) while defaulting to Neon as the database provider.

2.A Pull Request to the Original Project

The second part of our submission is a pull request to the original create-t3-app project. Our aim is to contribute this enhancement back to the community, ensuring that the tool continues to serve the evolving needs of developers.
The original create-t3-app offered PlanetScale as the primary database option for MySQL users. However, with PlanetScale's recent deprecation of their free tier, the community needs a strong alternative—especially for those who prefer to build on PostgreSQL. Neon, designed for serverless environments and with its very generous free tier, is the perfect fit for this role.

Check out the PR here:

feat: Neon as database Provider #1976

JoseCToscano posted on Sep 01, 2024

Closes # 1930

With PlanetScale's recent deprecation of their free tier, the community needs a strong alternative—especially for those who prefer to build on PostgreSQL. Neon, designed for serverless environments and with its very generous free tier, is the perfect fit for this role.

Why Neon? Neon offers a modern, serverless PostgreSQL solution that is perfectly aligned with the needs of developers who prioritize performance, scalability, and simplicity.

I tried using Supabase (lot's of connection issues) and Vercel's Storage (seamless integration, but they're missing all the extra tools that other DB providers offer)

With Neon, you get:

Serverless PostgreSQL: Seamless scaling without the need for managing servers.
Cost Efficiency: A free tier that supports developers from prototyping to production.
Developer-Friendly: A modern approach to database management, making it easy to integrate into existing workflows.

✅ Checklist

[x] I have followed every step in the contributing guide (updated 2022-10-06).
[x] The PR title follows the convention we established conventional-commit
[x] I performed a functional test on my final commit

Changelog

Adds Neon as a database provider: Introduced Neon as an option for PostgreSQL
Updates CLI Prompts: Added a new option to select Neon as the database provider during the setup process.
Configuration Files: Generated all necessary configuration files for Prisma and Drizzle ORM when Neon is selected, ensuring seamless integration with Neon's serverless PostgreSQL.

Screenshots

💯

View on GitHub

(still WIP to fit to their contribution guidelines)

Why Neon?

Neon offers a modern, serverless PostgreSQL solution that is perfectly aligned with the needs of developers who prioritize performance, scalability, and simplicity.

With Neon, you get:

Serverless PostgreSQL: Seamless scaling without the need for managing servers.
Cost Efficiency: A free tier that supports developers from prototyping to production.
Developer-Friendly: A modern approach to database management, making it easy to integrate into existing workflows.

How to Use the CLI Tool

Our CLI tool retains the simplicity and flexibility of the original create-t3-app while offering Neon as the default database provider. Here’s how you can use it to kickstart your next project:

Step 1: Install and Run the CLI To get started, you can run the CLI directly from npm:

npm create neon-t3@latest

This will pull the latest version of the CLI

Pro Tip here: If the package is called "create-neon-t3", why can it be run with npm create neon-t3?
This is because of the Package Naming Convention:
The package name "create-neon-t3" follows a common convention where packages designed to scaffold new projects start with create-. When you run npm create neon-t3, npm looks for a package named "create-neon-t3" to initialize a new project.
The @latest tag ensures that the latest version of the package is used.

Step 2: Choose Your Project Options
The CLI will guide you through a series of prompts to configure your new project. Since Neon is set as the default database provider, that won't be part of these prompts:
Step 3: Set Up Your Environment
Once you’ve completed the setup, the CLI will generate a .env file for your project. This file will include the necessary environment variables for connecting to your Neon database.

For example:

env

# Database Connection String
DATABASE_URL="postgresql://postgres:password@localhost:5432/myapp"

# Next Auth Settings
NEXTAUTH_SECRET="your-secret"
NEXTAUTH_URL="http://localhost:3000"

Step 4: Create and connect your Neon project
Proceed to connect your Neon's project by simply configuring your database URL available on your Neon dashboard.
Step 5: Start Building
With everything set up, you can begin building your application immediately. The CLI has taken care of configuring the database, authentication, and other essential settings, allowing you to focus on writing code.

npm run dev

Together, we can continue to build the ultimate open-source starter kit—one that adapts to the needs of the community and supports developers at every stage of their journey. Happy coding!

Link to Kit

JoseCToscano / create-neon-t3

The best way to start a full-stack, typesafe Next.js app

create-neon-t3

Interactive CLI to start a full-stack, typesafe Next.js app, with database on Neon

Why We Forked create-t3-app

The original create-t3-app offered PlanetScale as the primary database option for MySQL users. However, with PlanetScale's recent deprecation of their free tier, the community needs a strong alternative—especially for those who prefer to build on PostgreSQL. Neon, designed for serverless environments and with its very generous free tier, is the perfect fit for this role.

Why Neon?

Neon offers a modern, serverless PostgreSQL solution that is perfectly aligned with…

View on GitHub

Your Journey

The Bigger Picture: Contributing Back to the Community

Our intention with this fork is to contribute something valuable back to the open-source community. By integrating Neon into the create-t3-app tool, we hope to offer developers another robust option for building with PostgreSQL. This enhancement is not just about adding a new feature—it’s about ensuring that the tool continues to grow in ways that serve the needs of its users.

We deliberately chose not to remove any other database providers on the pull request to the original project, such as PlanetScale, to maintain the CLI's versatility and ensure a smooth integration process. Our hope is that by keeping the tool open and adaptable, it will encourage more developers to contribute and ultimately lead to this enhancement being merged into the original project.

Conclusion

The integration of Neon into the create-t3-app CLI tool is just the beginning. We believe that this enhancement will empower developers to build even more powerful applications with the tools they love. Whether you're already a fan of create-t3-app or just discovering it, we invite you to try out this new version and see how Neon can elevate your development experience.

Next.js + tRPC: Best practices for dApp development. Issuing new Assets + Freighter Wallet integration

Jose Toscano — Mon, 19 Aug 2024 06:37:43 +0000

This is a submission for the Build Better on Stellar: Smart Contract Challenge : Create a Tutorial

Your Tutorial

Best practices for dApp development. Issuing new assets using Freighter Wallet | Arcade

app.arcade.software

JoseCToscano / art-auction

Create T3 App

This is a T3 Stack project bootstrapped with create-t3-app.

What's next? How do I make an app with this?

We try to keep this project as simple as possible, so you can start with just the scaffolding we set up for you, and add additional things later when they become necessary.

If you are not familiar with the different technologies used in this project, please refer to the respective docs. If you still are in the wind, please join our Discord and ask for help.

Learn More

To learn more about the T3 Stack, take a look at the following resources:

Documentation
Learn the T3 Stack — Check out these awesome tutorials

You can check out the create-t3-app GitHub repository — your feedback and contributions are welcome!

How do I deploy this?

Follow our deployment guides for Vercel…

View on GitHub

By the end of the tutorial we should be able to mint new assets through our dApp by signing transactions with the Freighter Wallet Browser Extension:

You may be wondering why I chose that as my cover image. It’s actually the randomly generated image I created for my tutorial, representing art pieces as Stellar assets. I thought it would be fitting to use it here as well

What I Created

My submission is a comprehensive tutorial that guides developers through building a decentralized application (dApp) using Stellar's API and Freighter's web wallet, while promoting best practices in software development. The tutorial covers essential concepts such as issuer and distributor accounts, the asset minting process, and Trustlines, providing detailed explanations to ensure a deep understanding. I also emphasized secure management of environment variables and encapsulated wallet integration in a custom useWallet hook to promote modularity and reusability. By using modern tools like create-t3-app, Vercel's v0, and Shadcn's components, the tutorial helps developers efficiently build secure and scalable applications, with best practices and core Stellar functionalities at the forefront.

In the tutorial, I aimed to leverage all the tools available to us as developers, from quick component development and image generation to powerful frameworks for rapidly getting an app up and running. My goal was to demonstrate how seamlessly web development can integrate and incorporate these new advancements, including those in decentralized applications.

Journey

I became deeply involved in building a dApp on that used the Stellar and Soroban Smart Contracts. Before diving into development, I first had to familiarize myself with the essential concepts, terminology, and challenges associated with Stellar's technologies. It was challenging at the beginning, with a steep learning curve, but once I grasped the core concepts, I found myself thriving in the development process.

After completing and submitting my app, I realized just how much I had learned. This newfound understanding and excitement made me eager to share my knowledge with others. I wanted to create a straightforward, easy-to-follow tutorial that highlights the exact steps I took—something I wish I had when I was starting out. This tutorial is designed to save developers hours, if not days, of deep research and trial-and-error by providing a clear path through the complexities of Stellar and Freighter Wallet integration. I would have loved to inclued a section to showcase the use of Soroban Smart Contracts, but I just didn't have enough time to cover it.

I’m particularly proud of how I managed to distill these complex ideas into accessible content, making it easier for others to get started with Stellar. What I hope to do next is continue building on this foundation, further explore the possibilities within Stellar’s ecosystem, and create more educational resources to help others navigate and thrive in this space.

Take a look at my submission if you haven't yet:

Entry•X | Decentralized Ticketing Platform

Jose Toscano ・ Aug 17 '24

#devchallenge #stellarchallenge #blockchain #web3

Entry•X | Decentralized Ticketing Platform

Jose Toscano — Sat, 17 Aug 2024 07:56:25 +0000

This is a submission for the Build Better on Stellar: Smart Contract Challenge : Build a dApp

The ticketing industry is plagued by high fees, unreliable systems, and widespread fraud, leaving fans frustrated and uncertain. Traditional ticketing processes lack transparency, often prioritizing profits over people. However, by leveraging Soroban Smart Contracts on the Stellar Network, we can restore trust and fairness to the industry.

What I Built

In creating a decentralized ticketing platform, our primary focus was on developing a robust solution tailored to the unique needs of Users (that's all of us), Event Organizers, and Resellers. Each of these groups interacts with the platform differently, so we designed the system to ensure their experiences are seamless, secure, and transparent.

Redefining WYSIWYG (What You Sign Is What You Get)

We couldn't define it better.

Our application leverages the power of the Stellar **Network and **Soroban Smart Contracts to create a transparent and reliable ticketing ecosystem. Every transaction is reviewed and approved through your Freighter Wallet, giving you complete control and security. For the best experience, make sure you've got your browser extension up and running. (Get Freighter)

Secure and Transparent: The Freighter Wallet prompts you to review and approve every transaction, ensuring that what you sign is truly what you get.

Here's how it works:

1. Decentralized Ticketing for Event Organizers

Note that video demo won't display any Wallet Interaction, but you can go and check it out on our live demo

Event organizers can now distribute their tickets with complete control and transparency. Using the platform, organizers issue tickets as digital assets on the Stellar network. Soroban Smart Contracts manage the sale of tickets, enforcing rules around pricing, limits per buyer, and other conditions. This eliminates the need for middlemen and allows organizers to sell tickets directly to their audience.

Experience immediate payments directly to your Wallet.

Transparency and Trust for Users and Resellers

For users, the platform offers a transparent and secure way to purchase tickets. Every ticket is issued as a digital asset on the Stellar Network, which means that when you buy a ticket, you can verify its authenticity at all time. The integration with the Freighter wallet allows users to securely sign transactions, ensuring that all purchases are authorized and that your secret keys never leave your control.

This system not only prevents fraud but also gives you confidence that what you sign is what you get - whether you're buying or selling.

For resellers, the platform provides a fair and transparent marketplace where tickets can be resold through auctions. Soroban Smart Contracts handle all aspects of the auction, from placing bids to executing the final sale. But more importantly, bidders must commit to their offers - no bid is valid without the corresponding transaction.

We are committed to providing trust and transparency at every level, and this principle is the foundation upon which we built our smart contracts. The code below illustrates how we ensure that a bid is only considered valid if a legitimate transaction is made, reinforcing our dedication to secure and fair transactions.

 pub fn place_bid(env: Env, auction_id: Symbol, bidder: Address, bid_amount: i128) {
            bidder.require_auth();
            // ...

            // Put your Money where your mouth is $$$
            // Transfer the corresponding bid (XLM) from the bidder to the contract address
            let native_asset = token::Client::new(&env, &auction.native_address.clone());
            let contract = env.current_contract_address();
            let xlmAmount = bid_amount.clone() * 100000;
            native_asset.transfer(&bidder.clone(), &contract, &xlmAmount);

            // Transfer the previous highest bid back to the previous highest bidder
            let previous_highest_bidder = auction.highest_bidder.clone();
            if previous_highest_bidder.is_some() {
                let previous_bidder = previous_highest_bidder.unwrap();
                let previous_bid = auction.highest_bid.clone() * 10000000;
                native_asset.transfer(&contract, &previous_bidder, &previous_bid);
            }
      // ...
}

Our goal is not to limit or regulate resellers, but to empower them with full control over how they sell tickets, while ensuring trust and transparency for both parties involved.

We recognize that reselling is a significant aspect of the ticketing industry, and we’re committed to supporting it rather than imposing restrictions. To build trust, we’ve implemented a system where the swap of resources—whether it’s money or tickets—only occurs when all conditions are met. This way, both buyers and sellers can engage confidently, knowing that their transactions are secure and fair.

Leveraging Stellar's Low Fees and Decentralization

In an industry where every cent counts, keeping costs down is crucial for both buyers and sellers. On our platform, each user is responsible for covering their own network fees, but thanks to Stellar's efficient design, these fees are minimal.

By decentralizing the ticketing process, we eliminate the need for middlemen who often inflate prices. Instead, users transact directly with each other through a secure, transparent, and decentralized system.

Demo

Entry•X is Live --> https://www.entryx.me/

Make sure to be connected to the Testnet network

Join Us on This Journey

If you're an event organizer looking to distribute your tickets through a platform built on trust and transparency, we encourage you to become a partner. Join our waitlist today and be part of this revolutionary change. Together, we can make the ticketing experience better for everyone.

As we move forward, we're excited to extend an invitation to the organizers of the upcoming Meridian events. How awesome would it be to showcase the future of ticketing on the very platform that leverages the power of Stellar and Soroban? Let’s work together to ensure that by next year, Meridian 2025 attendees will experience firsthand how secure and seamless ticketing can be. Join us in setting a new standard for the industry.

entryx.me

My Code

JoseCToscano / EntryX

Decentralized event ticketing platform on the Stellar Blockchain, enabling secure ticket sales and auctions within a secondary market. Get ready to buy, sell, or bid on tickets seamlessly – make sure your Freighter Wallet is set up!

Entry•X Decentralized Ticketing and Reselling dApp

Welcome to Entry•X! This platform leverages the power of the Stellar blockchain to create a secure, transparent, and efficient marketplace for event tickets Users can purchase, manage, and resell their tickets with ease, all while ensuring the authenticity of their assets.

Features

Blockchain-Powered Tickets: Each ticket is a digital asset on the Stellar blockchain, ensuring authenticity and security.
Freighter Wallet Integration: Securely sign transactions and manage your assets with the Freighter wallet.
Auction-Based Reselling: Users can resell their tickets on the secondary market through a transparent auction system.
Smart Contract Enforcement: Soroban smart contracts manage all transactions, ensuring that conditions are met and providing security for both buyers and sellers.

Tech Stack

This is a T3 Stack project bootstrapped with create-t3-app.

If you are not familiar with the different technologies used in this project, please refer to the respective docs.

View on GitHub

Journey

Implementation and Smart Contract Design

Our motivation for this project stems from personal experiences of fraud and unfair pricing in the ticketing industry. It’s about time we take control and drive real change. The smart contracts we’ve implemented are designed to decentralize ticketing, ensuring that money is only exchanged when a valid asset is received.

In many countries, resellers face significant risks, sometimes even engaging in illegal activities, while trust remains low and fraud is rampant in secondary markets. I wanted to address these issues head-on. Additionally, event organizers often rely on third parties for ticket distribution, which can result in long delays before they see their earnings, not to mention the high, often abusive, commissions they’re forced to pay. There are clear areas of opportunity at every stage of the ticketing process.

When designing our contracts, we deliberately avoided becoming intermediaries for payouts and ticket distribution, as these transactions can be handled directly on the Stellar network. Payments go directly to where they need to be at the exact moment they occur, and asset exchanges happen simultaneously. We needed to ensure that our contracts managed and distributed resources exactly this way. Given that we had to interact directly with Stellar Assets, we chose to manage them through Stellar Asset Contracts. This required us to dive deep into understanding and learning how to effectively utilize them.

(Pro tip here: just make sure the SAC are deployed before attempting to use them, even if there's already an address for them)

Our contracts are capable of storing both assets and native currency, making them the sole intermediary where all transactions are atomic and fully traceable. Rust, a powerful language that maximizes the use of network resources, was crucial in this development. We had to learn and apply best practices in Rust to design our contracts effectively. (That was a tough one)

Proud Moments

One of the most rewarding moments was seeing how our Asset Auctions managed to distribute funds to the correct agents and all involved parties. Witnessing how the issuer received the appropriate commissions, how the asset owner got paid for the sale, and how the commissions were automatically taken out and sent to the right addresses was an incredible validation of our work.

Experience with the Ecosystem

Working with the Stellar Network and Soroban Smart Contracts has been a learning-intensive experience, but also incredibly fulfilling. The ecosystem provided the tools and framework necessary to bring our vision to life, particularly in terms of transparency and reliability in ticketing. (Of course, there’s still work to be done—improving documentation, providing more examples—but that’s a responsibility we share as a community.)

Future Plans

We are actively seeking event organizers who are ready to adopt decentralized ticketing. The more users we onboard, the more we can push for wider adoption of web3 services, including wallet usage. One of our major goals is to manage ticketing for Stellar's annual events, as it feels like a natural fit for their ecosystem.

Looking ahead, our next big step is integrating fiat payments to ensure a seamless user experience. We believe that by making the process as straightforward as possible, we can encourage more users and organizers to transition to decentralized ticketing.

Additionally, we recognize a significant gap in the market related to ticket pre-sales and the frequent shortages that leave buyers frustrated. We aim to redefine how these pre-sales are conducted, allowing assets to go directly to where they need to be without the need for virtual lines that result in hours of waiting, only to discover that tickets are sold out. Our vision is to create a more efficient and fair system where everyone has a better chance to secure their tickets without the usual hassle.