Scaling a Telegram Trading Bot to 1.2K Users and Getting Acquired

Building a trading bot was never the plan. It started as a tool for myself, evolved into a product, and ended with an acquisition. Here's the technical story behind EzPump.

The Genesis

In late 2024, Solana meme coins were exploding. The opportunity was clear, but the tools were lacking:

• Existing bots had terrible UX
• Most required complex wallet setups
• None offered the features power traders needed

I built EzPump to solve my own trading needs. Within weeks, traders in my network wanted access.

Technical Architecture

Why Telegram?

• Built-in Authentication: Telegram handles user identity - no signup/login needed
• User Trust: Crypto traders already live in Telegram
• Real-time Updates: Native support for instant notifications

The Stack

// Core Technologies
- TypeScript with Node.js for type safety
- Telegraf framework for bot integration
- @solana/web3.js for blockchain interaction
- MongoDB with Mongoose for user data
- NestJS for API endpoints
- Jito for fast, low-cost MEV-protected transactions

From MVP to Production Architecture

The first month, I built everything with pure TypeScript and Node.js Telegram Bot API — no fancy architecture, just fast implementation to solve the problem and get users on board. It worked, but as features grew, the codebase became unwieldy.

Month two was a complete refactor:

• Migrated to NestJS for dependency injection and scalable architecture
• Adopted Telegraf - the best Telegram framework with session handling, middleware support
• Database schema redesign - Completely migrated to a new MongoDB schema optimized for scale
• Modular design - each feature (volume bot, bundler, comment bot) became a separate module
• Clean separation - business logic, API routes, and bot handlers properly organized

This refactor paid dividends - new features that would've taken days now took hours, and the new schema handled growth effortlessly.

Key Features That Drove Growth

1. Volume Generation Bot

Traders needed to boost their tokens' visibility on pump.fun. I engineered a clever system that:

• Created dedicated wallets for each user automatically
• Automatically created and branded pump.fun accounts with EzPump logo, description, and name
• Applied strategic "bumps" - executing buy and sell orders in the same transaction block
• Generated real volume without users losing money (net zero trades)
• Exploited pump.fun's algorithm that promoted high-volume tokens to homepage visibility

// Volume generation through atomic bumps
const generateVolumeBump = async (config: BumpConfig) => {
    const userWallet = await createOrGetUserWallet(config.userId);
    
    // Update pump.fun profile with EzPump branding
    await updateProfile(userWallet, {
        name: config.customName || 'EzPump Trader',
        image: EZPUMP_LOGO,
        bio: 'Powered by @EzPumpFun'
    });

    // Execute buy and sell in same block
    const tx = new Transaction();
    tx.add(buyInstruction(config.token, config.amount));
    tx.add(sellInstruction(config.token, config.amount));
    
    // Net zero for user, maximum impact for algorithm
    await sendAndConfirmTransaction(tx);
};

2. Token Bundler

The killer feature - create and buy tokens in the same transaction:

async function bundleTokenLaunch(params: BundleParams) {
    const tx = new Transaction();

    // Create token on Pump.fun
    tx.add(createTokenInstruction(params));

    // Create new wallets
    const buyers = await generateBuyerWallets(params.buyerCount);

    // Add buy instructions for each wallet
    for (const buyer of buyers) {
        tx.add(createBuyInstruction(buyer, params.amount));
    }

    // Execute atomically
    return await sendAndConfirmTransaction(tx);
}

Scaling Challenges

1. RPC Strategy for Scale

At 1K+ users, RPC performance was critical. My solution:

• Jito for all transactions - Extremely fast execution with lower fees than standard Solana
• Mainnet RPC for queries - Account lookups, balances, hashblock verification
• Premium Helius subscription - Ensured users always had quick transaction confirmations
• Smart routing - Transactions via Jito, reads via mainnet, premium fallback via Helius

2. Smart Wallet & Fee Management

Built a sophisticated wallet system with secure key storage and intelligent fee calculation. Generated wallets for each user with private keys hashed and secured in the database:

// Smart fee estimation before bumping
const calculateTotalFees = async (bumpConfig: BumpConfig) => {
    const fees = {
        pumpFun: PUMP_FUN_FEE,
        solanaBase: BASE_TX_FEE,
        jitoTip: bumpConfig.jitoTip || DEFAULT_JITO_TIP,
        slippage: calculateSlippage(bumpConfig.amount, bumpConfig.slippageBps),
        rent: await calculateRentForNewAccounts(),
        botFee: calculateBotFee(user.subscription, bumpConfig.amount)
    };
    
    return {
        total: Object.values(fees).reduce((a, b) => a + b),
        breakdown: fees,
        possibleBumps: Math.floor(balance / fees.total),
        estimatedTime: calculateBumpTime(bumpConfig.frequency)
    };
};

3. Advanced Features That Set Us Apart

Customizable Trading Parameters: Users had full control through settings:

• SOL Amount: How much to use per bump
• Bump Frequency: Time interval between bumps
• Max Bump Limit: Stop after X bumps to control spending
• Priority Fee: Higher fees = faster transactions (with speed impact warnings)
• Slippage Tolerance: Maximum acceptable price movement

Flexible Business Models:

• Token Passes: One-time purchase for unlimited bumps on specific tokens
• Pay-Per-Bump: Traditional fee on every transaction
• Service Pass: Lifetime access with zero bot fees
• Referral System: 50% commission on fees from invited users

Comment Bot with Anti-Detection:

// Reverse-engineered browser comment submission
const postComment = async (message: string) => {
    const browser = await puppeteer.launch({
        args: ['--proxy-server=' + getRotatingProxy()]
    });
    
    // Submit comments through browser automation
    await navigateToPumpFun(page);
    await page.type('#comment-box', message);
    await page.click('#submit-button');
    
    // Rotate proxy for next request
    await browser.close();
};

4. Smart Notification System & User Retention

Built a comprehensive notification system to keep users engaged:

Real-time Alerts:

• Trade confirmations with transaction details
• Balance updates after deposits/withdrawals
• Error alerts with actionable solutions
• Bump completion summaries

Newsletter Strategy:

• Regular updates to keep the bot top-of-mind
• New feature announcements
• Trading tips and successful user stories
• Market insights to drive engagement

This notification system was crucial for retention - users who received regular updates were 3x more likely to remain active.

The Growth Journey: 0 to 1.2K Users

Strategic Growth & User Acquisition

Smart Onboarding with Free Trials:

// Automated onboarding that converted
const onboardNewUser = async (userId: string) => {
    // Create wallet immediately
    const wallet = await createUserWallet(userId);
    
    // Don't make user wait for pump.fun setup (can take seconds)
    setupPumpFunProfile(wallet).catch(handleProfileError);
    
    // Hook them with value immediately
    await sendWelcomeMessage(userId, quickStartGuide);
    await grantFreeTokenPass(userId); // Free trial to build familiarity
    
    // Track everything
    await trackEvent('user_onboarded', { userId, freePassGranted: true });
};

Multi-Channel Growth Strategy:

1. Organic Network Effect - Started with my network, EzPump branding on pump.fun profiles spread awareness
2. Telegram Groups - Direct promotion in crypto trading communities
3. Professional Presence - Built website, created branded email, established Twitter presence
4. Paid Twitter Growth - Premium account + promoted posts drove significant traffic
5. Open-Source Credibility - After launching v2, made the codebase open-source for developers to learn from
6. 24/7 Comment Bot Marketing:

// Real-time token monitoring via WebSocket
const marketingBot = () => {
    pumpFunWebSocket.on('newTokenCreated', async (mint: string) => {
        try {
            await postMarketingComment({
                tokenMint: mint,
                message: getRandomMarketingMessage(),
                // Race to be first = lifetime visibility
            });
        } catch (err) {
            // Handle rate limits, retry logic
        }
    });
};

Data-Driven Optimization:

• Tracked offer views vs. purchases
• Analyzed bump frequency by pricing plan
• Monitored user activity patterns
• Identified drop-off points for improvement

Community Marketing Engine

• Built active Twitter/X presence @EzPumpFun for updates and community engagement
• Automated success story sharing across social channels
• Referral program with instant rewards
• Community competitions with leaderboards
• Strategic partnerships with alpha groups

The Acquisition

After 8 months of growth from November 2024 to June 2025, we hit 1.2K active users. MicroPump — the pioneer and first bot on pump.fun — approached with an offer I couldn't refuse. They were building a comprehensive trading ecosystem and wanted:

What They Valued

1. The User Base: 1.2K+ active, paying users
2. Robust Architecture: EzPump's maintainable codebase designed for easy feature additions
3. The Bundler Technology: Our unique approach to token creation
4. Anti-Detection Systems: Sophisticated proxy rotation and behavioral patterns
5. The Brand: EzPump had become synonymous with reliable Solana trading bots

The Transition Process

The handover took 4 weeks of intensive technical work:

Technical Migration Challenges:

// Complex database migration between different schemas
const migrationScript = async () => {
    // EzPump's NestJS schemas → MicroPump's Node.js structure
    const users = await ezpumpDB.getUsers();
    
    for (const user of users) {
        const transformedUser = {
            // Map EzPump fields to MicroPump schema
            micropump_id: generateNewId(),
            telegram_id: user.telegramId,
            wallets: transformSchema(user.wallets),
            subscription: mapSubscriptionModel(user.plan),
            // Preserve all historical data
            legacy_data: user
        };
        
        await micropumpDB.insertUser(transformedUser);
    }
};

Key Challenges Solved:

1. Schema Migration: Developed and tested migration scripts in dev before flawless production execution
2. Framework Translation: Ported EzPump's NestJS features to MicroPump's Node.js architecture
3. Zero Downtime: Users experienced seamless transition with no service interruption
4. Data Integrity: All user wallets, balances, and subscription data preserved perfectly

Lessons Learned

1. Start with Your Own Needs

The best features came from my own trading frustrations. Dog-fooding led to genuine innovation.

2. Speed is Everything

In crypto, being first matters more than being perfect. Ship fast, iterate faster.

3. Community is Your Moat

Technical features get copied. Your community doesn't. I invested heavily in user support and feedback loops.

4. Prepare for Success

I didn't expect 1K+ users. When growth hit, architecture decisions made early saved us:

• Stateless bot design
• Horizontal scaling ready
• Proper abstraction layers

5. Security First

One hack could've ended everything. Security measures included:

• Encrypted wallet storage
• Rate limiting everything
• Audit logging
• Regular security reviews

Technical Takeaways

Building EzPump taught me:

• Blockchain development requires different thinking
• Real-time systems need careful architecture
• User trust in crypto is everything
• Performance directly impacts revenue

Impact Beyond the Acquisition

Open-sourcing EzPump after the v2 refactor had unexpected benefits:

• Developers learned from the architecture patterns
• Some forked and built their own variations
• Established credibility in the developer community
• Proved that execution matters more than code secrecy

What's Next?

The acquisition was a win, but the journey continues. I'm applying these lessons to new projects, focusing on the intersection of AI and blockchain.

Building in crypto is wild - the pace, the users, the opportunity. If you're considering it, my advice: start building. The ecosystem needs more builders who care about user experience.

Working on something in Web3? I'd love to chat. Reach out.