Skip to main content

Lost & Found Ideas

· 4 min read
Max Kaido
Max Kaido
Architect

Collection of technology ideas that emerged during our search for missing documentation.

First Attempt: Core Infrastructure​

  1. Testing Strategies

    • Jest and E2E testing patterns
    • Test organization and best practices
    • Performance testing guidelines

  2. CI/CD Practices

    • GitHub Actions workflows
    • Deployment strategies
    • Pipeline optimization

  3. Monitoring & Logging

    • Logging strategies
    • Metrics collection
    • Alert management

  4. Security Best Practices

    • Authentication patterns
    • Encryption guidelines
    • Key management

  5. Project Structure

    • Monorepo organization
    • Dependency management
    • Workspace setup

Second Attempt: Modern Frameworks​

  1. Bun.sh

    • Fast JavaScript runtime
    • Built-in bundler and test runner
    • TypeScript support

  2. Deno Fresh

    • Edge-first framework
    • TypeScript native
    • Zero build step

  3. SvelteKit

    • Efficient UI framework
    • Built-in animations
    • Small bundle size

  4. Htmx + Hyperscript

    • HTML-first approach
    • Minimal JavaScript
    • Dynamic UIs

  5. Solid.js

    • Fine-grained reactivity
    • Ultra-performance
    • Small bundle size

Third Attempt: Stack Enhancements​

  1. Zod + tRPC

    • End-to-end type safety
    • Runtime validation
    • API layer enhancement

  2. Turborepo

    • Enhanced monorepo tooling
    • Build caching
    • Workspace management

  3. Vite Plugins

    • Build optimization
    • Custom transformers
    • Dev experience improvements

  4. Prisma + Pothos

    • Type-safe GraphQL
    • Code-first schemas
    • Database integration

  5. Tanstack Query/Router

    • Data fetching
    • Type-safe routing
    • State management

Fourth Attempt: Hidden Gems​

  1. Minio Object Storage

    • Self-hosted S3
    • Model weights storage
    • Dataset versioning

  2. RabbitMQ Streams

    • Durable event streaming
    • Trading data flow
    • Message persistence

  3. ClickHouse

    • Column-oriented DBMS
    • Time-series optimization
    • Trading analytics

  4. Caddy Server

    • Modern reverse proxy
    • Automatic HTTPS
    • Simple configuration

  5. Typesense

    • Intuitive search engine
    • Typo tolerance
    • Real-time search

Fifth Attempt: Immediate Applicability​

  1. Upstash Redis/Kafka

    • Serverless data layer
    • Pay per request
    • Perfect for bursty workloads
    • Could replace self-hosted Redis

  2. Supabase Edge Functions

    • PostgreSQL + Functions
    • Real-time subscriptions
    • Built-in auth
    • Could simplify our backend

  3. Liveblocks

    • Real-time collaboration
    • Presence API
    • Conflict resolution
    • For collaborative trading features

  4. Trigger.dev

    • Workflow automation
    • TypeScript-first
    • GitHub integration
    • Could replace custom crons

  5. Convex

    • Real-time backend
    • Automatic caching
    • TypeScript schemas
    • Could simplify state sync

  6. Replicache

    • Offline-first sync
    • Conflict resolution
    • Real-time updates
    • For mobile trading app

  7. Inngest

    • Event processing
    • Durable execution
    • TypeScript support
    • For trading workflows

  8. Unleash

    • Feature flags
    • A/B testing
    • Gradual rollouts
    • For safe deployments

  9. Sentry Profiling

    • Performance monitoring
    • CPU/Memory profiling
    • Error tracking
    • For production debugging

  10. Grafbase

    • Edge GraphQL
    • Type-safe schema
    • Built-in caching
    • For API federation

Lessons Learned​

These brainstorming sessions revealed several patterns:

  1. Infrastructure modernization opportunities
  2. Performance optimization potential
  3. Developer experience improvements
  4. Unexpected solution spaces
  5. Focus on practical, immediate applicability

Even if these weren't the missing docs, they represent valuable exploration paths for future improvements.

Part 2: Potential Questions and Ideas

A collection of potential questions and ideas that might have been forgotten in our conversations. High-temperature brainstorming of what could have been asked.

Development & Infrastructure 🛠​

  1. "Can we set up automated performance benchmarking that runs every night and alerts if any service drops below 90% of its baseline?"

  2. "What if we created a CI/CD pipeline that automatically generates and updates architecture diagrams based on code changes?"

  3. "Should we implement a 'chaos monkey' service that randomly kills containers to test resilience?"

  4. "Could we add automated security scanning with specific rules for crypto-related code?"

  5. "How about creating environment validation scripts that check for drift every hour?"

AI & Machine Learning 🤖​

  1. "What if we trained a custom GPT model specifically on our codebase to help with code reviews?"

  2. "Could we use AI to automatically suggest version bump types based on the changes detected?"

  3. "Should we implement an AI-powered commit message validator that ensures semantic clarity?"

  4. "What about creating an AI assistant that monitors our Discord/Telegram and learns from team discussions?"

  5. "Could we use ML to predict which parts of the codebase might need refactoring soon?"

User Experience & Features 🎯​

  1. "What if we added a 'time travel' feature to the trading bot that simulates what would have happened if a trade was executed differently?"

  2. "Should we create a VR interface for visualizing trading patterns in 3D space?"

  3. "Could we implement a voice-controlled trading mode for hands-free operation?"

  4. "What about adding a 'trading style DNA' that learns and adapts to each user's risk preferences?"

  5. "Should we create a social layer where traders can share their strategies as NFTs?"

Documentation & Knowledge 📚​

  1. "What if we created an automated documentation health score that considers completeness, freshness, and clarity?"

  2. "Could we implement a 'documentation debt' tracker that flags outdated sections?"

  3. "Should we add interactive code examples that users can run directly in the docs?"

  4. "What about creating a knowledge graph of our entire codebase that visualizes dependencies and relationships?"

  5. "Could we implement automated translation of our docs into different programming paradigms?"

Wild Ideas 🌟​

  1. "What if we created a physical hardware device that glows different colors based on market sentiment?"

  2. "Should we implement a 'quantum-safe' mode that prepares our crypto operations for quantum computing?"

  3. "Could we create a 'developer mood tracker' that adjusts code review strictness based on team energy levels?"

  4. "What about implementing a 'code smell detector' that uses AI to identify potential issues before they become problems?"

  5. "Should we create a gamified system where fixing bugs earns developers NFT achievements?"

Meta Questions 🤔​

  • Which of these ideas resonate the most with our current goals?
  • Should we create a voting system for prioritizing these lost ideas?
  • How can we ensure we don't lose good ideas in the future?
  • Should we implement an automated idea collector that monitors team communications?

Next Steps 🚀​

  1. Review and categorize these ideas
  2. Identify quick wins vs long-term investments
  3. Create a system for capturing future "lost" ideas
  4. Set up regular review sessions for revisiting this list

Remember: Sometimes the craziest ideas lead to the most innovative solutions! 🌈