Summary of "¿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.