Reshaping Development Team Dynamics and ROI

 I’ve always been skeptical that small, agile teams could consistently deliver robust, production-ready applications. The complexities of modern software development have long seemed to require a roster of specialized professionals to successfully execute an entire SDLC project.

The skeptical veteran in me has had to confront the reality that irrespective of skills even individual developers are now equipped to drive initiatives that once demanded large, collaborative groups. My recent experience with an AI-powered development environment has been a true paradigm shift. Only recently have I come to fully appreciate the ground-level impact of these tools.

While having previously tested tools like GitHub Copilot and observed incremental gains in productivity. I still felt dependence on the expertise of specialists for nuanced or highly complex tasks. Those tools never completely changed that equation for me.

Now, even from a business perspective, the ROI is equally game-changing. Rather than investing heavily in consultants or maintaining large, narrowly focused teams, AI powered platforms like cursor.com streamline the entire delivery cycle. I am now absolutely convinced that by adopting these technologies, small-high-output agile teams are becoming an achievable standard.

Perils of Holiday Code Freezes

Holiday Code Freeze has now become an age-old practice where deployments are stopped, and it's aimed to reduce any risk of new bugs or issues in the system when a majority of support staff is away. However, this also means the servers and infrastructure are left untouched for several weeks, and surprisingly, in my experience, this can be a bit chaotic. 

Application and Database Leaks

First and foremost, the most common error noticed is the Application leak. I recall one particular instance where an e-commerce application began to slow down significantly a week into the holiday break. The application retained references to several objects that were not required, causing the heap memory to fill up gradually. As the memory usage increased, the application became sluggish, eventually leading to crashes and "out of memory" errors.

Leaks can also happen when connecting to a database. In another example, the same e-commerce application began experiencing intermittent outages. The root cause was traced to a connection leak where the application was not releasing database connections after it was used. As the number of open connections grew, the database server eventually refused new connections, causing the application to crash. 

Similarly, I have also experienced code freeze situations, where thread leaks were consuming system resources and slowing down the application. This typically happens when threads are created but not terminated. 

Array index out-of-bounds errors

Another issue I recently encountered during a recent freeze was the Array index out-of-bounds error. The application was a CMS, and system downtime started in the middle of a week when an application tried to access an index in an array that didn't exist. It happened due to unexpected input and data changes not accounted for in the custom code.

Array Index out-of-bound exceptions can also be caused by data mismatch when interacting with external services or APIs, not under code freeze. Once, during a holiday season, a financial reporting application began throwing array index out-of-bounds exceptions. The root cause was traced back to an external data feed that had changed its format. The application was expecting a certain number of fields, but the external feed had added additional fields, causing the application to attempt to access non-existent indices. It led to errors that took the application offline until a patch was deployed after the freeze.

Cache Corruption

Cache corruption is another potential way of bringing down heavy cache-dependent applications. In online real-time applications, caches improve the application performances, but, on several occasions, I have seen over time, if not cleared, caches can become corrupt, leading to stale and receiving of incorrect data.

COnclusion

While it's funny that IT stakeholders think that the code freeze aims to maintain stability, in most cases, they expose underlying issues that might not be apparent during regular operations. The even more funnier thing is that a majority of the time, these issues are resolved by a simple server restart.

Extracting running data out of NRC/Nike + (Nike Run Club) using API's

For the past few weeks, I have been struggling to see the running kilometers getting updated in my  Nike + App. It could be a bug or a weird feature of the app and since this was kind of a demotivation, I decided to go ahead and create my own dashboard to calculate the results. Also, for some reason, Nike discontinued viewing and editing activities on the web.

Considering I had about 8 years of data and you never know when this kind of apps stop to exist or when they become paid versions. It's always better to persist your data to a known source and if required use it to feed it into any other application. 

It turns out that there is a lot of additional information the NRC app captures which are typically not shown on the mobile app. Few of the information include 

1. Total Steps during the workout including detail split between intervals
2. Weather Details during the workout 
3. Amount of the time the workout was halted for 
4. Location details including latitude and longitude information that can help you plot your own Map

I ended up creating a  .NET MVC app for fetching the activities and displaying it locally.

The code can be downloaded here ->  https://github.com/shailendrabhatt/Nike-run-stats 

Below are some screen shots of the App

The code also includes a postman repository which contains a Collection that can also be used to fetch one's activities. Just update the {{access_token}} and run the Get requests.

Note :- Nike no longer supports or does not provide a public or officially supported API for individuals or third party developers to directly access to export workout data. 

Here are few latest ways (As of June 2025) to access the data.

• Fetching the Authorization token can be tricky and it has an expiry time. For that, you will need a https://www.nike.com/se/en/nrc-app account and fetch the authorization token from the XML HTTP request headers for the URL type api.nike.com. There are few requests hitting this URL and the token can be fetched from any of them.
• The bearer token can be seen in the URL --> https://api.nike.com/buy/lists/v1/39a71942-a408-4642-84e8-aadd4caffe89/items?filter=country(se) 

• The API described in the link shows details of  before_time information 

https://api.nike.com/plus/v3/activities/before_id/v3/*?limit=30&types=run%2Cjogging&include_deleted=false 

https://api.nike.com/plus/v3/activities/before_id/v3/before_id?limit=30&types=run%2Cjogging&include_deleted=false

• Pagination can be easily achieved using the before_id. These ids are of different formats ranging from GUIDs to a single-digit number and can be confusing.