Deployed the first version of the AI IDE extension.

Empowering Women Through AI: Building a Legal & Financial Advisor

Access to clear, actionable legal advice is still a major hurdle for a lot of people. Legal documents, statutory frameworks, and rights-related literature are often written in heavy jargon that is nearly impossible to parse if you don't have a background in law. For women navigating questions around workplace rights, property ownership, domestic safety, or financial independence, this barrier can feel even higher.

To help bridge this gap, I built Legal Advisor Chatbot—a targeted conversational platform designed to give women direct, easy-to-understand insights into their legal rights and key financial concepts.

The Problem

When someone faces a legal or financial issue, getting reliable answers quickly usually comes with two main challenges:

1. High Cost & Friction: Professional consultation isn't always immediately accessible or affordable.
2. Dense Terminology: Raw legal statutes and financial terms are rarely written for everyday comprehension.

Standard chatbots can give general summaries, but they frequently miss domain-specific grounding. The main goal of this project was to take complex legal framework information and break it down into clean, empathetic, and easily digestable advice.

Tech Stack & Architecture

The project relies on a full-stack architecture built to keep response times fast while managing conversational state smoothly.

• Frontend: Built with React. It handles the interactive chat flow, message state management, and real-time streaming updates.
• Backend: Powered by a lightweight API service to bridge client interactions with the intelligence layer.
• AI & Knowledge Pipeline: Uses retrieval workflows (via LangChain / RAG patterns) grounded on legal documentation and financial resources to keep answers focused and accurate.

Deep Dive: Mastering Modern React & Redux — A 75.5-Hour Engineering Journey

• Published: June 13, 2025
• Category: Web Development / Learning Log
• Read Time: ~8 min read
• Topics: React, Redux Toolkit, RTK Query, JavaScript (ES6+), Tailwind CSS, Custom Hooks

Over the past few months, I dedicated 75.5 hours of focused study and hands-on coding to complete Stephen Grider and Sanjay Azhagan’s intensive Modern React with Redux course on Udemy.

Rather than just watching lectures passively, I built every project from scratch, refactored state management layers, and dissected how React handles rendering under the hood. Here is a comprehensive technical breakdown of everything I learned, engineered, and mastered during this deep dive.

1. Deconstructing the React Core: Rendering & Mental Models

Mastering React requires moving beyond basic JSX syntax to understand the Virtual DOM, rendering cycles, and state immutability.

The Component Engine & Functional Patterns

• Virtual DOM & Reconciliation: Learned how React compares virtual element trees using the diffing algorithm to minimize actual DOM manipulations, ensuring maximum UI responsiveness.
• Unidirectional Data Flow: Standardized component design around strict top-down data flow via props and bottom-up event notifications via callback triggers.
• Component Composition over Inheritance: Utilized the children prop pattern to build highly configurable structural wrappers, isolating layout logic from domain specific business data.

// Example of clean component composition for reusable panel containers
function Panel({ children, className, ...rest }) {
  const finalClassNames = classNames(
    'border rounded p-3 shadow bg-white w-full',
    className
  );

  return (
    <div {...rest} className={finalClassNames}>
      {children}
    </div>
  );
}

Advanced Hooks & Side-Effect Synchronization

• useState Batching & Functional Updates: Mastered state updater functions (prevCount => prevCount + 1) to eliminate race conditions in rapid asynchronous updates.
• useEffect Lifecycle Discipline: Dissected synchronization cycles, dependency arrays, and essential cleanup functions to prevent memory leaks in websocket connections and event listeners.
• Custom Hooks Extraction: Abstracted stateful UI logic into standalone custom hooks (e.g., useSort, useNavigation, useThunk) to maintain single-responsibility modules across the codebase.
• useRef for Persistent Non-State Data: Leveraged refs for direct DOM element access (focus management, measuring layout coordinates) without triggering unnecessary render passes.

2. Scalable State Architecture: Context API vs. Redux Toolkit

Managing client-side state efficiently is one of the hardest parts of frontend architecture. This course provided a deep contrast between local context providers and global state machines.

       [ Client Request / Event ]
                   │
                   ▼
         [ Dispatch Action ]
                   │
                   ▼
    ┌─────────────────────────────┐
    │     Redux Toolkit Store     │
    │  ┌───────────────────────┐  │
    │  │ Immer Immutable State │  │
    │  └───────────────────────┘  │
    └──────────────┬──────────────┘
                   │
         [ Auto-Trigger Re-render ]
                   │
                   ▼
         [ UI Component View ]

Context API for Feature-Level Isolation

Built custom Context Providers paired with custom hooks to solve "prop-drilling" across deeply nested component trees. Ideal for localized configuration settings, theme switching, or feature-bound application states.

Redux Toolkit (RTK) for Enterprise Global State

When local context causes widespread re-renders, Redux Toolkit becomes essential. I implemented clean state slicers, explicit action dispatches, and normalized store structures:

• Slices & Immutable Operations: Created modular slices using createSlice, leveraging Immer.js behind the scenes to write safe, readable "mutating" syntax that outputs pure immutable state trees.
• Redux Thunks for Async Operations: Managed asynchronous API lifecycles through explicit pending, fulfilled, and rejected action dispatches to handle loading spinners and dynamic fallback states seamlessly.
• RTK Query for Advanced Data Fetching: Shifted from manual fetching to RTK Query's automated caching, request deduplication, optimistic UI updates, and tag-based cache invalidation (providesTags and invalidatesTags).

3. UI Engineering & Reusable Component Systems

A major highlight of this learning log was building a full-featured, zero-dependency UI component library styled with Tailwind CSS.

Component Library Tree
 ├── Accordion (Toggle state & icon animations)
 ├── Dropdown (Custom click-outside listener via useRef)
 ├── Modal Overlay (DOM Portal mounting to document.body)
 └── Sortable Table (Generic column mapping & sorting logic)

Highlights of Components Developed:

• Custom Dropdown with Global Event Listeners: Integrated direct document event bindings inside useEffect with target check validation (ref.current.contains(event.target)) to close dropdown menus when users click outside.
• Accessible Modals using React Portals: Utilized createPortal to mount modal overlays directly to secondary DOM container nodes (document.body), guaranteeing absolute z-index isolation from parent layout bounds.
• Dynamic, Sortable Data Table Engine: Engineered a generic <Table/> engine capable of receiving abstract column configurations and rendering sorted dataset pipelines via custom useSort hooks.

4. Key Projects Built During the Course

To solidify these patterns, I built several end-to-end applications:

1. Unsplash Media Search Engine

• Tech Stack: React, Axios, Tailwind CSS
• Key Feature: Asynchronous media search interface with dynamic input debouncing to prevent API quota throttling during live typing.

2. Tailored UI Component Library

• Tech Stack: React, Tailwind CSS, Custom Hooks, Portals
• Key Feature: Fully accessible design system with custom accordions, modals, panels, buttons, and sortable dynamic tables.

3. Enterprise Photo & User Management Platform

• Tech Stack: React, Redux Toolkit, RTK Query, Json-Server
• Key Feature: Full CRUD application utilizing RTK Query endpoints for real-time user creation, album management, and lazy-loaded image generation with instant tag-based cache invalidation.

5. Course Completion & Certification Metadata

Here are the official verification credentials for this milestone:

• Course Title: Modern React with Redux [2024 Update]
• Instructors: Stephen Grider, Sanjay Azhagan
• Total Duration: 75.5 Hours
• Completion Date: June 13, 2025
• Credential ID: UC-fc37bfa8-8543-4c27-b989-a78beadd595d
• Verification Link: Verify Certificate on Udemy

Reflections & Next Steps

Investing 75+ hours into this course significantly elevated my frontend development proficiency. Moving from basic component structures to architecting complex state flows with Redux Toolkit and RTK Query has prepared me to tackle enterprise-scale web applications.

Next up, I will be combining these advanced React state management techniques with Next.js for server-side rendering and extending these frontend architectures into full-stack and Web3 user interfaces!