Founding Solutions Architect

Overview

You're the founding Solutions Architect at Catio, a 22-person startup building an Architecture IDE. You work alongside the founding AE, running deep technical discovery, architecture workshops, and proof-of-value engagements with CTOs and principal engineers. You're not doing canned demos - you're producing custom deliverables that help prospects make architecture decisions.

Role Snapshot

Company Context

Stage: Seed/early (22 employees)

Size: 22 employees

Growth: Building founding GTM team - you're the first or second SA

Market Position: Category creation mode. Prospects don't know they need an "Architecture IDE" yet. You're educating the market.

GTM Reality

How Leads Come In:

• Mostly outbound - AE books a meeting, hands off to you for technical discovery
• Some inbound from demo video views, founder network
• No established demand gen engine yet

AE/SA Collaboration: You're paired with the founding AE. At 22 people, you're probably in most deals together, tag-teaming discovery and POVs. No clear handoffs yet - you're figuring out the motion.

POV/POC Process: Undefined. You're building this. Probably multi-week engagements where you map their architecture, identify gaps, show how Catio helps. You'll create custom deliverables (architecture maps, decision frameworks, integration plans).

Competitive Landscape

Main Competitors:

• Status quo: Architecture decisions happen in whiteboard sessions, Confluence docs, Slack threads
• Point solutions: Diagramming tools (Lucidchart), API docs (Stoplight), system catalogs (Backstage)
• Internal tools: Many companies build their own architecture wikis

How They Differentiate: AI-powered reasoning about architecture tradeoffs, not just documentation. Connects architecture decisions to business outcomes. "Expert guidance" built in (unclear what this means - you'll define it).

Common Objections:

• "Our architects don't need tools, they need thinking time"
• "We already document this in Confluence/Notion"
• "How does this integrate with our existing stack?"
• "Can't we just build this internally?"

Technical Win Themes: You'll discover these, but likely: Faster onboarding, reduced tribal knowledge, systematic vs ad-hoc decisions, tying tech choices to business metrics.

What You'll Actually Do

Time Breakdown

POV/Workshops (40%) | Discovery Calls (25%) | Internal Product Feedback (20%) | Demo Prep/Artifacts (15%)

Key Activities

• Running architecture workshops: You're facilitating 2-3 hour sessions with 4-8 engineers, walking through their system architecture, identifying pain points in decision-making. This is more consulting than demo'ing. You need to earn credibility fast or they tune out.

• Building custom POV deliverables: After discovery, you're creating "decision-grade artifacts" - architecture maps, integration plans, maybe ROI models. These aren't slide decks. They're technical documents that the prospect's engineers will actually reference. High bar.

• Deep product discovery with prospects: You're digging into: How do they make architecture decisions today? Where does it break? What tools do they use? Who's involved? This feeds back into how Catio should work - you're shaping product direction.

• Technical objection handling: When an architect says "we could build this in 2 weeks," you need to credibly explain why that's wrong (or right, and position differently). When they ask how Catio handles their specific tech stack (microservices, event-driven, whatever), you need depth.

• Creating the POV playbook: There's no standard POV process yet. You're figuring out: What's the right length (1 week? 4 weeks?). What deliverables prove value? How much custom work is too much? You're documenting this for the next SA.

The Honest Reality

What's Hard

• You're consulting, not demo'ing: Typical SE roles are "show the product, answer questions, help close." Here, you're producing custom architecture deliverables that take 10-20 hours per deal. If you expected to just run demos, this will feel like a different job.

• Technical buyers are tough: Principal engineers and CTOs have built complex systems. They'll poke holes in your logic. They'll ask about edge cases. They'll question your technical chops. You can't fake depth here.

• Product is early: Catio is 22 people. The product will have gaps. Prospects will ask for features that don't exist. You'll need to sell the vision and roadmap, not just what's live today. Some deals will die because the product isn't ready.

• Ambiguous scope: "Decision-grade artifacts" could mean anything. You'll figure out what "good" looks like by trial and error. Early POVs will take way longer than you planned.

What Success Looks Like

• You run 8-12 architecture workshops in your first 6 months with qualified prospects
• You close 60%+ of deals where you deliver a full POV (vs industry standard ~30-40% POC win rate)
• You create a repeatable POV process that takes 2-3 weeks and produces a deliverable prospects actually use
• Product team ships features based on your field feedback

Who You're Selling To

Primary Buyers:

• Principal Engineers / Staff Engineers owning platform architecture
• VPs of Engineering at 100-1000 person software companies
• CTOs (technical, hands-on, not "business CTO" types)

What They Care About:

• Making architecture decisions faster without sacrificing quality
• Reducing "tribal knowledge" risk when senior engineers leave
• Onboarding new engineers to complex systems in weeks, not months
• Proving architecture investments tie to business outcomes (uptime, velocity, cost)
• Avoiding technical debt that compounds invisibly

Requirements

• You've been a senior engineer or architect at a software company - you've actually designed systems, not just sold tools
• You can facilitate technical workshops with senior engineers and hold credibility in architecture discussions
• You're comfortable with ambiguity - POV process, deliverables, and success criteria are hypotheses you'll test
• You've done pre-sales or consulting with technical buyers (not IT buyers, not business users)
• You can produce written technical artifacts (architecture docs, integration plans, decision frameworks) that engineers respect