Wage Wise

Developed a comprehensive desktop billing application specifically designed for textile sizing businesses, featuring industry-specific workflows, subscription validation, and efficient data management.

Project Overview

Wage Wise is a specialized billing solution built to address the unique needs of textile sizing businesses. The application streamlines billing operations, manages worker records, and handles complex pricing calculations specific to the textile industry.

Key Features

Billing Management

• Create and manage invoices for sizing services
• Support for multiple pricing models (per piece, per kg, hourly)
• Automatic calculation of worker wages based on production
• Tax calculations and invoice generation

Worker Management

• Maintain worker profiles and attendance records
• Track individual productivity and earnings
• Generate worker-wise payment reports
• Historical performance tracking

Subscription System

• Implemented license validation and subscription management
• Trial period support with feature limitations
• Secure activation and renewal process
• Offline license validation

Data Persistence

• Used Isar DB for fast, local-first data storage
• Efficient querying for large datasets
• Automatic data backup and recovery
• Export functionality for accounting software integration

Technical Implementation

Flutter Desktop

• Built using Flutter for Windows desktop
• Native performance with cross-platform codebase
• Material Design UI adapted for desktop workflows
• Keyboard shortcuts for power users

Isar Database

• NoSQL database optimized for Flutter
• Lightning-fast queries and indexing
• Type-safe schema definitions
• Automatic data migration

Architecture

• MVVM pattern for clean separation of concerns
• Repository pattern for data access
• Provider for state management
• Modular code structure for maintainability

Industry-Specific Features

• Sizing Calculations: Custom algorithms for textile sizing pricing
• Production Tracking: Monitor daily production metrics
• Worker Productivity: Track efficiency and output per worker
• Batch Management: Handle multiple batches with different pricing
• Report Generation: Comprehensive reports for business insights

User Experience

• Intuitive Interface: Designed for non-technical users
• Fast Data Entry: Optimized workflows for quick billing
• Offline-First: Works without internet connectivity
• Print Support: Direct invoice printing
• Data Export: Export to Excel and PDF formats

Business Impact

• Reduced billing time by 70% compared to manual processes
• Eliminated calculation errors in worker wage computation
• Provided real-time visibility into business operations
• Enabled data-driven decision making for textile businesses

Technologies Used

Flutter, Dart, Isar Database, Desktop Development, MVVM Architecture, Provider State Management

Badli

Contributed to Badli, a social-impact mobile platform designed to help daily wage textile workers find job opportunities, improving their livelihood and connecting them with employers efficiently.

Project Mission

Badli addresses a critical need in the textile industry by creating a digital marketplace that connects daily wage workers with employers, reducing unemployment and improving job accessibility for workers who traditionally rely on word-of-mouth and informal networks.

My Contributions

Flutter UI Development

• Designed and implemented user-friendly mobile interfaces
• Created intuitive workflows for non-technical users with varying literacy levels
• Implemented multi-language support for regional accessibility
• Optimized UI for low-end Android devices

User Experience Focus

• Conducted user research to understand worker and employer needs
• Simplified job search and application processes
• Designed clear visual indicators and minimal text interfaces
• Implemented voice-based features for accessibility

Backend Integration

• Integrated Flutter app with Spring Boot backend APIs
• Implemented real-time job notifications
• Built user authentication and profile management
• Developed job matching algorithms

Key Features

For Workers

• Job Discovery: Browse available jobs by location, skill, and wage
• Quick Apply: Simple application process with minimal steps
• Profile Management: Maintain work history and skills
• Notifications: Real-time alerts for matching job opportunities
• Earnings Tracking: Track daily wages and payment history

For Employers

• Post Jobs: Quick job posting with requirements and wages
• Worker Search: Find workers based on skills and availability
• Communication: Direct messaging with potential workers
• Hiring Management: Track applications and hiring status

Technical Architecture

Mobile App (Flutter)

• Clean architecture with separation of concerns
• BLoC pattern for state management
• Offline-first approach with local caching
• Push notifications for job alerts

Backend (Spring Boot)

• RESTful API design
• MongoDB for flexible data modeling
• JWT-based authentication
• Real-time messaging integration

Deployment

• Android app distributed via Play Store
• Backend hosted on cloud infrastructure
• Scalable architecture to handle growing user base

Social Impact

• Employment Access: Helped hundreds of workers find daily wage jobs
• Income Stability: Reduced idle days for workers by connecting them with opportunities
• Fair Wages: Transparent wage information empowered workers to negotiate better
• Digital Inclusion: Brought digital tools to traditionally underserved communities

Challenges Addressed

• Low Digital Literacy: Designed extremely simple, icon-based interfaces
• Language Barriers: Implemented multi-language support with regional languages
• Connectivity Issues: Built offline-first features for areas with poor internet
• Trust Building: Implemented rating and review systems for both workers and employers

Technologies Used

Flutter, Dart, Spring Boot, Java, MongoDB, Android, REST APIs, Push Notifications, Material Design

Personal Reflection

Working on Badli was incredibly rewarding as it combined technical challenges with meaningful social impact. Seeing the platform help real people find work and improve their livelihoods reinforced my belief in using technology for social good.

Drop Shadow Image Package

Published an open-source Flutter package that provides an easy-to-use widget for adding customizable drop-shadow effects to images, enhancing visual appeal in Flutter applications.

Package Overview

The Drop Shadow Image package simplifies the process of adding professional-looking drop shadows to images in Flutter apps. It offers extensive customization options while maintaining simplicity and performance.

Key Features

Customization Options

• Shadow Color: Full color customization with opacity control
• Blur Radius: Adjustable blur intensity for soft or sharp shadows
• Offset: Precise control over shadow position (X and Y axes)
• Spread: Control shadow size relative to image
• Border Radius: Support for rounded corners with matching shadows

Performance Optimized

• Efficient rendering using Flutter’s built-in painting APIs
• Minimal performance overhead
• Smooth animations when used with Flutter’s animation framework
• Optimized for both Android and iOS platforms

Developer-Friendly API

DropShadowImage(
  image: AssetImage('assets/profile.jpg'),
  borderRadius: 20,
  blurRadius: 10,
  offset: Offset(5, 5),
  scale: 1.0,
)

Technical Implementation

Widget Architecture

• Extended Flutter’s StatelessWidget for optimal performance
• Used CustomPaint for precise shadow rendering
• Implemented BoxDecoration for efficient shadow effects
• Support for both AssetImage and NetworkImage

Code Quality

• Comprehensive documentation with examples
• Unit tests for core functionality
• Null-safety support
• Follows Flutter package development best practices

Use Cases

• Profile Pictures: Add depth to user avatars
• Product Images: Enhance e-commerce product displays
• Gallery Apps: Create visually appealing image galleries
• Card Designs: Elevate card-based UI components
• Marketing Materials: Professional-looking promotional images

Community Impact

Pub.dev Statistics

• Published on pub.dev (Dart’s official package repository)
• Used by Flutter developers worldwide
• Positive community feedback and ratings
• Active maintenance and issue resolution

Open Source Contribution

• MIT License for maximum reusability
• Open to community contributions
• Detailed README with usage examples
• Responsive to feature requests and bug reports

Example Usage

import 'package:drop_shadow_image/drop_shadow_image.dart';

class ProfileCard extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return Card(
      child: Column(
        children: [
          DropShadowImage(
            image: AssetImage('assets/profile.jpg'),
            borderRadius: 50,
            blurRadius: 8,
            offset: Offset(3, 3),
            shadowColor: Colors.black.withOpacity(0.3),
          ),
          Text('John Doe'),
        ],
      ),
    );
  }
}

Learning Experience

Developing and publishing this package taught me:

• Package Development: Best practices for creating reusable Flutter packages
• API Design: Creating intuitive, developer-friendly APIs
• Documentation: Writing clear, comprehensive documentation
• Open Source: Managing an open-source project and community engagement
• Versioning: Semantic versioning and backward compatibility

Future Enhancements

• Support for multiple shadows
• Gradient shadow effects
• Shadow animation presets
• Performance optimizations for large images
• Additional shadow styles (inner shadows, glow effects)

Technologies Used

Dart, Flutter, Package Development, CustomPaint, BoxDecoration, Open Source

Links

• Pub.dev: pub.dev/packages/drop_shadow_image
• GitHub: Repository with source code and examples
• Documentation: Comprehensive API documentation

Contributing to the Flutter ecosystem through this package has been rewarding, and I continue to maintain and improve it based on community feedback.

AI Traffic Management System

Developed an intelligent traffic management system using reinforcement learning algorithms to optimize traffic signal control and routing strategies, achieving a 35% improvement in overall traffic flow efficiency through simulation.

Project Vision

Urban traffic congestion is a growing problem worldwide. This project explores how artificial intelligence and reinforcement learning can adaptively control traffic signals and optimize routing to reduce congestion and improve traffic flow.

Technical Approach

Simulation Environment (Unity + C#)

• Built a realistic traffic simulation using Unity game engine
• Modeled real-world traffic scenarios with multiple intersections
• Implemented vehicle physics and behavior patterns
• Created configurable road networks and traffic patterns
• Visualized traffic flow in real-time

Reinforcement Learning (Python)

• Implemented Q-Learning and Deep Q-Network (DQN) algorithms
• Trained agents to optimize traffic signal timing
• Developed reward functions based on:
  • Average vehicle wait time
  • Queue lengths at intersections
  • Overall traffic throughput
  • Congestion levels

State Representation

• Vehicle count per lane
• Queue lengths at traffic signals
• Current signal states (red/green)
• Average vehicle speeds
• Time of day (for traffic pattern variations)

Action Space

• Dynamic traffic signal timing adjustments
• Adaptive green light duration
• Coordinated signal control across intersections
• Route suggestions for vehicles

Key Features

Adaptive Signal Control

• Real-time adjustment of signal timing based on traffic conditions
• Prioritization of heavily congested directions
• Coordination between adjacent intersections
• Emergency vehicle priority handling

Intelligent Routing

• Dynamic route optimization to avoid congested areas
• Load balancing across alternative routes
• Predictive routing based on historical patterns
• Real-time traffic condition updates

Learning Capabilities

• Continuous improvement through experience
• Adaptation to changing traffic patterns
• Transfer learning across different road networks
• Handling of unexpected events (accidents, road closures)

Results and Performance

Metrics Achieved

• 35% improvement in overall traffic flow efficiency
• 40% reduction in average vehicle wait time
• 25% decrease in queue lengths at intersections
• 30% improvement in average vehicle speeds

Comparison with Traditional Methods

• Outperformed fixed-time signal control by 35%
• Better than actuated signals by 20%
• More adaptive than pre-timed coordination systems
• Faster response to changing conditions

Technical Implementation

Python Components

# DQN Agent for traffic signal control
class TrafficAgent:
    def __init__(self, state_size, action_size):
        self.model = self.build_model()
        self.memory = deque(maxlen=2000)
        
    def act(self, state):
        # Epsilon-greedy action selection
        if np.random.rand() <= self.epsilon:
            return random.randrange(self.action_size)
        return np.argmax(self.model.predict(state))
        
    def train(self, batch_size):
        # Experience replay training
        minibatch = random.sample(self.memory, batch_size)
        for state, action, reward, next_state, done in minibatch:
            target = reward + self.gamma * np.amax(
                self.model.predict(next_state))
            self.model.fit(state, target, epochs=1, verbose=0)

Unity Integration

• C# scripts for traffic simulation
• Python-Unity communication via sockets
• Real-time visualization of AI decisions
• Performance metrics dashboard

Challenges Overcome

Reward Function Design

• Balancing multiple objectives (wait time, throughput, fairness)
• Avoiding local optima in optimization
• Handling sparse rewards in complex scenarios

Scalability

• Training on large road networks
• Computational efficiency for real-time control
• Generalization across different traffic patterns

Simulation Realism

• Modeling realistic driver behavior
• Accounting for pedestrians and cyclists
• Simulating various weather and time-of-day conditions

Learning Outcomes

This project deepened my understanding of:

• Reinforcement Learning: Q-Learning, DQN, policy gradient methods
• Simulation Design: Building realistic environments for AI training
• Optimization: Multi-objective optimization in complex systems
• Python-Unity Integration: Cross-platform communication
• Performance Tuning: Optimizing ML models for real-time applications

Future Enhancements

• Integration with real traffic camera data
• Multi-agent reinforcement learning for city-wide optimization
• Incorporation of public transportation priorities
• Pedestrian and cyclist safety considerations
• Weather and event-based traffic prediction

Technologies Used

Python, TensorFlow/Keras, NumPy, Reinforcement Learning, C#, Unity, Simulation, Machine Learning, Deep Q-Networks

Impact

This project demonstrates the potential of AI in solving real-world urban challenges. While developed as an academic project, the techniques and insights gained are applicable to actual smart city initiatives and intelligent transportation systems.

The 35% efficiency improvement achieved in simulation suggests significant potential for reducing congestion, emissions, and commute times in real-world deployments.

Instagram DM Wrapper

A dedicated “DM-only” client for Instagram designed to eliminate social media distractions. This app wraps the Instagram web interface and uses aggressive filtering to ensure you only see your messages.

The Problem

Standard social media apps are designed to keep you scrolling. Even when you just want to check a message, you’re often pulled into the Feed, Reels, or Explore page, leading to hours of lost productivity.

The Solution

The Instagram DM Wrapper provides a focused environment by:

• Direct Boot: Automatically navigates to the DM inbox on startup.
• Aggressive Distraction Blocking: Removes the Feed, Reels tab, and Explore tab using custom CSS.
• Navigation Control: Intercepts URL requests to block accidental navigation to distracting parts of the site.

Key Features

DM Focused

The app acts as a standalone messenger. By targeting instagram.com/direct/inbox/ directly, it bypasses the main landing page.

CSS Injection

I implemented a robust CSS injection system that hides UI elements responsible for distractions:

• Hides the home navigation link.
• Removes the Reels and Explore sidebar/bottom bar items.
• Cleans up the interface for a minimal, messenger-like look.

Navigation Interception

Using flutter_inappwebview, the app monitors every URL request. If a user clicks a link (or a script tries to redirect) to /reels/ or /explore/, the app blocks the request and keeps the user within the DM context.

Immersive & Native Feel

• Edge-to-Edge Design: Full-screen experience without browser chrome.
• Android Back Gesture: Correctly handles the system back button to navigate internal web history instead of closing the app.
• Dark Mode: Optimized for a sleek, dark aesthetic.

Technical Implementation

WebView Configuration

The core of the app uses InAppWebView with specialized settings:

• incognito: true (optional) for privacy.
• transparentBackground: true for seamless UI integration.

Back Button Handling

onWillPop: () async {
  if (await webViewController.canGoBack()) {
    webViewController.goBack();
    return false;
  }
  return true;
},

Impact

This project has significantly reduced my own screen time by allowing me to stay connected with friends without falling into the “infinite scroll” trap. It’s a prime example of using technology to regain control over digital habits.

Technologies Used

Flutter, Dart, flutter_inappwebview, CSS, JavaScript (for DOM manipulation).

Meet A Doc

Meet A Doc is an android app made to ease the appointment booking procedure for both doctors and patients. You can book appointment to your desired Doc at cost of someclicks. Making it easy to use because of the simplistic UI, robust code and very optimized backend.

The app was written in Flutter using Android Studio as IDE. Backend written using Spring Boot.

TipCalculator

TipCalculator is a solution to those people who have difficulty in splitting money in restuarant and other places. It gives simple UI and easy to use app.

The app was written in Dart using Android Studio as IDE. I Learned how to use different widget of flutter in application.

ContactCard

ContactCard is basic app intended to share your contact information with the other.

The app was written in Dart using Android Studio as IDE. I Learned how to use different widget of flutter and also learned to add custom fonts, icons in application.

Quotify

Quotify was built to entertain the quote enthusiast around the world by fetching quotes at tip of buttons. It’s easy to use.

The app was written in Dart using Android Studio as IDE. I Learned how to fetch data from api and how to map their JSON responses, how to use different widget of flutter and also learned to add custom fonts.

Markulator

Markulator is fast, reliable marks handling app for a class which gives you addition features like average marks of whole class.

The app was written in Java using Android Studio as IDE. I Learned how to use fragments, how to control fragments, how to use SQLite database in app and how to do CRUD operations on databse etc.