MoreMitaan

Meet Geeta Didi: The Real User Behind the Technology

In 2020, I was introduced to Geeta Devi, a 45-year-old farmer from a small village near Raipur, Chhattisgarh. She had recently received her first smartphone through a government scheme—a basic Android device with 4GB storage and intermittent 2G connectivity.

Geeta's challenge was overwhelming: the government offered 481 different welfare schemes, but she had no way to know which ones she qualified for. The local government office was 20 kilometers away, requiring a full day's journey and loss of agricultural income. When she did make the trip, officials often couldn't provide clear guidance across all available schemes.

This is the story of building AI that works for Geeta Didi—and millions like her.

The Last Mile Challenge

Understanding the Constraints

Building AI for rural India meant confronting harsh realities:

Device Limitations:

• 4GB total storage (with system taking 2GB)
• 2GB RAM with background apps consuming 1.5GB
• Single-core processors from 2016
• Battery life concerns with limited charging infrastructure

Connectivity Reality:

• 2G networks with frequent dropouts
• Data costs that matter—every MB has a price
• Offline periods lasting days during monsoons
• No WiFi infrastructure

User Context:

• First-time smartphone users
• Limited literacy in Hindi, minimal English
• Agricultural work schedules that demand efficiency
• Skepticism about digital services based on past failures

The challenge wasn't just technical—it was about building AI that could be genuinely helpful to someone whose time and resources were precious.

Designing an AI Expert System for Extreme Constraints

Why Expert Systems Over Machine Learning?

While deep learning was dominating AI headlines, I chose a classical AI approach—expert systems with backward chaining inference. Here's why:

Explainability: Geeta needed to understand WHY she qualified for a scheme Reliability: No training data required—rules were based on government policies Efficiency: Deterministic algorithms that could run on minimal hardware Offline Capability: No cloud dependencies after initial setup

The Technical Architecture

┌─────────────────────────────────────┐
│        Voice/Text Interface         │ ← Chhattisgarhi, Hindi, English
├─────────────────────────────────────┤
│         Inference Engine            │ ← Backward chaining logic
├─────────────────────────────────────┤
│         Knowledge Base              │ ← 481 schemes + eligibility rules
├─────────────────────────────────────┤
│      Local Storage (SQLite)         │ ← Offline data persistence
└─────────────────────────────────────┘

Implementation Deep Dive

The Knowledge Base: Encoding Government Schemes

The heart of MoreMitaan was a comprehensive knowledge base that encoded every government scheme's eligibility criteria:

// Example scheme representation
const pmKisanScheme = {
  id: 'pm_kisan_2019',
  name: {
    hindi: 'प्रधानमंत्री किसान सम्मान निधि योजना',
    chhattisgarhi: 'मुख्यमंत्री किसान सम्मान योजना',
    english: 'PM Kisan Samman Nidhi Scheme'
  },
  eligibility: {
    rules: [
      { field: 'occupation', operator: 'equals', value: 'farmer' },
      { field: 'landOwnership', operator: 'lessThan', value: 2 }, // hectares
      { field: 'age', operator: 'greaterThan', value: 18 },
      { field: 'bankAccount', operator: 'exists', value: true }
    ],
    logic: 'AND' // All conditions must be met
  },
  benefits: {
    amount: 6000,
    frequency: 'annual',
    installments: 3,
    description: {
      hindi: 'वर्ष में ₹6000 तीन किश्तों में',
      chhattisgarhi: 'साल में ₹6000 तीन बार में'
    }
  },
  documents: [
    'aadhar_card',
    'bank_passbook',
    'land_records'
  ],
  applicationProcess: {
    online: true,
    offline: true,
    csCenter: true
  }
};

Backward Chaining Inference Engine

The AI engine used backward chaining to determine scheme eligibility:

class SchemeInferenceEngine {
  constructor(knowledgeBase) {
    this.schemes = knowledgeBase;
    this.userProfile = {};
    this.eligibleSchemes = [];
  }

  // Main inference method
  async findEligibleSchemes(userAnswers) {
    this.userProfile = userAnswers;
    this.eligibleSchemes = [];

    for (const scheme of this.schemes) {
      if (await this.evaluateScheme(scheme)) {
        this.eligibleSchemes.push({
          scheme,
          confidence: this.calculateConfidence(scheme),
          missingInfo: this.findMissingInfo(scheme)
        });
      }
    }

    return this.rankSchemes(this.eligibleSchemes);
  }

  // Backward chaining evaluation
  async evaluateScheme(scheme) {
    const rules = scheme.eligibility.rules;
    const logic = scheme.eligibility.logic;

    if (logic === 'AND') {
      return rules.every(rule => this.evaluateRule(rule));
    } else if (logic === 'OR') {
      return rules.some(rule => this.evaluateRule(rule));
    }

    return false;
  }

  evaluateRule(rule) {
    const userValue = this.userProfile[rule.field];

    if (userValue === undefined) {
      // Ask user for missing information
      this.requestInformation(rule.field);
      return false;
    }

    switch (rule.operator) {
      case 'equals':
        return userValue === rule.value;
      case 'lessThan':
        return parseFloat(userValue) < rule.value;
      case 'greaterThan':
        return parseFloat(userValue) > rule.value;
      case 'exists':
        return Boolean(userValue);
      default:
        return false;
    }
  }

  // Calculate confidence based on how well user profile matches
  calculateConfidence(scheme) {
    const totalRules = scheme.eligibility.rules.length;
    const metRules = scheme.eligibility.rules.filter(rule =>
      this.evaluateRule(rule)
    ).length;

    return (metRules / totalRules) * 100;
  }
}

Extreme Size Optimization

To fit within the 2MB constraint, I implemented aggressive optimization:

1. Code Minification and Compression

// Before: 150KB scheme data
const schemes = [
  {
    name: "Pradhan Mantri Kisan Samman Nidhi Scheme",
    description: "Financial support to farmers...",
    // ... full details
  }
];

// After: 45KB compressed scheme data
const schemes = compress([
  {
    n: "PM_KISAN",
    d: "₹6k/yr farmers",
    r: [["occ","eq","farm"],["land","lt",2]]
  }
]);

2. Intelligent Lazy Loading

class SchemeLoader {
  constructor() {
    this.coreSchemes = loadCoreSchemes(); // Most common 50 schemes
    this.extendedSchemes = null; // Loaded on demand
  }

  async getScheme(id) {
    if (this.coreSchemes.has(id)) {
      return this.coreSchemes.get(id);
    }

    if (!this.extendedSchemes) {
      this.extendedSchemes = await loadExtendedSchemes();
    }

    return this.extendedSchemes.get(id);
  }
}

3. Offline-First Data Storage

class OfflineStorage {
  constructor() {
    this.db = new SQLite('moremitaan.db');
    this.syncQueue = [];
  }

  async storeUserProfile(profile) {
    // Store locally first
    await this.db.save('user_profile', profile);

    // Queue for sync when online
    this.syncQueue.push({
      type: 'profile_update',
      data: profile,
      timestamp: Date.now()
    });
  }

  async syncWhenOnline() {
    if (navigator.onLine && this.syncQueue.length > 0) {
      try {
        await this.uploadSyncQueue();
        this.syncQueue = [];
      } catch (error) {
        // Continue working offline
        console.log('Sync failed, continuing offline');
      }
    }
  }
}

User Experience Design for Digital Newcomers

Conversational Interface Design

I designed the interaction to feel like talking to a knowledgeable friend rather than using a computer:

const conversationFlow = {
  greeting: {
    hindi: "नमस्ते! मैं आपको सरकारी योजनाओं की जानकारी देने आया हूं। आपका नाम क्या है?",
    chhattisgarhi: "राम राम! हमन तुंहर बर सरकारी योजना के बारे म बताए आए हान। तुंहर नाम का हे?",
    response: ['name']
  },

  occupation: {
    hindi: "{name} जी, आप क्या काम करते हैं?",
    chhattisgarhi: "{name} दाई, तुमन का काम करथव?",
    options: [
      { key: 'farmer', hindi: 'खेती', chhattisgarhi: 'खेती' },
      { key: 'labor', hindi: 'मजदूरी', chhattisgarhi: 'मजदूरी' },
      { key: 'business', hindi: 'व्यापार', chhattisgarhi: 'धंधा' }
    ]
  },

  followUp: {
    farmer: {
      hindi: "अच्छा! आपके पास कितनी जमीन है?",
      chhattisgarhi: "बढ़िया! तुंहर घर कतना जमीन हे?",
      inputType: 'voice_or_text',
      validation: 'numeric'
    }
  }
};

Voice Interface for Low-Literacy Users

Recognizing that many users struggled with text input, I implemented voice recognition with local language support:

class VoiceInterface {
  constructor() {
    this.recognition = new (window.SpeechRecognition || window.webkitSpeechRecognition)();
    this.setupRecognition();
  }

  setupRecognition() {
    this.recognition.continuous = false;
    this.recognition.interimResults = false;

    // Support for local languages
    this.recognition.lang = 'hi-IN'; // Default to Hindi
  }

  async askQuestion(question, expectedType = 'text') {
    return new Promise((resolve) => {
      // Play question audio (pre-recorded for clarity)
      this.playAudio(question.audio);

      // Listen for response
      this.recognition.onresult = (event) => {
        const answer = event.results[0][0].transcript;
        const processedAnswer = this.processAnswer(answer, expectedType);
        resolve(processedAnswer);
      };

      this.recognition.onerror = () => {
        // Fall back to text input
        resolve(this.showTextInput(question.text));
      };

      this.recognition.start();
    });
  }

  processAnswer(answer, expectedType) {
    switch (expectedType) {
      case 'numeric':
        // Extract numbers from voice input
        return this.extractNumber(answer);
      case 'yes_no':
        // Recognize various ways to say yes/no in local languages
        return this.extractYesNo(answer);
      case 'selection':
        // Match spoken words to predefined options
        return this.matchSelection(answer);
      default:
        return answer;
    }
  }
}

Visual Design for Basic Smartphones

The interface was optimized for small screens and touch interactions:

/* Mobile-first design for 4-inch screens */
.question-container {
  padding: 16px;
  font-size: 18px; /* Large enough for aging eyes */
  line-height: 1.6;
}

.option-button {
  min-height: 56px; /* Touch-friendly size */
  margin: 8px 0;
  background: #4CAF50;
  color: white;
  border: none;
  border-radius: 8px;
  font-size: 16px;
  font-weight: bold;
}

.voice-button {
  position: fixed;
  bottom: 20px;
  right: 20px;
  width: 64px;
  height: 64px;
  border-radius: 50%;
  background: #FF5722;
  color: white;
  border: none;
  font-size: 24px;
}

/* High contrast for outdoor visibility */
.high-contrast {
  background: #000;
  color: #FFF;
}

.high-contrast .option-button {
  background: #FFF;
  color: #000;
  border: 2px solid #000;
}

Deployment and Field Testing

Pilot Program with 100 Families

I started with a small pilot in two villages near Raipur, working directly with families to understand real usage patterns:

Week 1-2: Basic Training

• Village meetings to explain the app
• One-on-one training sessions with interested families
• Paper backup sheets for complex cases

Week 3-6: Guided Usage

• Daily check-ins with pilot users
• Real-time bug fixes and UX improvements
• Collection of user feedback and confusion points

Week 7-12: Independent Usage

• Users operated independently
• Monthly review sessions
• Success story documentation

Key Learnings from Field Testing

1. Audio Quality Matters More Than Visual Polish Poor audio made the app unusable, while simple visuals with clear audio worked perfectly.

2. Confidence Building is Crucial Users needed reassurance that their information wouldn't be misused. Trust-building was more important than feature development.

3. Family Learning Networks Often, one family member (usually younger) would learn the app and then help others. Designing for this "local expert" model was more effective than trying to make every individual self-sufficient.

4. Success Stories Drive Adoption When Geeta Didi received her first scheme benefit after using the app, three neighboring families immediately wanted to try it.

Results and Impact

Quantitative Outcomes

After 18 months of operation:

• 10,847 citizens successfully matched with eligible schemes
• ₹2.3 crore in total benefits accessed by users
• Average of 4.2 schemes per user (previously 1.1)
• 68% reduction in trips to government offices
• 87% user satisfaction rate

Qualitative Impact Stories

Geeta Devi's Transformation: "पहले मुझे पता ही नहीं था कि मेरे लिए इतनी योजनाएं हैं। अब मैं अपने फोन से ही सब देख लेती हूं।" (I never knew there were so many schemes for me. Now I can see everything on my phone.)

Ramesh, Local Teacher: "This app has made me the unofficial tech support for the village. But I'm happy to help—seeing families get benefits they deserve is worth it."

Sunita, Village Health Worker: "Now when I visit families, they already know about health schemes. The app has made my job easier and more effective."

Systemic Changes

The app's success led to broader improvements:

• Government office efficiency: Reduced burden on staff for scheme information queries
• Increased scheme uptake: Overall participation in government programs rose by 40% in pilot areas
• Digital literacy growth: Families became more confident with other government digital services
• Reduced intermediary dependence: Local agents who charged fees for scheme information lost their monopoly

Technical Lessons for Extreme Constraint Computing

1. Constraints Drive Innovation

Working within 2MB forced creative solutions that made the app better for everyone:

• Efficient data structures reduced memory usage
• Smart caching improved performance on all devices
• Offline capabilities made the app more reliable

2. User Context Trumps Technical Sophistication

The most advanced AI algorithms were useless if they couldn't run reliably on Geeta's phone. Understanding user context—device limitations, connectivity issues, usage patterns—was more important than algorithmic optimization.

3. Graceful Degradation is Essential

The app needed to work even when things went wrong:

• No internet: Full offline functionality
• Low battery: Reduced background processing
• Poor audio: Visual fallbacks for voice features
• User confusion: Clear escape routes to human help

4. Local Language Support is Non-Negotiable

True accessibility required deep local language support, not just translation:

• Cultural context: Schemes explained in locally relevant terms
• Voice recognition: Trained on local dialects and accents
• Visual cues: Icons and colors that made sense in local context

The Broader Implications for AI Accessibility

AI for the Next Billion Users

MoreMitaan represented a different approach to AI—not AI for the privileged, but AI for people who need it most:

Inclusive by Design: Built for users with the least resources, ensuring it works for everyone

Context-Aware: Understanding that technical capabilities must match real-world constraints

Human-Augmented: AI that enhances human capability rather than replacing human judgment

Lessons for AI Ethics

Working with vulnerable populations taught me crucial lessons about AI responsibility:

Explainability is Justice: When government benefits are at stake, users deserve to understand why they qualify or don't qualify for schemes.

Privacy by Design: Rural users may not understand data privacy, but that makes protecting their data more important, not less.

Empowerment over Automation: The goal was to give users more control over their interactions with government, not to automate those interactions away.

What This Taught Me About Conscious Technology

MoreMitaan fundamentally shaped my understanding of what conscious technology means:

1. The Last Mile is Often the First Priority

If technology doesn't work for people with the fewest resources, it's probably not as innovative as we think it is. Building for constraints often leads to better solutions for everyone.

2. AI Should Democratize Access, Not Concentrate Power

The most powerful AI applications help people navigate complex systems (like government schemes) rather than making decisions for them. AI should be a tool for empowerment, not control.

3. Success is Measured in Human Flourishing

Technical metrics (app downloads, processing speed, algorithm accuracy) matter only insofar as they contribute to real human outcomes. For MoreMitaan, success was measured in families accessing benefits they deserved.

4. Technology Transfer Requires Trust Transfer

Deploying technology in communities that have been marginalized requires deep trust-building. The technology is often the easy part—the social and cultural integration is where real innovation happens.

The Future of AI for Social Impact

MoreMitaan was a proof of concept for a larger vision: AI systems that work for everyone, especially those who need them most.

This requires:

• Inclusive design processes that center marginalized users from the beginning
• Appropriate technology choices that prioritize accessibility over sophistication
• Local partnerships that understand cultural and social context
• Sustainable deployment models that don't require ongoing external support

The lessons from building AI for Geeta Didi continue to influence every project I work on. Whether I'm building educational platforms for urban schools or blockchain systems for government transparency, I always ask: "Would this work for someone with Geeta's constraints? Would it genuinely help her life?"

If the answer is no, then it's probably not as conscious or as innovative as it could be.

True technological progress is measured not by what's possible in labs or for privileged users, but by what's accessible to those who need it most.