WebCodeGenie - Jr. Software Developer

April 2024 – May 2026 • Ahmedabad, India • In-Office

Internship (6 Months) → Converted to Full-Time SDE

Android Native · Kotlin · Jetpack Compose · MVVM · Real-Time Systems · Offline-First Architecture

At a Glance

Organization WebCodeGenie, Ahmedabad

Designation SDE — Mobile Application Developer (Android Native)

Total Tenure 2 Years 2 Months

Employment Path 6-Month Internship → Full-Time SDE Conversion

Work Mode In-Office

Applications Built from Scratch 3 — Winech, Mario's Admin, HRMS

Applications Under CI/CD Ownership 2 — Mario's Towing (Customer & Driver)

Core Domain Android Native Mobile Application Development

Overview

WebCodeGenie is where my journey as a Software Development Engineer genuinely began — not as a finished developer, but as someone who had to learn how to think, build, and ship like one.

I joined as a Mobile Application Developer and spent over two years evolving from an intern learning the fundamentals of Android development into a full-time engineer independently owning the architecture, delivery, and reliability of production mobile applications used by real customers in the field.

That path ran from solving my first DSA problem to building live location-tracking systems relied on by drivers and customers in time-sensitive situations — from writing my first line of Kotlin to architecting offline-first systems that keep working when the network doesn't.

Across this tenure I:

• Designed and built three complete mobile applications from scratch, each solving a distinct real business problem end-to-end

• Took shared ownership of CI/CD pipelines for two production applications, ensuring reliable, consistent releases

• Worked across multiple independent MVVM architectures, implemented Dependency Injection with Hilt/Dagger, engineered Google Maps live tracking over real-time sockets, built Room DB offline-first sync, and designed centralized network failure handling that keeps the user experience coherent even when the backend isn't

This document walks through that journey in three chapters: the foundation phase, the core project, and the applications I delivered solo.

Chapter 1 — The Foundation Phase

## Building the Engineer Behind the Code · Months 1–6

Before I touched a line of production code, I went through a structured six-month training and internship program — and looking back, this phase mattered as much as anything I built afterward. It wasn't designed to teach me syntax; it was designed to rewire how I approached problems. Instead of jumping straight to how do I code this, I learned to first ask what is actually being asked, and what is the simplest way to solve it. That shift became the foundation for everything that followed.

Stage 1 — Sharpening the Problem-Solving Mindset

Months 1–3

This stage wasn't about writing app features. It was about training the brain to think like an engineer, long before writing a single line of Android code.

• Solved a consistent, high volume of Data Structures & Algorithms problems, sharpening logical reasoning, pattern recognition, and — most importantly — the ability to break an intimidating problem into small, solvable steps instead of freezing at the size of it.

• Practiced critical thinking and structured logic implementation, learning to approach ambiguous, half-defined problems methodically rather than guessing through them.

• Took part in hands-on team collaboration and management exercises — explaining technical ideas clearly, dividing ownership fairly, and working in sync with others. This proved essential later when collaborating across multi-developer projects and coordinating CI/CD releases with a senior engineer.

• Built genuine command of the Ubuntu operating system and CLI — environment setup, file systems, permissions, and terminal-based workflows. The kind of comfort with a real dev environment that only comes from living in it, not watching tutorials.

• Closed the stage with an evaluation that identified my strongest fit, routing me into Mobile Application Development — the domain I have now spent two years in.

Stage 2 — Learning to Build for Android, the Right Way

Months 4–6

With the thinking foundation in place, this stage turned theory into real, working, well-structured Android applications — not toy projects, but code built the way production teams actually build it.

• Learned Kotlin from the ground up, progressing from basic syntax to clean, idiomatic, production-style code — the language that became my primary tool as an engineer.

• Studied Android Native fundamentals in depth: how an app actually starts, runs, communicates with the system, and renders to the screen — rather than only knowing which functions to call.

• Learned Jetpack Compose, Android's modern declarative UI toolkit, building interfaces the way apps are built today — reactive, component-driven, and maintainable — instead of relying on older XML layouts.

• Implemented the MVVM (Model–View–ViewModel) architectural pattern, learning not just how to use it but why it exists: cleanly separating UI, business logic, and data so code stays maintainable as an app grows in complexity.

• Ended with a formal Knowledge Transfer (KT) handover onto a live production project — the moment I stopped being a trainee and became a contributing engineer.

**Outcome of this chapter:** I came out of this internship with something more valuable than a checklist of tools — a genuine engineering foundation in how to think, structure, and communicate. That foundation earned me a **conversion into a full-time SDE role**, and it's the same foundation I still lean on when facing unfamiliar problems.

Chapter 2 — The Core Project: Mario's Towing

## Customer & Driver Applications · Production, Live, Real-Time

After onboarding, I was assigned to Mario's Towing — a production-grade, two-app ecosystem consisting of a Customer App and a Driver App, both actively used by real people in genuinely time-sensitive situations.

This project became the defining chapter of my career so far. It's where I stopped being someone who learned Android and became someone trusted with live systems. Working alongside my senior to manage CI/CD and ship features, I grew more in technical depth here than in any other stretch of the journey.

Key Responsibilities & Contributions

1. Owning Two Parallel Architectures

The Customer and Driver apps served fundamentally different user journeys — one focused on requesting help, the other on fulfilling it — so each ran on its own independent MVVM setup. Working across both meant I wasn't repeating a single pattern by rote; I had to genuinely understand why each architecture was shaped the way it was and adapt my implementation accordingly. That gave me a far more flexible understanding of MVVM than a single uniform codebase ever would have.

2. Building Clean, Testable Code with Dependency Injection

I implemented Hilt/Dagger for Dependency Injection across both applications. Beyond cleaner code, this decoupled components in a way that made the codebase genuinely easier to test, extend, and hand off — a foundational shift that paid off every time a new feature had to be added without breaking existing functionality.

3. Real-Time Location Intelligence — Google Maps & Live Tracking

The most technically demanding and rewarding part of the project. I integrated Google Maps APIs for real-time location rendering and engineered the tracking pipeline using socket-based real-time events, so a driver's live position updated on the customer's screen accurately, instantly, and without lag. This wasn't a peripheral feature — it was the core promise of the product: knowing exactly where help is, right now.

4. Designing for Offline Reliability

Tow truck drivers don't operate in perfect network conditions — they work on highways, in dead zones, in bad weather. To make the app resilient to that reality, I implemented Room Database to power an offline-first syncing system, so the app stayed usable and data stayed accurate even when connectivity dropped entirely, automatically catching up the moment the connection returned.

5. Centralized Network Failure Handling

Rather than letting network errors surface inconsistently — a frozen screen here, a silent failure there — I designed and built a centralized network failure management system, including an automatic, app-wide Server Under Maintenance state that triggers the moment the backend becomes unavailable. This replaced a confusing, broken-feeling experience with clear, honest, consistent communication to the user.

6. CI/CD Ownership

Working alongside my senior, I helped manage and maintain the CI/CD pipelines for both the Customer and Driver applications — contributing to faster, more predictable, and more reliable release cycles for a product people actively depended on.

Tech Stack

Kotlin Jetpack Compose MVVM Hilt / Dagger (DI) Room DB Google Maps API Socket / Real-Time Events CI/CD

Chapter 3 — Independent Builds

## Applications Designed, Built and Delivered Solo

Alongside Mario's Towing, I independently designed, built, and delivered three additional applications for the company — each owned by me from the first line of code to final deployment, each solving a distinct business problem.

Winech — QR Code Seat Allocation System

An in-house QR scanning application built to automate a previously manual, error-prone seat allocation process.

• Designed and built the complete QR code scanning flow, from camera capture through code validation.

• Engineered the logic so that on a successful scan, the app automatically assigns and displays the correct seat allocation number through a clean, dynamic popup — turning a clunky interaction into something instant and effortless.

• Owned the full experience end-to-end — scan, validate, allocate, confirm — with a focus on making it feel fast and error-free under real event conditions.

Mario's Admin App — Service Request & Attachment Management

An admin-facing application giving internal teams real visibility and control over service requests.

• Built the image and attachment upload system for service requests, allowing admins to attach supporting documentation directly to each request.

• Implemented dynamic offline-to-online synchronization using Room Database — data captured while offline syncs automatically and silently with the live server the moment connectivity returns, with zero manual steps from the user.

• Implemented Android WorkManager to run background sync tasks reliably even if the app was closed or the device restarted mid-process, ensuring no data was ever lost.

HRMS — Human Resource Management System

A complete in-house HR platform built to digitize and centralize the company's internal HR processes, replacing manual, fragmented tracking.

• Built the employee leave application workflow, letting staff request and track leave digitally instead of through informal channels.

• Implemented early leave and late check-in request workflows, bringing structure and accountability to attendance tracking.

• Built the optional holiday selection feature, letting employees choose from a defined set of optional holidays based on company policy.

• Delivered as a complete, end-to-end internal tool actively used company-wide, day in and day out, to run HR operations.

Skills Gained at WebCodeGenie

Category Skills

Languages Kotlin

UI Framework Jetpack Compose

Architecture MVVM (multiple independent implementations)

Dependency Injection Hilt, Dagger

Database Room DB — offline-first, dynamic sync

APIs & Real-Time Google Maps API, Socket Events, Live Tracking

Background Processing Android WorkManager

DevOps CI/CD Pipeline Management

Foundational DSA, Logical Problem Solving, Linux / Ubuntu CLI, Team Collaboration

Journey Timeline

APR 2024     ● Joined as an intern — training phase begins
             │ Months 1–3: DSA, structured problem solving, Ubuntu & CLI,
             │ team collaboration, evaluation → routed to Mobile Development
             │
             │ Months 4–6: Kotlin, Android Native, Jetpack Compose, MVVM
             │ Closed with KT handover onto a live production project
             │
OCT 2024     ● Converted to Full-Time SDE
             │ Assigned to Mario's Towing — Customer & Driver applications
             │ Two independent MVVM architectures, Hilt/Dagger DI
             │ Google Maps live tracking over real-time sockets
             │ Room DB offline-first sync, centralized failure handling
             │ Shared CI/CD ownership across both production apps
             │
             ● Independent builds delivered end-to-end, solo:
             │ Winech (QR seat allocation)
             │ Mario's Admin App (attachments + offline sync + WorkManager)
             │ HRMS (leave, attendance and optional holiday workflows)
             │
MAY 2026     ● Concluded a 2 year 2 month tenure as an Android Native SDE

This experience reflects my growth from a fundamentals-focused intern into a full-time Android engineer capable of independently owning architecture decisions, real-time systems, offline-first design, and end-to-end application delivery — not because I was told exactly how to do it, but because I learned, early on, how to think my way there.