G GUID Solutions

GUID Solutions

Agentic software development, rapid prototyping, and systems architecture for intelligent products.

GUID Solutions is Ronnie Guidry’s product studio for agentic software development, rapid prototyping, systems architecture, and decision systems. The analytics and experimentation background still matters, but the current work is focused on building intelligent products, operational tools, and working software with real technical depth.

Studio signal

15+ years across product analytics, experimentation, attribution, measurement, and business-to-technical translation now applied to AI desktop products, trading systems, research infrastructure, and full-stack software.

Current focus

Agentic software developmentRapid product prototypingSystems architectureDecision systems

What GUID Solutions Does

Builds from uncertainty instead of waiting for certainty.

The studio is built around one practical question: what needs to exist, in software, for an idea to stop being abstract? In practice that means agentic software development, rapid prototyping, systems architecture, and decision systems across AI-driven desktop workflows, operational tooling, and full-stack products.

Translate ambiguity

Clarify product shape before overbuilding the wrong thing.

Work usually starts with incomplete requirements, fuzzy workflows, or a strong intuition that has not been operationalized yet. GUID Solutions turns that into concrete product surfaces, data flows, and implementation choices.

Prototype with intent

Build the first useful version fast enough to learn from it.

The goal is not a slide deck or a speculative architecture diagram. It is a working slice: something people can use, react to, pressure-test, and refine into a more durable product.

Engineer for iteration

Keep architecture honest to the product and flexible for change.

That includes local and cloud AI workflows, desktop and web delivery, operational controls, observability, and data-informed iteration without turning every decision into an analytics exercise.

Operating model

The common thread is technical product building under real constraints: translating intent into interfaces, choosing the right architectural boundary, and getting to usable software without losing rigor.

  • Builds across AI workflows, desktop software, operational tooling, and full-stack web products.
  • Uses experimentation discipline where it helps, but does not let measurement become a substitute for shipping.
  • Treats architecture as a product decision, not a backend-only concern.

Featured Products

Current work spans desktop generation tools, quantitative systems, and full-stack collaboration software.

Current work is organized around products rather than generic service categories. Each one reflects a different slice of the same studio model: combine product judgment, technical depth, and disciplined iteration until the system is actually useful.

AI-powered desktop product

Teacher’s Assistant

An AI-powered desktop product for homeschooling families and elementary educators who need print-ready K-6 worksheets, lesson plans, and answer keys without hand-assembling materials from generic chatbot output.

Teacher’s Assistant is the most architecturally substantial product in the current portfolio because it has to feel like software, not a thin prompt wrapper. The workflow is guided, stateful, and oriented around artifacts that are actually usable in a classroom or homeschool setting.

The desktop shell is built with Tauri v2, with a React + TypeScript frontend and Zustand-managed application state driving guided creation flows, previews, export controls, and local filesystem integration. The creation experience is designed around wizards and structured inputs so users can move from idea to lesson packet with less prompt-writing friction.

Behind that interface is a Node/Express generation API that streams progress over SSE, orchestrates prompts, parses inspiration material, and produces HTML-first educational artifacts that can move cleanly into print and PDF/export workflows. Supabase handles authentication, projects, credits, and version history, while generation can run through premium cloud models or local Ollama-based workflows depending on the user’s environment and budget.

System design

  • Tauri v2 desktop shell with React + TypeScript frontend
  • Zustand state for guided creation and revision flows
  • Preview, export, and local filesystem integration for real desktop behavior
  • Node/Express generation API with SSE progress streaming
  • Prompt orchestration, inspiration parsing, HTML-first output, and PDF/export paths
  • Supabase-backed auth, projects, credits, and version history
  • Supports both premium cloud AI workflows and local Ollama-based generation

Why it matters

  • Built for print-ready educational materials, not chat transcripts
  • Treats artifact generation, revision, and export as first-class product concerns
  • Balances cloud convenience with local-first optionality for privacy and cost control

Technology

Tauri v2ReactTypeScriptZustandNode/ExpressSSESupabaseOllama

Intraday day trading bot

Alpaca

An intraday day trading bot that turns validated research into real-time paper and live execution workflows with explicit operational controls.

Alpaca is deployed on GCP and structured around dedicated test and production runtime environments, controlled releases, and close operational oversight. It is designed as a real system with distinct runtime responsibilities rather than a monolithic trading script.

The runtime handles real-time market-data streaming, strategy routing, risk-based sizing, and execution controls using contract-driven interfaces that keep downstream behavior predictable as strategies evolve. An OpenAI copilot sidecar is used in shadow and test-oriented review workflows to help inspect behavior without turning autonomous review into production authority.

Runtime design

  • Deployed to GCP with separate test and prod environments
  • Real-time market-data streaming and strategy routing
  • Risk-based sizing and execution controls
  • Contract-driven architecture between research and runtime systems
  • OpenAI copilot sidecar used in shadow and test-oriented review workflows

Operational posture

  • Presented as a controlled execution system, not a promise of returns
  • Built around release discipline, runtime isolation, and explicit review loops
  • No performance claims and no financial-advice framing

Technology

GCPStreaming market dataStrategy routingRisk controlsContract-driven runtime

Quantitative research platform

Forrest

A deterministic quantitative research and validation platform for strategy discovery, built to complement Alpaca by deciding what should reach runtime in the first place.

Forrest is the research and validation layer that sits upstream of Alpaca. It focuses on disciplined discovery rather than curve-fit storytelling, with regime-aware analysis and subgroup discovery used to pressure-test where a strategy idea appears to hold up and where it does not.

Walk-forward validation, multiple-comparison guardrails, and deterministic export contracts are central to the system. The point is to create a reproducible research path that can promote strategies into downstream execution systems without hand-wavy translation.

Research design

  • Regime-aware analysis
  • Subgroup discovery for structured signal inspection
  • Walk-forward validation
  • Multiple-comparison and statistical guardrails
  • Deterministic strategy export contracts into downstream runtime systems

Role in the system

  • Forrest is the research layer; Alpaca is the execution layer
  • Designed to reduce leakage between discovery, validation, and runtime deployment
  • Makes downstream promotion more explicit and reproducible

Technology

Deterministic pipelinesValidation contractsQuant research workflows

Collaboration product

Helm

A full-stack collaboration product for recurring groups and meetup coordination, designed to make lightweight community operations less chaotic.

Helm is built as a React + Express + PostgreSQL/Drizzle application with the basics treated seriously: authentication, membership management, scheduling, and shared notes. The aim is not just event scheduling, but a better operational memory for recurring groups.

AI-assisted import and enrichment workflows help turn messy source material into structured knowledge that a group can actually reuse over time. That makes Helm as much about continuity and capture as it is about scheduling.

Application design

  • React + Express + PostgreSQL/Drizzle architecture
  • Authentication and membership management
  • Scheduling and shared notes
  • AI-assisted import and enrichment for structured knowledge capture

Product angle

  • Aims at recurring group coordination, not one-off event promotion
  • Uses AI where it improves structure and continuity, not as decorative feature fill
  • Built as a durable full-stack product rather than a landing page concept

Technology

ReactExpressPostgreSQLDrizzle

Background

The analytics foundation still matters. It just is not the center of the page anymore.

Ronnie Guidry spent more than 15 years working across product analytics, web measurement, attribution, experimentation, funnel optimization, and the translation layer between business context and technical execution.

That experience still shapes the work. It sharpens instrumentation choices, keeps experimentation grounded in decision quality, and helps separate signal from noise when products start interacting with real users and operational constraints.

But the current center of gravity is product building: AI-enabled software, working prototypes, decision systems, and architecture that supports actual use instead of abstract intent.

  • 15+ years across analytics, measurement, attribution, and experimentation
  • Deep experience bridging operators, product stakeholders, and technical teams
  • Now applied primarily to building new software systems rather than selling analytics services

Working Style

Strategy, architecture, and product shape are treated as the same conversation.

The studio works best where product strategy and implementation are tightly coupled. That means prototyping early, letting architecture inform scope, and using data discipline to improve decisions rather than delay them.

Prototype-first

Useful software beats polished speculation.

The first milestone should usually be a working product slice, not an inflated roadmap. That creates real feedback and exposes technical constraints before they become expensive.

Architecture matters

System boundaries are product decisions.

Decisions about contracts, state, local versus cloud execution, and operational visibility change what a product can become. They are not backend housekeeping.

Use data well

Bring experimentation discipline without getting trapped in analytics-only work.

Metrics, instrumentation, and structured validation still matter. They just serve the product instead of becoming the product.

Ship the real thing

Build systems, not decks and not vague concept theater.

The standard is software that can be used, reviewed, and improved. If a decision should stay abstract, it probably is not ready to dominate the roadmap.

Contact

Have a product idea, intelligent system, or prototype that needs a real build path?

GUID Solutions is open to collaboration where product thinking and technical depth both matter. Use the form for a direct note or connect through LinkedIn.

  • Best fit: agentic software, rapid prototypes, technical product strategy, systems architecture, and decision systems.
Connect on LinkedIn

Protected by Turnstile, server-side validation, and a honeypot field.