¿Este es el MEJOR stack para proyectos grandes?

High-level goal

The presenter describes a preferred full-stack for large, multi-client projects covering backend, frontend, mobile, desktop, CLI tools, AI integrations, databases, and deployment/CI. Emphasis is on developer experience (DX), maintainability, and user experience (performance).

---

Databases

• PostgreSQL
  • Primary SQL choice for production.
  • Easy to deploy and has a mature ecosystem.
• MongoDB
  • Recommended for flexible/dynamic NoSQL schemas.
• SQLite
  • Lightweight local/embedded DB for tools, single-user apps, and mobile prototyping.
• Redis
  • In-memory cache to speed common queries and store hot data in RAM.

---

Backend

• Recommended language: Go (Golang)
  • Strengths: good concurrency, low resource use, strong support for network/distributed apps.
• Go frameworks
  • Popular/recommended: Gin
  • Alternatives: Echo, Chi, Fiber, or no framework at all.
• ORM / DB tooling
  • GORM recommended for getting started.
  • Alternatives: sqlx, sqlc.
  • Approaches:
    • Code-first (ORM/generators)
    • SQL-first (migrations / raw SQL)
• Notes on other languages
  • TypeScript/Node: useful for sharing types/validation with the frontend.
  • Python: common for AI/data science libraries.
  • Go offers a balance of performance and DX.

---

Frontend

• React + Vite
  • Fast tooling; good for internal dashboards and SPAs.
• Next.js
  • Use when SEO, server-side rendering (SSR), hybrid rendering, or advanced public site needs (e.g., e-commerce).
• Guidance
  • Choose React + Vite for internal tools where speed matters.
  • Choose Next.js when SEO, pre-rendering, or server-side data fetching are important.

---

Monorepo vs Multiple Repos

• Monorepo
  • Preferable when most code is the same language (e.g., a full TypeScript stack) to share types and logic easily.
• Multiple repos
  • Preferable for mixed-language stacks (e.g., Go backend + TypeScript frontend) with independent deployments.
  • Cross-language type sharing is still possible (e.g., tools that convert Go structs → TypeScript).

---

Mobile and Desktop

• Mobile
  • React Native for a single codebase targeting iOS and Android.
  • Trade-off: native Swift/Kotlin gives the best UX but costs more to maintain.
• Desktop
  • Tauri (Rust-based shell + web UI)
    • Wraps web apps into native desktop apps with OS APIs.
    • Smaller footprint and better performance than heavier web wrappers.
  • Reuse frontend code across web and desktop where possible.

---

AI integrations, CLIs and “API-on-top-of-API”

• CLIs
  • Build command-line tools for admin/automation and developer workflows; these can be invoked by AI agents.
• “MCP” concept (API layer for AI/agents)
  • Create an API wrapper or “API for AI” that exposes documented operations (e.g., Google Calendar calls) so agents/AI can interact safely and reliably with backend services.
  • Implementations can be in TypeScript, Python or Go (Go recommended for system tools/CLIs).
• Skills/plugins
  • Store documentation/skills for agents so they can call CLIs/APIs as needed.

MCP: an API layer that exposes safe, documented operations for AI agents to call, avoiding unsafe or ad-hoc integrations.

---

Models, Code Agents and Editors

• Models mentioned
  • ChatGPT/GPT, Claude, Gemini, Grok — choose based on context window and use case.
  • The presenter uses cloud models (e.g., ChatGPT).
• Code assistants
  • Cloud-based agents (e.g., GitHub Copilot, editor-integrated agents) can replace much manual coding.
  • Recommendation: pay for model/agent access if needed rather than expensive editor subscriptions.
• Editors
  • VS Code recommended for extensions and integrations.
  • Also mentioned: a fast native (Rust-based) editor for speed.
  • VS Code + cloud agents is a practical combination.

---

Deployment and CI/CD

• Hosts commonly used
  • AWS, DigitalOcean, Railway, and a newer host mentioned in the transcript.
• Deployment methods
  • Via provider CLIs or SSH.
• CI/CD tooling
  • GitHub for source control.
  • GitHub Actions for automated builds and deployments.
  • GHCR (GitHub Container Registry) for containers.
  • GitHub Releases for distributing desktop/CLI binaries.
• Typical flow
  • push → GitHub Action builds backend/frontend → deploy to cloud / store container/binaries → updates auto-deploy

---

Trade-offs and Alternatives

• The recommended stack balances DX and performance.
• Alternatives to increase raw speed: native desktop apps, Rust backend, custom in-memory caching beyond Redis.
• The presenter acknowledges many valid alternatives (Rust, Deno, Bun, different DB choices) and invites suggestions.

---

Product / Tool Mention (sponsor)

• Abacci (sponsored)
  • Developer-focused platform unifying access to multiple AI models (GPT, Grok, Gemini, etc.) under one subscription.
  • Features: intelligent agent for scaffolding projects, web navigation automation, document interpretation, presentation/image/video generation, and no-install usage.

---

Guides, Tutorials and Related Content

• The presenter has additional videos/tutorials:
  • A video explaining frontend rendering methods (link referenced in description).
  • An upcoming video comparing agent/code editor tooling differences (how Cloud/Claude vs other agents behave).
• Personalized consultations available via webfast.dev (links in the video description).

---

Key Recommendations (Short)

• Databases: PostgreSQL + Redis; MongoDB for dynamic schemas; SQLite for embedded tools.
• Backend: Go + Gin + GORM/sqlc/sqlx for scalable services.
• Frontend: React + Vite for internal apps; Next.js for SEO/SSR.
• Mobile/Desktop: React Native and Tauri to maximize code reuse.
• AI: expose CLIs and an API-layer for AI agents; implement MCPs/connectors in Go/TS/Python.
• Deploy: GitHub Actions + cloud host (AWS/DigitalOcean/Railway/etc.); use GHCR and Releases for artifacts.

---

Main Speakers / Sources

• Video presenter (author of webfast.dev) — primary speaker.
• Sponsor/source: Abacci (AI platform).
• Tools/technologies mentioned: PostgreSQL, MongoDB, SQLite, Redis, Go (Gin, Echo, Chi, Fiber), GORM/sqlx/sqlc, TypeScript/Node, Python, React, Vite, Next.js, React Native, Tauri, GitHub (Actions, GHCR, Releases), AWS/DigitalOcean/Railway, ChatGPT/GPT, Claude/“Cloud”, Gemini, Grok, Copilot/agent tools, VS Code and a Rust-based fast editor.