Dev Log: June 30 Wrap-up

Overview

Today was a bit of a shift in gears. After spending a lot of time on the heavy 'plumbing' of the backend yesterday, I spent today focusing on the user experience and session management within the CRM modules. It was one of those days where you realize how much work goes into just making sure the app 'remembers' who the user is as they navigate around.

What I Worked On

Refining User Context

In our CRM, we deal with different roles like partners and distributors. Keeping their identity consistent across different views—like when they're jumping between a list of customers and creating a new deal—was getting a bit messy. I spent some time updating the core app service to handle these identities more reliably.

I implemented a way to fetch and store these details in local storage, but I didn't want to just dump plain text in there. I added a layer of encryption for these stored names. It's not just about security; it's about making the whole system feel more integrated. Now, if a partner goes to add a new deal, the system is smart enough to pull their identity from the session and pre-fill the form. It saves a few clicks and makes the app feel context-aware.

Handling the 'Loading' Jitters

The dashboard was looking a little bit unfinished because of how the data was popping in. When you have five or six different API calls all trying to populate various KPIs, the screen can jump around quite a bit. I added a proper loading state to the dashboard, but I had to be careful with how I tracked it.

I used a simple request counter to make sure the spinner stays visible until the last request finishes, rather than disappearing when the first one comes back:

// Simple counter to manage the loading spinner across multiple calls
private activeRequests = 0;

private startRequest() {
  this.activeRequests++;
  this.isLoading.set(true);
}

private finalizeRequest() {
  this.activeRequests--;
  if (this.activeRequests <= 0) {
    this.isLoading.set(false);
  }
}

It's a small change, but it makes the initial dashboard load feel way more intentional and less glitchy.

Reflecting on the Java 21 Migration

I’m finally feeling the relief of having the Java 21 migration behind me. The last few days were a bit of a battle with annotation processors and wrestling with JDBC connection strings. I'm glad I decided to manually map the environment variables in the config rather than trying to parse a complex URI string in the code. It’s much cleaner, and the YAML file is now a lot more readable for anyone else who might have to touch the deployment config later.

Wrapping Up

The 'invisible' infrastructure work is finally stable, and the UI is starting to catch up. It feels good to have the app properly identifying users and behaving consistently as they move through different modules. Tomorrow I’ll likely focus on some of the data binding in the partner dropdowns to make sure that 'context-awareness' is solid across the board.