Netscape

Click here to go the App and skip the explanation

LLM Integration & Routing Proof of Concept

Overview

Netscape is a lightweight AI chat application built to explore how large language models (LLMs) can be integrated into real systems through APIs.

The project intentionally focuses on architectural clarity, deployment fundamentals, and model abstraction rather than UI polish or feature completeness.

Its purpose is to reduce ambiguity around AI adoption before teams commit to production-scale solutions.

Architecture Diagram

┌─────────────────────────────┐
│        Web Browser          │
│  index.html + main.js       │
│  - Prompt input             │
│  - Model selection          │
│  - Optional file upload     │
└─────────────┬───────────────┘
              │ POST /api/chat
              │
┌─────────────▼───────────────┐
│        Express Server       │
│          server.js          │
│                             │
│  - CORS                     │
│  - Multer (file handling)   │
│  - Env config               │
│  - Model routing logic      │
└─────────────┬───────────────┘
              │
              │ Chat Completion Request
              ▼
┌─────────────────────────────┐
│        OpenAI API           │
│     (LLM Provider)          │
└─────────────┬───────────────┘
              │
              │ Model Response
              ▼
┌─────────────────────────────┐
│        Express Server       │
└─────────────┬───────────────┘
              │ JSON Response
              ▼
┌─────────────────────────────┐
│        Web Browser          │
│   Response Rendering        │
└─────────────────────────────┘

Problem

Many teams evaluate AI tools in isolation — through browser-based chat interfaces or one-off scripts. This makes it difficult to understand how LLMs behave when embedded inside real applications, combined with internal data, and operated under practical constraints.

As a result, architectural decisions are often made without hands-on validation.

Goal

Create a simple, deployable proof of concept that demonstrates:

• How to integrate an LLM via API
• How to abstract model selection behind a backend
• How a frontend can remain decoupled from AI providers
• How this pattern can be extended to internal tools

Architecture Overview

The application follows a straightforward client–server design.

Frontend

• Basic HTML interface for prompt input, model selection, and optional file upload
• Sends requests to the backend via HTTP

Backend

• Express.js server
• Handles request processing, model routing, file uploads, and secure API key usage
• Communicates with the LLM provider via API

External Service

• OpenAI API (currently using gpt-3.5-turbo)

All LLM interaction is owned by the backend. The frontend never accesses the provider directly.

How It Works

1. A user enters a prompt and selects a model
2. The frontend sends a POST request to the backend
3. The backend processes the input and calls the LLM API
4. The response is returned and displayed in the UI

The system is intentionally stateless and minimal, mirroring common production patterns without unnecessary complexity.

Use of AI

AI development tools were used to:

• Scaffold the application structure
• Generate API integration code
• Accelerate setup and iteration during deployment

AI was treated as an execution accelerator — not a replacement for understanding system behavior or architectural decisions.

Applying This to Modern Software Quality Engineering

One of the primary motivations behind Netscape is exploring how LLMs can be embedded into internal systems used by Software Quality Assurance teams.

Using the same backend-driven API pattern, an SQA organization could:

• Integrate LLMs into internal QA tools rather than external chat interfaces
• Combine LLM reasoning with proprietary data such as existing test cases, historical defect data, and requirements/acceptance criteria
• Use AI to assist with test design while maintaining human review and ownership

Example application: An internal tool that sends requirements and historical QA data to an LLM to generate candidate test cases, edge scenarios, and negative paths — accelerating test creation without removing human judgment.

Leadership Perspective

As a director, I build proofs of concept like Netscape to understand technologies end to end before asking teams to adopt them.

This approach allows me to:

• Identify real integration boundaries
• Evaluate tradeoffs early
• Guide teams with working examples rather than assumptions

The value of this project is not the app itself — it’s the clarity it creates.

What I’d Change for Production

• Support for multiple LLM providers
• Authentication and usage tracking
• Cost and latency monitoring
• Persistent conversation state
• Prompt governance and safety controls

Click here to go the App