Somm Scribe: Wine Journal & AI Recommendations

Context & The Solo Founder Challenge

Wine tasting is an inherently sensory, personal experience. Yet for most wine lovers, remembering which bottles resonated, decoding personal taste preferences, and discovering new wines that match individual flavor profiles remains frustrating.

Existing consumer wine applications tend to fall into two extremes: either ad-saturated social discovery networks cluttered with sponsored ratings, or overly complex inventory databases designed for high-volume cellar collectors. There was a glaring void for a fast, elegant, mobile-responsive web journal built specifically to help drinkers record sensory notes, deepen their wine education, and receive intelligent bottle recommendations based on their own verified tasting history.

As the sole founder and full-stack software engineer behind Somm Scribe, I set out to design, architect, and ship a production-grade SaaS application from scratch. The objective was not just to write code, but to execute the full product lifecycle: user experience design, high-concurrency Go API architecture, PostgreSQL database modeling, Stripe subscription billing, Cloud Run deployment, and AI-powered recommendation workflows.

The Product Experience: Tasting, Learning & AI

The core interface is engineered to eliminate friction while capturing rich sensory data. Rather than requiring users to type long essay notes, Somm Scribe pairs high-speed structured attributes (varietals, body, acidity, tannins, sensory tags like “Juicy”, “Creamy”, “Fireside”) with personal notes and bottle photos.

As illustrated in Figure 2.1, every logged tasting connects directly to an educational continuum. Logging a crisp Chardonnay automatically surfaces bite-sized modules like “Step 1: Acidity basics — Learn how freshness changes the shape of a wine and why bright wines feel lively.” This transforms simple record-keeping into ongoing wine appreciation.

As a user logs more tastings, the system synthesizes their rating trends and flavor attributes into an evolving taste profile. In Figure 2.2, the mobile recommendation engine highlights curated bottles (such as Castello di Ama Chianti Classico) accompanied by natural language justification: “A full-bodied Sangiovese that resonates with your Tuscan affinity.”

System Architecture & Technical Stack

Building a consumer SaaS as a solo engineer requires ruthless architectural discipline. The stack was deliberately chosen to minimize operational overhead, guarantee sub-150ms response times, and scale effortlessly on demand without runaway infrastructure bills.

Key Engineering Decisions & Implementation

1. Relational Data Modeling for Sensory Profiles

A common pitfall in wine apps is storing tasting attributes as unstructured strings or JSON blobs. In Somm Scribe, sensory tags (e.g. body, acidity, tannins, flavor_profiles) are normalized into relational tables with strict foreign keys and composite indexes.

This design enables sub-5ms faceted SQL queries when users filter their personal collection by multiple intersecting attributes (e.g., “Pinot Noir + Willamette Valley + Full-Bodied + Rating >= 4”), while providing clean aggregate data when computing user taste preferences.

2. Idiomatic Go API Design

The backend follows a classic layered pattern: HTTP handlers, domain services, and database repositories. Handlers parse requests, validate input defensively, and translate domain errors into consistent JSON responses:

// TastingService handles business logic and validation for wine tastings
type TastingService struct {
    repo         TastingRepository
    userRepo     UserRepository
    stripeClient StripeClient
}

func (s *TastingService) CreateTasting(ctx context.Context, userID string, req CreateTastingRequest) (*Tasting, error) {
    // 1. Enforce tier subscription entitlements server-side
    tier, err := s.stripeClient.GetUserEntitlement(ctx, userID)
    if err != nil {
        return nil, fmt.Errorf("verifying tier entitlements: %w", err)
    }

    count, err := s.repo.CountTastingsByUser(ctx, userID)
    if err != nil {
        return nil, err
    }

    if tier.MaxTastings > 0 && count >= tier.MaxTastings {
        return nil, ErrSubscriptionLimitReached
    }

    // 2. Persist tasting with normalized sensory tags in a single transaction
    return s.repo.CreateWithTags(ctx, userID, req)
}

3. AI Recommendation Pipeline

Rather than passing arbitrary user text to an LLM, the recommendation pipeline executes a multi-step deterministic aggregation:

1. Cluster Extraction: Query the database for the user's top-rated wines (rated 4 or 5 stars) over the trailing 12 months, aggregating frequency counts across varietals, regions, and sensory descriptors.
2. Context-Optimized Prompting: Format the aggregated sensory profile into a concise JSON payload sent to the OpenAI API, requesting recommendations with explicit rationale (the “Why this matches” field).
3. Server-Side Validation: Validate the structured JSON output against an internal schema before returning it to the client, preventing hallucinated formatting issues from reaching the UI.

4. Resilient Stripe Subscription & Webhook Pipeline

Monetization requires bulletproof billing lifecycle management. When handling Stripe subscriptions, network drops and delayed webhooks can easily desynchronize customer status if handled naively.

The webhook handler verifies cryptographic Stripe signatures, checks an internal idempotency table to guard against duplicate webhook deliveries, and transitions user subscription states transactionally:

• checkout.session.completed: Grants immediate access tier and associates Stripe Customer ID.
• customer.subscription.updated: Handles plan upgrades, downgrades, and billing cycle changes.
• customer.subscription.deleted: Gracefully downgrades the account while preserving all historical tasting data.

Reliability, Security & Deployment

Operating a live SaaS requires automated operations that let a solo engineer sleep peacefully at night. Key operational safeguards include:

• Zero-Downtime Revisions: Google Cloud Run deploys every release as an immutable container revision, gradually shifting traffic from the healthy predecessor and automatically rolling back if health checks fail.
• Automated Database Migrations: Schema changes are applied via automated migration scripts at deployment, ensuring application code and database schema remain in strict lockstep.
• Secure Session Authentication: HTTP-only, secure, SameSite cookies protect session tokens from XSS vectors.
• Production Telemetry: Integrated Sentry error monitoring provides instant stack traces and context whenever client or API exceptions occur.

Measurable Outcomes & Reflections

Somm Scribe serves as an end-to-end demonstration of senior product engineering: taking an ambiguous consumer concept and translating it into a performant, reliable, revenue-generating reality.

• Live in Production: Deployed and actively serving users with real Stripe subscription billing.
• Sub-150ms 95th Percentile Latency: The compiled Go backend consistently serves requests under 150ms on Cloud Run.
• Zero Third-Party UI Kit Bloat: Handcrafted React components deliver a responsive, tactile mobile experience without massive bundle penalties.
• Solo Ownership: 100% of product vision, visual design, backend architecture, cloud infrastructure, and operational reliability executed independently.

Building Somm Scribe reinforced my belief that the best software engineers maintain empathy across the entire stack—from the database query plan and serverless cold start up to the touch target and visual rhythm of the user interface.