DEV Community: Dinesh A

Why Software Teams Still Struggle to Ship, Even With AI

Dinesh A — Wed, 10 Dec 2025 10:23:01 +0000

AI is writing code.
AI is generating tests.
AI is assisting with pull requests and deployments.

Yet, even in this new era of GenAI-powered development, teams still face the same old question:

“Are we ready to ship?”

Because the problem was never only the code. The problem is where the work lives. The Modern Workflow Is Still Fragmented. Today’s software teams operate like this:

AI generates code in IDEs
Developers track tasks in Jira
Testers maintain test cases in Excel
Deployments run in cloud pipelines
Approvals disappear in email threads

AI made parts of the journey faster, But it didn’t make the journey clearer. And so, release day still sounds like:

“Did the AI-generated code get reviewed?”
“Do we have test coverage for this?”
“Which version was deployed?”
“Who approved what, and when?”

AI Isn’t the Problem; Our Tools Are

Generative AI introduced a new challenge:

We now track human and AI-generated work, but systems weren’t designed to differentiate between them, report on them, or govern them.

We moved faster,
But without traceability, we also moved riskier.

AI-generated code that didn’t go through testing
AI-written tests that didn’t reflect the requirement
Cloud deployments with no connected approval trail
Tickets closed by automations but never validated by QA

To solve this, we built Trackleaf.
AI accelerates execution - TrackLeaf adds the control.

TrackLeaf treats AI as a first-class contributor,
Every action, automation, or code commit is tracked, governed, and linked to outcomes.

Bugs convert to tasks automatically
Tests tie back to the exact requirement
AI-generated tasks labeled and audit-ready
Release readiness is visible in real time

For Leaders, Proof Over Promises

In a GenAI world, speed is a given; confidence is the differentiator.

TrackLeaf provides:

Audit trails for AI and human work
Real-time readiness dashboards
Traceability from requirement → code → test → deployment
Faster answers and fewer “status” meetings

Instead of guessing, leaders get proof.

The New Standard: Faster, Smarter, Traceable Shipping

GenAI will write more code.
AI agents will execute more tasks.
Automation will replace repetitive steps.

But visibility, ownership, governance, and release confidence still matter.

TrackLeaf ensures the answer to:

“Are we ready to ship?”

TrackLeaf: One tool to know you’re ready to ship, in the era of human & AI work.

www.trackleaf.in

For queries, contact: dinesh@trackleaf.in

Lit Web Components

Dinesh A — Tue, 18 Feb 2025 16:04:44 +0000

Web Components are web platform APIs allowing developers to create reusable, encapsulated, modular UI elements. Unlike traditional JavaScript frameworks, Web Components work natively in the browser, meaning they don't require additional dependencies.Web Components can be used across different projects and frameworks (reusable). Works with any framework or vanilla JavaScript.

A Web Component consists of three main technologies:

Custom Elements – Define new HTML elements with custom behavior.
Shadow DOM – Encapsulates styles and markup to prevent conflicts.
HTML Templates – Reusable chunks of HTML that can be used dynamically.

Lit

Lit is a lightweight library built on top of Web Components that simplifies their creation and usage. It provides simple syntax and built-in features. It can be used to build sharable components, design systems, and even sites and apps.

How to Create a Custom Lit Component?
Run the below command in the terminal to create a Lit project using Vite.

npm create vite@latest my-lit-app --template lit

Here’s a basic example of a Lit Web Component:

import { LitElement, html, css } from 'lit';

class HelloWorld extends LitElement {
  static styles = css`
    p { color: blue; font-size: 18px; }
  `;

  render() {
    return html`<p>Hello, World!</p>`;
  }
}

customElements.define('hello-world', HelloWorld);

How to use the built component?

<!DOCTYPE html>
<html lang="en">
<head>
  <script type="module" src="/path/to/my-component.js"></script>
</head>
<body>
  <hello-world></hello-world>
</body>
</html>

Lit makes working with Web Components easier, enabling developers to build fast, and reusable components with minimal overhead. Whether you're creating a small UI component or a full-fledged design system, Lit provides an efficient way to work with modern web standards.
Experiment with Lit: Lit Playground

Understanding the Factory Design Pattern with Node.js

Dinesh A — Mon, 03 Jun 2024 04:44:33 +0000

Design patterns are a crucial part of software engineering, helping to create robust, scalable, and maintainable code. There are various design patterns, the Factory Design Pattern is particularly useful for managing object creation.
Factory design pattern helps create objects without having to specify the exact class of the object that will be created. This is particularly useful in scenarios where the exact type of object may not be known until runtime.

Use cases of Factory Design Pattern

Whenever we create objects that have similar behavior or are closely related, we can use a factory design pattern.

In Swiggy, when we are creating orders, orders can be of type dine-in, delivery, or take-out. We have to decide at runtime what type of order should be created.
In Ola, when we are booking a ride, rides can be of type solo rides, share rides, or luxury rides. We have to decide at runtime what type of ride should be created. In both examples, the creation process is encapsulated using the factory design pattern.

Understanding with an example

Let's take an example of a notification system, there are different types of notifications including Email, SMS, and Push notifications. The type of notification required will be decided during runtime.

In Factory Pattern, the code will be split into 4 major parts.

Interface (Notification interface)
Concrete Classes (EmailNotification, SMSNotification, PushNotification)
Factory (Notification Factory)
Client

The interface acts as a blueprint for concrete classes. Each Concrete class extends the interface and provides its implementation of methods declared in the interface. Factory determines which concrete class to instantiate based on input parameters. The client utilizes the Factory to create instances of objects and Interacts with the created objects to perform actions.

Code

Notification Interface
First, we'll define a common interface for all types of notifications. In Nodejs, we'll use a base class with an abstract method to achieve this.

class Notification {
  send(message) {
    throw new Error('Method "send()" must be implemented.');
  }
}

module.exports = Notification;

Concrete Classes
Now, we'll create concrete classes for Email, SMS, and Push notifications that extend the base Notification class.

const Notification = require('./Notification');

class EmailNotification extends Notification {
  send(message) {
    console.log(`Sending email with message: ${message}`);
    // Email sending logic here
  }
}

class SMSNotification extends Notification {
  send(message) {
    console.log(`Sending SMS with message: ${message}`);
    // SMS sending logic here
  }
}

class PushNotification extends Notification {
  send(message) {
    console.log(`Sending push notification with message: ${message}`);
    // Push notification sending logic here
  }
}

module.exports = { EmailNotification, SMSNotification, PushNotification };

Notification Factory
Now, we'll create a factory class that will return the appropriate notification object based on the input.

const { EmailNotification, SMSNotification, PushNotification } = require('./notifications/Notifications');

class NotificationFactory {
  static createNotification(type) {
    switch (type) {
      case 'email':
        return new EmailNotification();
      case 'sms':
        return new SMSNotification();
      case 'push':
        return new PushNotification();
      default:
        throw new Error('Unknown notification type');
    }
  }
}

module.exports = NotificationFactory;

Client
Finally, we'll use the factory to create notification objects in our client code.

const NotificationFactory = require('./notifications/NotificationFactory');

const notificationType = process.argv[2]; // 'email', 'sms', or 'push'
const message = 'Hello, this is a test message!';
const notification = NotificationFactory.createNotification(notificationType);

notification.send(message);

What benefit did we get by following this factory design pattern ?

Encapsulation: It encapsulates the instantiation logic, making the code cleaner and more modular.
Decoupling: It decouples the client code from the concrete classes, promoting flexibility and maintainability.
Single Responsibility Principle: It adheres to the Single Responsibility Principle by delegating the creation logic to the factory class.
Open/Closed Principle: It adheres to the Open/Closed Principle, allowing new types to be added without modifying the existing client code.

Conclusions

The Factory Design Pattern is one of the best ways to manage object creation in a clean and decoupled manner. By incorporating design patterns like the Factory Design Pattern into development practices, we can write more robust, scalable, and maintainable code.

If you found this article helpful, connect with me on LinkedIn and follow my posts on DEV.to. Share your thoughts and questions in the comments below!

Smart India Hackathon 2023 winners

Dinesh A — Tue, 02 Jan 2024 09:31:58 +0000

Silence enveloped the room; all eyes focused on the podium, and every ear eagerly awaited the results. The announcement finally came: the winner of SIH1370 was Team DORA the Explorer. The moment those words echoed, joy and excitement filled the air. It was a remarkable feeling to become a two-time SIH winner.

Hello, everyone. I am Dinesh, and my team emerged victorious in the Smart India Hackathon 2023 software edition. We chose to tackle the problem statement "Real-Time Monitoring of Infrastructure" provided by the government of Jharkhand.

Why did we participate in SIH?

We participated in the Smart India Hackathon to learn and validate our entrepreneurial skills. The experience of forming a team, deciding on product features, and making it commercially feasible with a better user experience is invaluable. We wanted to build something that would create impact and solve real world problems. Participation in initiatives like SIH lays the foundation for later entrepreneurial ventures.

How did I form a team?

To build a well-rounded team, I sought diversity in both technical and non-technical skills. Eventually, I formed a team comprising Ishika Jain, Sidhanti Patil, Namrata Hakari, Gagan S, and Prince Thakkar. Our team covered designers, business developers, ML engineers, full-stack developers, and presenters. We named our team as Dora the explorer
Dora = Dynamic Observation Real Time Analysis.

How did we choose a Problem Statement?

We selected a problem statement aligned with our personal goals and within our skill set.
We had to choose one problem statement out of 234 problem statements. Criteria for choosing included: no dependencies, standalone solutions, fewer competitors, government not being the sole customer, monetization potential, large Total Addressable Market (TAM), and no hardware equipment's. Problem statement SIH1370, Real-Time Monitoring of Infrastructure, met these criteria, and we chose it to work on.

How do we approach a problem?

Our unique approach was that we didn't immediately jump into solutions or coding. Instead, we followed a design thinking strategy, spending 60% of our time understanding the problem, defining user needs, ideating solutions, prototyping, and testing.

Our Solution :

Our solution was built on an AI and GIS foundation, providing real-time monitoring capabilities to construction sites. Key features of our solution included:

Progress Tracking:
- Utilizing AI algorithms, we implemented progress tracking by comparing current images of construction sites with the previous day’s images captured through CCTV cameras.
- Material consumption at the site was also calculated through CCTV cameras to provide an additional metric for progress.
Project Management System: We developed an end-to-end project management system allowing contractors and project managers to create milestones, tasks, and assign them to site engineers with due dates and priority levels.
Mobile Application for Site Engineers: To facilitate daily progress updates, we created a mobile application for site engineers. Through this app, engineers could upload daily progress reports and mark the photos of completed work on the site plan.
GIS Mapping: All projects were mapped on GIS, enabling anyone to view the current status of any infrastructure project and analyze various patterns.

How did we validate our idea and solution?

We pitched our idea to various stakeholders, gathering feedback from friends, faculty, contractors, civil engineers, and ML specialists. This feedback helped us identify and address potential issues and refine our solution before the grand finale.

How did we choose a tech stack?

When selecting our tech stack, we prioritised a large community for support and ensured at least 50-60% familiarity within the team. Our tech stack included ReactJS, NodeJS, Express, MongoDB, React Native, Leaflet, Flask, and various ML algorithms.

What happened in the Finals?

Our finals were on December 19th, and our nodal centre was in Jaipur, Rajasthan. Travelling with my teammates was a fun experience filled with singing, playing, joking, and final preparations.

The finals comprised three judging rounds and two mentoring sessions.

The first judging round focused on presentation, uniqueness of the idea, and feasibility, accounting for 20% of the total weightage.
Judges emphasised inclusivity, urging us to ensure that no user could find fault with the product. They also set challenges for us to include air quality monitoring and make the product adaptable by integrating with other services. This round we did pretty well.

The second judging round focused on the tech and execution , accounting for 30% of total weightage.This round didn't go well as we misunderstood the term integrating but I guess we scored well as the round focused on execution. Judges challenged us to integrate various components, including ML models with the application, connect frontend with backend, and dynamically map projects on GIS for the final round.

The third round was forced on complete end to end product, commercial viability and end user perspective, accounting for 50% of the total weightage.
Guess what the application broke just one hour before the last round while integrating, we got multiple merge conflicts, finally we integrated by reverting code and implementing the latest changes by storing the code on WhatsApp messages.
We panicked while pitching at finals, and got stuck here and there, but everyone explained their parts which gave unexpected brownie points as all the team members were involved in the pitch. We put our end to end implementation plan on BMC, which also earned brownie points

And the rest is history.

Read about my SIH'22 journey here.

Setting Up Unity Editor for Android AR App Development: A Step-by-Step Guide

Dinesh A — Sun, 05 Nov 2023 15:56:56 +0000

Unity, the powerful real-time 3D development engine, empowers a collaborative effort between artists, designers, and developers to craft immersive and interactive experiences. In this article, we will guide you through the process of setting up the Unity editor to develop Augmented Reality (AR) applications for Android devices.

Let's dive into the steps:

Launch Unity Hub and Create a New Project:

Open Unity Hub and click on "New Project."
Select the "3D Core" template and give your project a name.
Click "Create Project" and allow Unity to initialize your project.

Configure Build Settings:

Navigate to "File > Build Settings."
Choose "Android" as your target platform and click "Switch Platform."

Enable Unity Registry:

Head to "Windows > Package Manager."
Ensure that "Unity Registry" is checked.

Install AR Foundation and Google AR Core XR Plugin:

Search for "AR Foundation" and install it.
Similarly, install the "Google AR Core XR Plugin."

Project Settings:

Go to "Edit > Project Settings."
Select "Player" from the left-side menu.
Provide your company name and product name.

Adjust Graphics Settings:

In the same window, navigate to "Other Settings."
Uncheck "Auto Graphics API" and remove "Vulkan" from the Graphics API list.

Set Minimum API Level:

Ensure that the "Minimum API Level" is set to "Android 7.0 - Nougat" (API level 24).

Configure Target Architecture:

In the same window, configure the "Scripting Backend" to IL2CPP.
Select the "Target Architectures" option and choose "ARM64."

Enable XR Plugin for AR:

In the Project Settings window, select "XR Plugin Management."
Check "Google AR Core" to enable it.

Prepare the Scene:

Close the Project Settings window.
Delete the "Main Camera" from the Hierarchy.

Set Up XR Components:

Right-click on the Hierarchy panel.
Select "XR > AR Session."

Add XR Origin:

Right-click on the Hierarchy again.
Select "XR > XR Origin."

Add Scenes to Build Settings:

Go to "File > Build Settings."
In the Build Settings window, locate the "Scenes In Build" section.
Drag and drop your scene from the Hierarchy panel to add it to the list of scenes to build.

With these steps completed, your fundamental setup for developing AR applications on Android devices is ready. You are now well-prepared to proceed with your AR development endeavors.

Hackathon through organizers eye

Dinesh A — Tue, 27 Jun 2023 09:02:25 +0000

Most of you folks may have participated in various hackathons, but have you ever wondered what it takes to organize one? 🤔 As one of the organizers, I had the privilege of witnessing the incredible journey of our event, Hackman v6, from start to finish. 👀

Hackman v6 is an annual 24-hour hackathon conducted by the Department of ISE, DSCE on June 24th-25th, 2023. It provides the brightest minds with a chance to brainstorm as a team, come up with unique solutions, code them out, and solve some of the pressing problems of our society. 💡💻

Intro:

The planning for the event started back in April 2023, where we began forming teams, deciding the theme of the hackathon, establishing a budget, seeking sponsors, designing posters, building websites, devising PR strategies, obtaining permissions from the college, inviting mentors and judges, and planning the schedule, among other tasks. 🗓️💡💼

Due to various reasons like exams and placements, we were not as active until the last three weeks of Hackman. However, what we accomplished in those three weeks is truly incredible. 🚀🏆

Highlights:🌟

We secured Unibic, HueLearn, Vendo Smart, 50 Fin, and Bullz as sponsors. 🎉💼
We invited mentors from PhonePe, Amazon, Open Craft, Luma Chain, and others. 🤝👩‍🏫👨‍🏭
We received 170 registrations from 46 teams in less than a week, leading us to close registrations due to logistical constraints. 📝📈
We raised funds and had a prize pool of 37K, as well as provided internship opportunities to participants. 💰🏅🎓

Challenges we encountered: 💪🚧

Getting Sponsors
Initially, we faced difficulties in raising enough funds to organize the event. However, the entire team came together, regardless of their assigned tasks, and worked towards securing funds. Eventually, we managed to gather enough funds from the college and sponsors to conduct the event. 💸🤝

Check-In System Crash
We developed a web app to streamline attendance tracking and manage food distribution using QR technology. However, the night before the event, the app crashed due to mismatched peer dependencies. We had to stay up all night to fix it, and by 5:45 AM, we managed to push the application to production, and it worked. 😴🔧💻

Internet Issues
Initially, we were unable to provide the required internet bandwidth to participants during the first two hours. We were assured that we had been allocated 500Mbps, but when we connected directly to the LAN, we only got 10Mbps for a single connection. Additionally, the router designed to connect 32 devices couldn't connect to more than 9 devices, and the ACL was not working. To solve this, we brought new routers from EDP and connected them to the main server in the DSLD lab, providing a stable internet connection to the participants. 🌐📶🔌

These were just a few of the challenges we faced and overcame while organizing this hackathon.

Conclusion:

In conclusion, organizing a hackathon is a challenging yet rewarding endeavor. The journey from the initial planning stages to the successful execution of the event is filled with hurdles and obstacles that require determination, teamwork, and problem-solving skills. 🌟🤝💪

Smart India Hackathon 22 winners

Dinesh A — Sat, 27 Aug 2022 19:23:16 +0000

The winner for problem statement NR1174 is... team 01 Hum Bhi Bana Lenge, the moment we heard this statement from the juries, we could not resist our emotions, tears in our eyes, people congratulating us all over the path to the stage and receiving a prize of one lakh, The last night was overwhelming.

From strangers to the best team ever the journey was remarkable. It all started on 13th December 2021 me searching for teammates, and finally found the final team Vinit Hanabar, Ishika Jain, Prince Thakkar, Janvi Kumari, Dheeraj Gajula, after many rejections and firing. There were approximately 600 problem statements and had no clue to select PS. Luckily seniors at Point Blank chose 20 PS and gave it to us. I knew that neither I nor my teammates were technically strong, so we chose a PS that involves a lot of critical thinking and innovation in terms of solutions that can be implemented with the tech that we are familiar with. As I was part of IEDC DSCE I did know some of the business strategies, marketing and how startups work. With all these we choose the PS that aims to increase the efficiency of courts and reduce the timeline of pendency of cases. We usually had meets @10 pm and sometimes it continued till 3am in morning, In all those meets we discussed more about the users-what they need, will they use our product, how to market it than the technical implementation, we submitted our ppt to SIH and was waiting for results which were declared in phases, we were checking the website 2 times a day and finally we got to know that we are selected for finals in the final phase of announcement.

Since all the team members stay in PG and different parts of Bangalore, we needed a common working place, so we requested ISE Hod Dr. Uday Kumar Reddy for space to work. To our surprise sir gave his new cabin for us to work, then we started to work and concentrated on technical implementation still keeping our end users in mind. We worked from 9am in the morning to 7pm in the evening, the hustle was real with a lot of fun. With all of these said ,we didn't have working model even one weak before finals, Yes we were scared, stressed and broke lot of times like others but we didn't give up even once as a team. The good part of team is they cared each other and nevertheless the obstacles at least one person in the team was energized at any given time, and lead the others. We came to ACS college, Bangalore on 25th of August and took a good sleep for the finals on the next day.

SIH’22 finals started on 26th August, we gave our pitch in the first evaluation round, jury members were impressed, and we were working on the minute changes told by juries, 2nd evolution round happened, and we were literally crying, as we didn't answer the questions, ml models were failing to deploy on cloud, backend api which was working till yesterday was not working, changes in frontend was not reflected in production. We called all the seniors we knew from IEDC DSCE, Point Blank and friends at Google Developer Student Club - DSI and spent the entire night on fixing this, Luckily we fixed most of this bugs but still we had some, 3rd and final evaluation was about to happen at 5pm and we pitched our best with the existing product .After evaluation we went to interact with all the teams, We had dinner and were waiting for results and rest is history.

We thank all the parents, friends, seniors, faculties, mentor Shubam Kumar Nigam, our SPOC Vindhya Malagi, principal Dr. C.P.S Prakash college and Mic for their support and help in all the terms and our mentoring panel Ganesh sir and Shruthi mam for their advice and support.