English العربية Deutsch Español Français हिन्दी Italiano 日本語 한국어 Português (BR) Русский Türkçe 中文

Modulo S: Configuracion Soberana

Curso STREETS de Ingresos para Desarrolladores — Modulo Gratuito Semanas 1-2 | 6 Lecciones | Entregable: Tu Documento de Stack Soberano

"Tu equipo es tu infraestructura de negocio. Configuralo como tal."

Ya eres dueno de la herramienta generadora de ingresos mas poderosa que la mayoria de las personas jamas tendra: una estacion de trabajo de desarrollador con conexion a internet, computo local y las habilidades para conectar todo.

La mayoria de los desarrolladores tratan su equipo como un producto de consumo. Algo en lo que juegan, programan, navegan. Pero esa misma maquina — la que esta debajo de tu escritorio ahora mismo — puede ejecutar inferencia, servir APIs, procesar datos y generar ingresos las 24 horas del dia mientras duermes.

Este modulo trata de ver lo que ya tienes a traves de un lente diferente. No "que puedo construir?" sino "que puedo vender?"

Al final de estas dos semanas, tendras:

Nada de rodeos. Nada de "solo cree en ti mismo." Numeros reales, comandos reales, decisiones reales.

Comencemos.

Leccion 1: La Auditoria del Equipo

"No necesitas una 4090. Esto es lo que realmente importa."

Tu Maquina Es un Activo de Negocio

Cuando una empresa evalua su infraestructura, no solo lista especificaciones — mapea capacidades a oportunidades de ingreso. Eso es exactamente lo que vas a hacer ahora.

Abre una terminal y ejecuta lo siguiente. Anota cada numero. Los necesitaras para tu Documento de Stack Soberano en la Leccion 6.

Inventario de Hardware

CPU

# Linux/Mac
lscpu | grep "Model name\|CPU(s)\|Thread(s)"
# or
cat /proc/cpuinfo | grep "model name" | head -1
nproc

# Windows (PowerShell)
Get-CimInstance -ClassName Win32_Processor | Select-Object Name, NumberOfCores, NumberOfLogicalProcessors

# macOS
sysctl -n machdep.cpu.brand_string
sysctl -n hw.ncpu

Lo que importa para los ingresos:

RAM

# Linux
free -h

# macOS
sysctl -n hw.memsize | awk '{print $0/1073741824 " GB"}'

# Windows (PowerShell)
(Get-CimInstance -ClassName Win32_ComputerSystem).TotalPhysicalMemory / 1GB

Lo que importa para los ingresos:

GPU

# NVIDIA
nvidia-smi

# Check VRAM specifically
nvidia-smi --query-gpu=name,memory.total,memory.free --format=csv

# AMD (Linux)
rocm-smi

# macOS (Apple Silicon)
system_profiler SPDisplaysDataType

Lo que importa para los ingresos:

Esta es la especificacion con la que la gente se obsesiona, y aqui esta la verdad honesta: tu GPU determina tu nivel de LLM local, y tu nivel de LLM local determina que flujos de ingresos funcionan mas rapido. Pero no determina si puedes ganar dinero o no.

VRAM Capacidad LLM Relevancia para Ingresos
0 (solo CPU) Modelos 7B a ~5 tokens/seg Procesamiento por lotes, trabajo asincrono. Lento pero funcional.
6-8 GB (RTX 3060, etc.) Modelos 7B a ~30 tok/seg, 13B cuantizado Suficiente para la mayoria de flujos de ingresos por automatizacion.
12 GB (RTX 3060 12GB, 4070) 13B a velocidad completa, 30B cuantizado Punto optimo. La mayoria de los motores de ingresos funcionan bien aqui.
16-24 GB (RTX 4090, 3090) Modelos 30B-70B Nivel premium. Vende calidad que otros no pueden igualar localmente.
48 GB+ (GPU dual, A6000) 70B+ a velocidad Inferencia local de grado empresarial. Ventaja competitiva seria.
Apple Silicon 32GB+ (M2/M3 Pro/Max) 30B+ usando memoria unificada Excelente eficiencia. Menor costo energetico que el equivalente NVIDIA.

No se detecto GPU dedicada. Ejecutaras inferencia en CPU, lo que significa ~5-12 tokens/seg en modelos 7B. Eso esta bien para procesamiento por lotes y trabajo asincrono. Usa llamadas API para cubrir la brecha de velocidad en salidas orientadas al cliente.

Hablemos Claro: Si tienes una RTX 3060 12GB, estas en mejor posicion que el 95% de los desarrolladores que intentan monetizar IA. Deja de esperar una 4090. La 3060 12GB es el Honda Civic de la IA local — confiable, eficiente, hace el trabajo. El dinero que gastarias en una mejora de GPU es mejor invertirlo en creditos API para calidad orientada al cliente mientras tus modelos locales se encargan del trabajo pesado.

Almacenamiento

# Linux/Mac
df -h

# Windows (PowerShell)
Get-PSDrive -PSProvider FileSystem | Select-Object Name, @{N='Used(GB)';E={[math]::Round($_.Used/1GB,1)}}, @{N='Free(GB)';E={[math]::Round($_.Free/1GB,1)}}

Lo que importa para los ingresos:

Red

# Quick speed test (install speedtest-cli if needed)
# pip install speedtest-cli
speedtest-cli --simple

# Or just check your plan
# Upload speed matters more than download for serving

Lo que importa para los ingresos:

Tiempo de Actividad

Esta es la especificacion en la que nadie piensa, pero separa a los aficionados de las personas que ganan dinero mientras duermen.

Preguntate:

Si no puedes funcionar 24/7, esta bien — muchos flujos de ingresos en este curso son trabajos por lotes asincronos que ejecutas manualmente. Pero los que generan ingresos verdaderamente pasivos requieren tiempo de actividad.

Configuracion rapida de tiempo de actividad (si la quieres):

# Enable Wake-on-LAN (check BIOS)
# Set up SSH access
sudo systemctl enable ssh  # Linux

# Auto-restart on crash (systemd service example)
# /etc/systemd/system/my-income-worker.service
[Unit]
Description=Income Worker Process
After=network.target

[Service]
Type=simple
ExecStart=/usr/local/bin/my-worker
Restart=always
RestartSec=10

[Install]
WantedBy=multi-user.target

Las Matematicas de la Electricidad

La gente ignora esto o lo exagera catastroficamente. Hagamos matematicas reales.

Midiendo tu consumo real de energia:

# If you have a Kill-A-Watt meter or smart plug with monitoring:
# Measure at idle, at load (running inference), and at max (GPU full utilization)

# Rough estimates if you don't have a meter:
# Desktop (no GPU, idle): 60-100W
# Desktop (mid-range GPU, idle): 80-130W
# Desktop (high-end GPU, idle): 100-180W
# Desktop (GPU under inference load): add 50-80% of GPU TDP
# Laptop: 15-45W
# Mac Mini M2: 7-15W (seriously)
# Apple Silicon laptop: 10-30W

Calculo del costo mensual:

Costo mensual = (Watts / 1000) x Horas x Precio por kWh

Ejemplo: Desktop con RTX 3060, ejecutando inferencia 8 horas/dia, idle 16 horas/dia
- Inferencia: (250W / 1000) x 8h x 30 dias x $0.12/kWh = $7.20/mes
- Idle: (100W / 1000) x 16h x 30 dias x $0.12/kWh = $5.76/mes
- Total: ~$13/mes

Ejemplo: Mismo equipo, 24/7 inferencia
- (250W / 1000) x 24h x 30 dias x $0.12/kWh = $21.60/mes

Ejemplo: Mac Mini M2, 24/7
- (12W / 1000) x 24h x 30 dias x $0.12/kWh = $1.04/mes

El promedio de electricidad en EE.UU. es aproximadamente $0.12/kWh. Revisa tu tarifa real — varia enormemente. California puede ser $0.25/kWh. Algunos paises europeos llegan a $0.35/kWh. Partes del medio oeste de EE.UU. estan en $0.08/kWh.

El punto: Mantener tu equipo funcionando 24/7 para generar ingresos cuesta entre $1-$30/mes en electricidad. Si tus flujos de ingresos no pueden cubrir eso, el problema no es la electricidad — es el flujo de ingresos.

Especificaciones Minimas por Tipo de Motor de Ingresos

Aqui tienes una vista previa de hacia donde nos dirigimos en el curso completo de STREETS. Por ahora, solo verifica donde se ubica tu equipo:

Motor de Ingresos CPU RAM GPU Almacenamiento Red
Automatizacion de contenido (publicaciones de blog, newsletters) 4+ nucleos 16 GB Opcional (respaldo API) 50 GB libres 10 Mbps subida
Servicios de procesamiento de datos 8+ nucleos 32 GB Opcional 200 GB libres 50 Mbps subida
Servicios de API de IA local 8+ nucleos 32 GB 8+ GB VRAM 100 GB libres 50 Mbps subida
Herramientas de generacion de codigo 8+ nucleos 16 GB 8+ GB VRAM o API 50 GB libres 10 Mbps subida
Procesamiento de documentos 4+ nucleos 16 GB Opcional 100 GB libres 10 Mbps subida
Agentes autonomos 8+ nucleos 32 GB 12+ GB VRAM 100 GB libres 50 Mbps subida

Error Comun: "Necesito mejorar mi hardware antes de poder empezar." No. Empieza con lo que tienes. Usa llamadas API para cubrir las brechas que tu hardware no puede. Mejora cuando los ingresos lo justifiquen — no antes.

Punto de Control de la Leccion 1

Ahora deberias tener anotado:

Guarda estos numeros. Los ingresaras en tu Documento de Stack Soberano en la Leccion 6.

En el curso completo de STREETS, el Modulo R (Motores de Ingresos) te da guias especificas paso a paso para cada tipo de motor listado arriba — incluyendo el codigo exacto para construirlos y desplegarlos.

Leccion 2: El Stack de LLM Local

"Configura Ollama para uso en produccion — no solo para chatear."

Por Que los LLMs Locales Importan para los Ingresos

Cada vez que llamas a la API de OpenAI, estas pagando alquiler. Cada vez que ejecutas un modelo localmente, esa inferencia es gratuita despues de la configuracion inicial. Las matematicas son simples:

Si estas construyendo servicios que procesan miles de solicitudes, la diferencia entre $0 y $5-$15 por millon de tokens es la diferencia entre ganancia y punto de equilibrio.

Pero aqui esta el matiz que la mayoria se pierde: los modelos locales y los de API sirven roles diferentes en un stack de ingresos. Los modelos locales manejan el volumen. Los modelos API manejan la calidad critica, las salidas orientadas al cliente. Tu stack necesita ambos.

Instalando Ollama

Ollama es la base. Convierte tu maquina en un servidor de inferencia local con una API limpia.

# Linux
curl -fsSL https://ollama.com/install.sh | sh

# macOS
# Download from https://ollama.com or:
brew install ollama

# Windows
# Download installer from https://ollama.com
# Or use winget:
winget install Ollama.Ollama

Verifica la instalacion:

ollama --version
# Should show version 0.5.x or higher (check https://ollama.com/download for latest)

# Start the server (if not auto-started)
ollama serve

# In another terminal, test it:
ollama run llama3.1:8b "Say hello in exactly 5 words"

Nota sobre versiones: Ollama lanza actualizaciones frecuentemente. Los comandos de modelos y flags en este modulo fueron verificados contra Ollama v0.5.x (principios de 2026). Si estas leyendo esto despues, revisa ollama.com/download para la ultima version y ollama.com/library para los nombres de modelos actuales. Los conceptos fundamentales no cambian, pero las etiquetas especificas de modelos (por ejemplo, llama3.1:8b) pueden ser reemplazadas por versiones mas nuevas.

Guia de Seleccion de Modelos

No descargues cada modelo que veas. Se estrategico. Esto es lo que debes descargar y cuando usar cada uno.

Nivel 1: El Caballo de Batalla (modelos 7B-8B)

# Pull your workhorse model
ollama pull llama3.1:8b
# Alternative: mistral (good for European languages)
ollama pull mistral:7b

Usar para:

Rendimiento (tipico):

Comparacion de costos:

Nivel 2: La Eleccion Equilibrada (modelos 13B-14B)

# Pull your balanced model
ollama pull llama3.1:14b
# Or for coding tasks:
ollama pull deepseek-coder-v2:16b

Usar para:

Rendimiento (tipico):

Cuando usar en vez de 7B: Cuando la calidad de salida del 7B no es suficiente pero no necesitas pagar por llamadas API. Prueba ambos en tu caso de uso real — a veces el 7B esta bien y solo estas desperdiciando computo.

Nivel 3: El Nivel de Calidad (modelos 30B-70B)

# Only pull these if you have the VRAM
# 30B needs ~20GB VRAM, 70B needs ~40GB VRAM (quantized)
ollama pull llama3.1:70b-instruct-q4_K_M
# Or the smaller but excellent:
ollama pull qwen2.5:32b

Usar para:

Rendimiento (tipico):

Hablemos Claro: Si no tienes 24GB+ de VRAM, omite los modelos 70B por completo. Usa llamadas API para salidas de calidad critica. Un modelo 70B ejecutandose a 3 tokens/segundo desde la RAM del sistema es tecnicamente posible pero practicamente inutil para cualquier flujo de trabajo generador de ingresos. Tu tiempo tiene valor.

Nivel 4: Modelos API (Cuando lo Local No Alcanza)

Los modelos locales son para volumen y privacidad. Los modelos API son para techos de calidad y capacidades especializadas.

Cuando usar modelos API:

Tabla de comparacion de costos (a principios de 2025 — revisa precios actuales):

Modelo Entrada (por 1M tokens) Salida (por 1M tokens) Mejor Para
GPT-4o-mini $0.15 $0.60 Trabajo de volumen economico (cuando lo local no esta disponible)
GPT-4o $2.50 $10.00 Vision, razonamiento complejo
Claude 3.5 Sonnet $3.00 $15.00 Codigo, analisis, contexto largo
Claude 3.5 Haiku $0.80 $4.00 Rapido, economico, buen balance de calidad
DeepSeek V3 $0.27 $1.10 Economico, rendimiento solido

La estrategia hibrida:

  1. El LLM local 7B/13B maneja el 80% de las solicitudes (clasificacion, extraccion, resumen)
  2. La API maneja el 20% de las solicitudes (generacion de calidad critica, tareas complejas)
  3. Tu costo efectivo: ~$0.50-2.00 por millon de tokens combinados (en vez de $5-15 con API pura)

Este enfoque hibrido es como construyes servicios con margenes saludables. Mas sobre esto en el Modulo R.

Configuracion de Produccion

Ejecutar Ollama para trabajo de ingresos es diferente de ejecutarlo para chat personal. Asi es como configurarlo correctamente.

Establecer Variables de Entorno

# Create/edit the Ollama configuration
# Linux: /etc/systemd/system/ollama.service or environment variables
# macOS: launchctl environment or ~/.zshrc
# Windows: System Environment Variables

# Key settings:
export OLLAMA_HOST=127.0.0.1:11434    # Bind to localhost only (security)
export OLLAMA_NUM_PARALLEL=4            # Concurrent request handling
export OLLAMA_MAX_LOADED_MODELS=2       # Keep 2 models in memory
export OLLAMA_KEEP_ALIVE=30m            # Keep model loaded for 30 min after last request
export OLLAMA_MAX_QUEUE=100             # Queue up to 100 requests

Crear un Modelfile para Tu Carga de Trabajo

En vez de usar la configuracion predeterminada del modelo, crea un Modelfile personalizado ajustado para tu carga de trabajo de ingresos:

# Save as: Modelfile-worker
FROM llama3.1:8b

# Tune for consistent, production output
PARAMETER temperature 0.3
PARAMETER top_p 0.9
PARAMETER num_ctx 4096
PARAMETER repeat_penalty 1.1

# System prompt for your most common workload
SYSTEM """You are a precise data processing assistant. You follow instructions exactly. You output only what is requested, with no preamble or explanation unless asked. When given structured output formats (JSON, CSV, etc.), you output only the structure with no markdown formatting."""

# Create your custom model
ollama create worker -f Modelfile-worker

# Test it
ollama run worker "Extract all email addresses from this text: Contact us at hello@example.com or support@test.org for more info."

Procesamiento por Lotes y Gestion de Cola

Para cargas de trabajo de ingresos, a menudo necesitaras procesar muchos elementos. Aqui tienes una configuracion basica de procesamiento por lotes:

#!/usr/bin/env python3
"""
batch_processor.py — Process items through local LLM with queuing.
Production-grade batching for income workloads.
"""

import requests
import json
import time
import concurrent.futures
from pathlib import Path

OLLAMA_URL = "http://127.0.0.1:11434/api/generate"
MODEL = "worker"  # Your custom model from above
MAX_CONCURRENT = 4
MAX_RETRIES = 3

def process_item(item: dict) -> dict:
    """Process a single item through the local LLM."""
    payload = {
        "model": MODEL,
        "prompt": item["prompt"],
        "stream": False,
        "options": {
            "num_ctx": 4096,
            "temperature": 0.3
        }
    }

    for attempt in range(MAX_RETRIES):
        try:
            response = requests.post(OLLAMA_URL, json=payload, timeout=120)
            response.raise_for_status()
            result = response.json()
            return {
                "id": item["id"],
                "input": item["prompt"][:100],
                "output": result["response"],
                "tokens": result.get("eval_count", 0),
                "duration_ms": result.get("total_duration", 0) / 1_000_000,
                "status": "success"
            }
        except Exception as e:
            if attempt == MAX_RETRIES - 1:
                return {
                    "id": item["id"],
                    "output": None,
                    "error": str(e),
                    "status": "failed"
                }
            time.sleep(2 ** attempt)  # Exponential backoff

def process_batch(items: list[dict], output_file: str = "results.jsonl"):
    """Process a batch of items with concurrent execution."""
    results = []
    start_time = time.time()

    with concurrent.futures.ThreadPoolExecutor(max_workers=MAX_CONCURRENT) as executor:
        future_to_item = {executor.submit(process_item, item): item for item in items}

        for i, future in enumerate(concurrent.futures.as_completed(future_to_item)):
            result = future.result()
            results.append(result)

            # Write incrementally (don't lose progress on crash)
            with open(output_file, "a") as f:
                f.write(json.dumps(result) + "\n")

            # Progress reporting
            elapsed = time.time() - start_time
            rate = (i + 1) / elapsed
            remaining = (len(items) - i - 1) / rate if rate > 0 else 0
            print(f"[{i+1}/{len(items)}] {result['status']} | "
                  f"{rate:.1f} items/sec | "
                  f"ETA: {remaining:.0f}s")

    # Summary
    succeeded = sum(1 for r in results if r["status"] == "success")
    failed = sum(1 for r in results if r["status"] == "failed")
    total_time = time.time() - start_time

    print(f"\nBatch complete: {succeeded} succeeded, {failed} failed, "
          f"{total_time:.1f}s total")

    return results

# Example usage:
if __name__ == "__main__":
    # Your items to process
    items = [
        {"id": i, "prompt": f"Summarize this in one sentence: {text}"}
        for i, text in enumerate(load_your_data())  # Replace with your data source
    ]

    results = process_batch(items)

Haciendo Benchmark a TU Equipo

No confies en los benchmarks de otros. Mide los tuyos:

# Quick benchmark script
# Save as: benchmark.sh

#!/bin/bash
MODELS=("llama3.1:8b" "mistral:7b")
PROMPT="Write a detailed 200-word product description for a wireless mechanical keyboard designed for programmers."

for model in "${MODELS[@]}"; do
    echo "=== Benchmarking: $model ==="

    # Warm up (first run loads model into memory)
    ollama run "$model" "Hello" > /dev/null 2>&1

    # Timed run
    START=$(date +%s%N)
    RESULT=$(curl -s http://localhost:11434/api/generate -d "{
        \"model\": \"$model\",
        \"prompt\": \"$PROMPT\",
        \"stream\": false
    }")
    END=$(date +%s%N)

    DURATION=$(( (END - START) / 1000000 ))
    TOKENS=$(echo "$RESULT" | python3 -c "import sys,json; print(json.load(sys.stdin).get('eval_count', 'N/A'))")

    echo "Time: ${DURATION}ms"
    echo "Tokens generated: $TOKENS"
    if [ "$TOKENS" != "N/A" ] && [ "$DURATION" -gt 0 ]; then
        TPS=$(python3 -c "print(f'{$TOKENS / ($DURATION / 1000):.1f}')")
        echo "Speed: $TPS tokens/second"
    fi
    echo ""
done

chmod +x benchmark.sh
./benchmark.sh

Anota tus tokens/segundo para cada modelo. Este numero determina que flujos de trabajo de ingresos son practicos para tu equipo.

Requisitos de velocidad por caso de uso:

Asegurando Tu Servidor de Inferencia Local

Tu instancia de Ollama nunca deberia ser accesible desde internet a menos que lo pretendas explicitamente.

# Verify Ollama is only listening on localhost
ss -tlnp | grep 11434
# Should show 127.0.0.1:11434, NOT 0.0.0.0:11434

# If you need remote access (e.g., from another machine on your LAN):
# Use SSH tunneling instead of exposing the port
ssh -L 11434:localhost:11434 your-rig-ip

# Firewall rules (Linux)
sudo ufw deny in 11434
sudo ufw allow from 192.168.1.0/24 to any port 11434  # LAN only, if needed

Error Comun: Enlazar Ollama a 0.0.0.0 por "conveniencia" y olvidarse de ello. Cualquiera que encuentre tu IP puede usar tu GPU para inferencia gratuita. Peor aun, pueden extraer pesos del modelo y prompts del sistema. Siempre localhost. Siempre tunel.

Punto de Control de la Leccion 2

Ahora deberias tener:

En el curso completo de STREETS, el Modulo T (Fosos Tecnicos) te muestra como construir configuraciones de modelos propietarias, pipelines ajustados y cadenas de herramientas personalizadas que los competidores no pueden replicar facilmente. El Modulo R (Motores de Ingresos) te da los servicios exactos para construir sobre este stack.

Leccion 3: La Ventaja de Privacidad

"Tu configuracion privada ES una ventaja competitiva — no solo una preferencia."

La Privacidad Es una Caracteristica del Producto, No una Limitacion

La mayoria de los desarrolladores configuran infraestructura local porque personalmente valoran la privacidad, o porque disfrutan experimentando. Eso esta bien. Pero estas dejando dinero sobre la mesa si no te das cuenta de que la privacidad es una de las caracteristicas mas comercializables en tecnologia ahora mismo.

Esto es por que: cada vez que una empresa envia datos a la API de OpenAI, esos datos pasan por un tercero. Para muchas empresas — especialmente las de salud, finanzas, legal, gobierno y empresas con base en la UE — esto es un problema real. No uno teorico. Un problema de "no podemos usar esta herramienta porque cumplimiento dijo que no."

Tu, ejecutando modelos localmente en tu maquina, no tienes ese problema.

El Viento Regulatorio a Favor

El entorno regulatorio se mueve en tu direccion. Rapido.

EU AI Act (vigente desde 2024-2026):

GDPR (ya vigente):

Regulaciones especificas por industria:

Como Posicionar la Privacidad en Conversaciones de Venta

No necesitas ser un experto en cumplimiento. Necesitas entender tres frases y saber cuando usarlas:

Frase 1: "Tus datos nunca salen de tu infraestructura." Usar cuando: Hablas con cualquier prospecto consciente de la privacidad. Este es el gancho universal.

Frase 2: "No se requiere acuerdo de procesamiento de datos con terceros." Usar cuando: Hablas con empresas europeas o cualquier empresa con equipo legal/de cumplimiento. Esto les ahorra semanas de revision legal.

Frase 3: "Auditoria completa, procesamiento de inquilino unico." Usar cuando: Hablas con empresas o industrias reguladas. Necesitan demostrar su pipeline de IA ante auditores.

Ejemplo de posicionamiento (para tu pagina de servicio o propuestas):

"A diferencia de los servicios de IA basados en la nube, [Tu Servicio] procesa todos los datos localmente en hardware dedicado. Tus documentos, codigo y datos nunca salen del entorno de procesamiento. No hay APIs de terceros en el pipeline, no hay acuerdos de intercambio de datos que negociar, y hay registro completo de auditoria de cada operacion. Esto hace que [Tu Servicio] sea adecuado para organizaciones con requisitos estrictos de manejo de datos, incluyendo entornos de cumplimiento GDPR, HIPAA y SOC 2."

Ese parrafo, en una landing page, atraera exactamente a los clientes que pagaran tarifas premium.

La Justificacion de Precios Premium

Aqui esta el caso de negocio en numeros concretos:

Servicio estandar de procesamiento de IA (usando APIs en la nube):

Servicio de procesamiento de IA con privacidad primero (tu stack local):

El premium de privacidad es real: 5x a 10x sobre servicios commoditizados basados en la nube para la misma tarea subyacente. Y los clientes que lo pagan son mas leales, menos sensibles al precio y tienen presupuestos mas grandes.

Configurando Espacios de Trabajo Aislados

Si tienes un empleo de dia (la mayoria de ustedes si), necesitas separacion limpia entre el trabajo del empleador y el trabajo de ingresos. Esto no es solo proteccion legal — es higiene operativa.

Opcion 1: Cuentas de usuario separadas (recomendado)

# Linux: Create a dedicated user for income work
sudo useradd -m -s /bin/bash income
sudo passwd income

# Switch to income user for all revenue work
su - income

# All income projects, API keys, and data live under /home/income/

Opcion 2: Espacios de trabajo en contenedores

# Docker-based isolation
# Create a dedicated workspace container

# docker-compose.yml
version: '3.8'
services:
  income-workspace:
    image: ubuntu:22.04
    volumes:
      - ./income-projects:/workspace
      - ./income-data:/data
    environment:
      - OLLAMA_HOST=host.docker.internal:11434
    network_mode: bridge
    # Your employer's VPN, tools, etc. are NOT in this container

Opcion 3: Maquina fisica separada (la mas infalible)

Si esto va en serio y tus ingresos lo justifican, una maquina dedicada elimina todas las preguntas. Un Dell OptiPlex usado con una RTX 3060 cuesta $400-600 y se paga solo en el primer mes de trabajo con clientes.

Lista de verificacion de separacion minima:

Error Comun: Usar la clave API de OpenAI de tu empleador "solo para probar" tu proyecto paralelo. Esto crea un rastro de papel que el dashboard de facturacion de tu empleador puede ver, y enturbia las aguas de la propiedad intelectual. Consigue tus propias claves. Son baratas.

Punto de Control de la Leccion 3

Ahora deberias entender:

En el curso completo de STREETS, el Modulo E (Ventaja en Evolucion) te ensena como rastrear cambios regulatorios y posicionarte antes de los nuevos requisitos de cumplimiento antes de que tus competidores siquiera sepan que existen.

Leccion 4: El Minimo Legal

"Quince minutos de configuracion legal ahora previenen meses de problemas despues."

Esto No Es Asesoramiento Legal

Soy desarrollador, no abogado. Lo que sigue es una lista practica que la mayoria de los desarrolladores en la mayoria de las situaciones deberian abordar. Si tu situacion es compleja (participacion accionaria en tu empleador, acuerdo de no competencia con terminos especificos, etc.), gasta $200 en una consulta de 30 minutos con un abogado laboral. Es el mejor retorno de inversion que obtendras.

Paso 1: Lee Tu Contrato de Trabajo

Encuentra tu contrato de trabajo o carta de oferta. Busca estas secciones:

Clausula de Asignacion de Propiedad Intelectual — Busca lenguaje como:

Frases clave que te restringen:

Frases clave que te liberan:

La Prueba de las 3 Preguntas

Para cualquier proyecto de ingresos, pregunta:

  1. Tiempo: Estas haciendo este trabajo en tu propio tiempo? (No durante horas de trabajo, no durante turnos de guardia)
  2. Equipo: Estas usando tu propio hardware, tu propio internet, tus propias claves API? (No la laptop del empleador, no la VPN del empleador, no las cuentas cloud del empleador)
  3. Materia: Esto no esta relacionado con el negocio de tu empleador? (Si trabajas en una empresa de IA para salud y quieres vender servicios de IA para salud... eso es un problema. Si trabajas en una empresa de IA para salud y quieres vender procesamiento de documentos para agentes inmobiliarios... eso esta bien.)

Si las tres respuestas estan limpias, es casi seguro que estas bien. Si alguna respuesta es turbia, obtiene claridad antes de proceder.

Hablemos Claro: La gran mayoria de los desarrolladores que hacen trabajo paralelo nunca tienen un problema. A los empleadores les importa proteger ventajas competitivas, no evitar que ganes dinero extra en proyectos no relacionados. Pero "es casi seguro que esta bien" no es "definitivamente esta bien." Si tu contrato es inusualmente amplio, ten una conversacion con tu gerente o recursos humanos — o consulta a un abogado. La desventaja de no verificar es mucho peor que la leve incomodidad de preguntar.

Paso 2: Elige una Estructura de Negocio

Necesitas una entidad legal para separar tus activos personales de tus actividades comerciales, y para abrir la puerta a banca empresarial, procesamiento de pagos y beneficios fiscales.

Estados Unidos

Estructura Costo Proteccion Mejor Para
Empresa Individual (predeterminada) $0 Ninguna (responsabilidad personal) Probar el terreno. Primeros $1K.
LLC de Un Solo Miembro $50-500 (varia por estado) Proteccion de activos personales Trabajo activo de ingresos. La mayoria de los desarrolladores deberian empezar aqui.
Eleccion S-Corp (sobre una LLC) Costo de LLC + $0 por la eleccion Igual que LLC + beneficios de impuestos de nomina Cuando ganas consistentemente $40K+/ano de esto

Recomendado para desarrolladores en EE.UU.: LLC de Un Solo Miembro en tu estado de residencia.

Estados mas baratos para constituirse: Wyoming ($100, sin impuesto estatal sobre la renta), New Mexico ($50), Montana ($70). Pero constituirse en tu estado de residencia es usualmente lo mas simple a menos que tengas una razon especifica para no hacerlo.

Como registrarse:

  1. Ve al sitio web del Secretary of State de tu estado
  2. Busca "form LLC" o "business entity filing"
  3. Presenta los Articles of Organization (formulario de 10 minutos)
  4. Obtiene un EIN del IRS (gratis, toma 5 minutos en irs.gov)

Reino Unido

Estructura Costo Proteccion Mejor Para
Sole Trader Gratis (registrate con HMRC) Ninguna Primeros ingresos. Probando.
Limited Company (Ltd) ~$15 via Companies House Proteccion de activos personales Cualquier trabajo serio de ingresos.

Recomendado: Ltd company via Companies House. Toma unos 20 minutos y cuesta GBP 12.

Union Europea

Varia significativamente por pais, pero el patron general:

Australia

Estructura Costo Proteccion Mejor Para
Sole Trader ABN gratuito Ninguna Empezando
Pty Ltd ~AUD 500-800 via ASIC Proteccion de activos personales Ingresos serios

Recomendado: Comienza con un ABN de Sole Trader (gratis, instantaneo), pasa a Pty Ltd cuando estes ganando consistentemente.

Paso 3: Procesamiento de Pagos (configuracion de 15 minutos)

Necesitas una forma de recibir pagos. Configura esto ahora, no cuando tu primer cliente este esperando.

Stripe (recomendado para la mayoria de los desarrolladores):

1. Ve a stripe.com
2. Crea una cuenta con tu correo de negocio
3. Completa la verificacion de identidad
4. Conecta tu cuenta bancaria de negocio
5. Ya puedes aceptar pagos, crear facturas y configurar suscripciones

Tiempo: ~15 minutos. Puedes empezar a aceptar pagos inmediatamente (Stripe retiene fondos por 7 dias en cuentas nuevas).

Lemon Squeezy (recomendado para productos digitales):

Si vendes productos digitales (plantillas, herramientas, cursos, SaaS), Lemon Squeezy actua como tu Merchant of Record. Esto significa:

1. Ve a lemonsqueezy.com
2. Crea una cuenta
3. Configura tu tienda
4. Agrega productos
5. Ellos manejan todo lo demas

Stripe Atlas (para desarrolladores internacionales o quienes quieren una entidad en EE.UU.):

Si estas fuera de EE.UU. pero quieres vender a clientes estadounidenses con una entidad de EE.UU.:

Paso 4: Politica de Privacidad y Terminos de Servicio

Si vendes cualquier servicio o producto en linea, necesitas estos. No pagues a un abogado por plantillas estandar.

Fuentes gratuitas y confiables para plantillas:

Lo que tu politica de privacidad debe cubrir (si procesas datos de clientes):

Tiempo: 30 minutos con un generador de plantillas. Listo.

Paso 5: Cuenta Bancaria Separada

No manejes ingresos de negocio a traves de tu cuenta personal. Las razones:

  1. Claridad fiscal: Cuando llega la temporada de impuestos, necesitas saber exactamente que fue ingreso de negocio y que no.
  2. Proteccion legal: Si tienes una LLC, mezclar fondos personales y de negocio puede "perforar el velo corporativo" — lo que significa que un tribunal puede ignorar la proteccion de responsabilidad de tu LLC.
  3. Profesionalismo: Facturas de "Consultoria de Juan LLC" llegando a una cuenta de negocio dedicada se ve legitimo. Pagos a tu Venmo personal no.

Banca empresarial gratuita o de bajo costo:

Abre la cuenta ahora. Toma 10-15 minutos en linea y 1-3 dias para verificacion.

Paso 6: Conceptos Basicos de Impuestos para Ingresos Paralelos de Desarrolladores

Hablemos Claro: Los impuestos son lo que la mayoria de los desarrolladores ignoran hasta abril, y luego entran en panico. Dedicar 30 minutos ahora te ahorra dinero y estres reales.

Estados Unidos:

Deducciones comunes para ingresos paralelos de desarrolladores:

Reino Unido:

Registra todo desde el dia uno. Usa una hoja de calculo simple si no tienes nada mas:

| Fecha      | Categoria   | Descripcion          | Monto   | Tipo    |
|------------|-------------|----------------------|---------|---------|
| 2025-01-15 | API         | Credito Anthropic    | -$20.00 | Gasto   |
| 2025-01-18 | Ingresos    | Factura cliente #001 | +$500.00| Ingreso |
| 2025-01-20 | Software    | Plan Vercel Pro      | -$20.00 | Gasto   |
| 2025-01-20 | Reserva Imp | 30% de ingreso neto  | -$138.00| Transfer|

Error Comun: "Me encargo de los impuestos despues." Despues es el Q4, debes $3,000 en impuestos estimados mas penalidades, y ya gastaste el dinero. Automatiza: cada vez que un ingreso llega a tu cuenta de negocio, transfiere el 30% a una cuenta de ahorro para impuestos inmediatamente.

Punto de Control de la Leccion 4

Ahora deberias tener (o tener un plan para):

En el curso completo de STREETS, el Modulo E (Manual de Ejecucion) incluye plantillas de modelado financiero que calculan automaticamente tus obligaciones fiscales, rentabilidad del proyecto y puntos de equilibrio para cada motor de ingresos.

Leccion 5: El Presupuesto de $200/mes

"Tu negocio tiene una tasa de quema. Conocela. Controlala. Haz que produzca."

Por Que $200/mes

Doscientos dollars por mes es el presupuesto minimo viable para una operacion de ingresos de desarrollador. Es suficiente para ejecutar servicios reales, servir a clientes reales y generar ingresos reales. Tambien es lo suficientemente pequeno como para que si nada funciona, no hayas apostado todo.

El objetivo es simple: convertir $200/mes en $600+/mes dentro de 90 dias. Si puedes hacer eso, tienes un negocio. Si no puedes, cambias de estrategia — no aumentas el presupuesto.

El Desglose del Presupuesto

Nivel 1: Creditos API — $50-100/mes

Este es tu computo de produccion para calidad orientada al cliente.

Asignacion inicial recomendada:

Anthropic (Claude):     $40/mes  — Tu principal para calidad de salida
OpenAI (GPT-4o-mini):   $20/mes  — Trabajo de volumen economico, respaldo
DeepSeek:               $10/mes  — Tareas de presupuesto, experimentacion
Reserva:                $30/mes  — Desborde o prueba de nuevos proveedores

Como gestionar el gasto en API:

# Simple API budget tracker — run daily via cron
# Save as: check_api_spend.py

import requests
import json
from datetime import datetime

# Check Anthropic usage
# (Anthropic provides usage in the dashboard; here's how to track locally)

MONTHLY_BUDGET = {
    "anthropic": 40.00,
    "openai": 20.00,
    "deepseek": 10.00,
}

# Track locally by logging every API call cost
USAGE_LOG = "api_usage.jsonl"

def get_monthly_spend(provider: str) -> float:
    """Calculate current month's spend for a provider."""
    current_month = datetime.now().strftime("%Y-%m")
    total = 0.0
    try:
        with open(USAGE_LOG, "r") as f:
            for line in f:
                entry = json.loads(line)
                if entry["provider"] == provider and entry["date"].startswith(current_month):
                    total += entry["cost"]
    except FileNotFoundError:
        pass
    return total

def log_api_call(provider: str, tokens_in: int, tokens_out: int, model: str):
    """Log an API call for budget tracking."""
    # Cost per 1M tokens (update these as pricing changes)
    PRICING = {
        "claude-3.5-sonnet": {"input": 3.00, "output": 15.00},
        "claude-3.5-haiku": {"input": 0.80, "output": 4.00},
        "gpt-4o-mini": {"input": 0.15, "output": 0.60},
        "gpt-4o": {"input": 2.50, "output": 10.00},
        "deepseek-v3": {"input": 0.27, "output": 1.10},
    }

    prices = PRICING.get(model, {"input": 1.0, "output": 5.0})
    cost = (tokens_in / 1_000_000 * prices["input"]) + \
           (tokens_out / 1_000_000 * prices["output"])

    entry = {
        "date": datetime.now().isoformat(),
        "provider": provider,
        "model": model,
        "tokens_in": tokens_in,
        "tokens_out": tokens_out,
        "cost": round(cost, 6),
    }

    with open(USAGE_LOG, "a") as f:
        f.write(json.dumps(entry) + "\n")

    # Budget warning
    monthly_spend = get_monthly_spend(provider)
    budget = MONTHLY_BUDGET.get(provider, 0)
    if monthly_spend > budget * 0.8:
        print(f"WARNING: {provider} spend at {monthly_spend:.2f}/{budget:.2f} "
              f"({monthly_spend/budget*100:.0f}%)")

    return cost

La estrategia de gasto hibrida:

Nivel 2: Infraestructura — $30-50/mes

Nombre de dominio:      $12/ano ($1/mes)     — Namecheap, Cloudflare, Porkbun
Email (negocio):        $0-6/mes             — Zoho Mail gratis, o Google Workspace $6
VPS (opcional):         $5-20/mes            — Para hospedar servicios ligeros
                                               Hetzner ($4), DigitalOcean ($6), Railway ($5)
DNS/CDN:                $0/mes               — Cloudflare tier gratuito
Hosting (estatico):     $0/mes               — Vercel, Netlify, Cloudflare Pages (tiers gratuitos)

Necesitas un VPS?

Si tu modelo de ingresos es:

Infraestructura inicial recomendada:

Equipo local — computo principal, inferencia LLM, procesamiento pesado
   |
   +-- Tunel SSH o VPN WireGuard
   |
VPS de $5 (Hetzner/DigitalOcean) — gateway API, receptor de webhooks, hosting estatico
   |
   +-- Cloudflare (gratis) — DNS, CDN, proteccion DDoS
   |
Vercel/Netlify (gratis) — sitio de marketing, landing pages, documentacion

Costo total de infraestructura: $5-20/mes. El resto son tiers gratuitos.

Nivel 3: Herramientas — $20-30/mes

Analiticas:             $0/mes    — Plausible Cloud ($9) o autoalojado,
                                    o Vercel Analytics (tier gratuito)
                                    o simplemente analiticas de Cloudflare (gratis)
Email marketing:        $0/mes    — Buttondown (gratis hasta 100 suscriptores),
                                    Resend ($0 por 3K emails/mes)
Monitoreo:              $0/mes    — UptimeRobot (gratis, 50 monitores),
                                    Better Stack (tier gratuito)
Diseno:                 $0/mes    — Figma (gratis), Canva (tier gratuito)
Contabilidad:           $0/mes    — Wave (gratis), o una hoja de calculo
                                    Hledger (gratis, contabilidad en texto plano)

Hablemos Claro: Puedes ejecutar todo tu stack de herramientas en tiers gratuitos al empezar. Los $20-30 asignados aqui son para cuando superes los tiers gratuitos o quieras una funcion premium especifica. No los gastes solo porque estan en el presupuesto. Presupuesto no gastado es ganancia.

Nivel 4: Reserva — $0-30/mes

Este es tu fondo de "cosas que no anticipe":

Si no usas la reserva, se acumula. Despues de 3 meses de reserva sin usar, considera reasignar a creditos API o infraestructura.

El Calculo de ROI

Este es el unico numero que importa:

Ingresos Mensuales - Costos Mensuales = Ganancia Neta
Ganancia Neta / Costos Mensuales = Multiplo de ROI

Ejemplo:
$600 ingresos - $200 costos = $400 ganancia
$400 / $200 = 2x ROI

El objetivo: 3x ROI ($600+ ingresos con $200 de gasto)
El minimo: 1x ROI ($200 ingresos = punto de equilibrio)
Por debajo de 1x: Cambia de estrategia o reduce costos

Cuando aumentar el presupuesto:

Aumenta tu presupuesto SOLO cuando:

  1. Estas consistentemente en 2x+ ROI por 2+ meses
  2. Mas gasto aumentaria directamente los ingresos (por ejemplo, mas creditos API = mas capacidad de clientes)
  3. El aumento esta vinculado a un flujo de ingresos especifico y probado

Cuando NO aumentar el presupuesto:

La escalera de crecimiento:

$200/mes  -> Probando el concepto (meses 1-3)
$500/mes  -> Escalando lo que funciona (meses 4-6)
$1000/mes -> Multiples flujos de ingresos (meses 6-12)
$2000+/mes -> Operacion de negocio completa (ano 2+)

Cada paso requiere probar ROI en el nivel actual primero.

Error Comun: Tratar los $200 como una "inversion" que no necesita retornar dinero inmediatamente. No. Este es un experimento con un plazo de 90 dias. Si $200/mes no generan $200/mes en ingresos dentro de 90 dias, algo de la estrategia necesita cambiar. El dinero, el mercado, la oferta — algo no esta funcionando. Se honesto contigo mismo.

Punto de Control de la Leccion 5

Ahora deberias tener:

En el curso completo de STREETS, el Modulo E (Manual de Ejecucion) incluye una plantilla de dashboard financiero que rastrea tu gasto, ingresos y ROI por motor de ingresos en tiempo real — para que siempre sepas que flujos son rentables y cuales necesitan ajuste.

Leccion 6: Tu Documento de Stack Soberano

"Todo negocio tiene un plan. Este es el tuyo — y cabe en dos paginas."

El Entregable

Esta es la cosa mas importante que crearas en el Modulo S. Tu Documento de Stack Soberano es una referencia unica que captura todo sobre tu infraestructura generadora de ingresos. Lo consultaras durante el resto del curso STREETS, lo actualizaras a medida que tu configuracion evolucione, y lo usaras para tomar decisiones con cabeza fria sobre que construir y que omitir.

Crea un nuevo archivo. Markdown, Google Doc, pagina de Notion, texto plano — lo que sea que realmente vayas a mantener. Usa la plantilla de abajo, llenando cada campo con los numeros y decisiones de las Lecciones 1-5.

La Plantilla

Copia esta plantilla completa y llenala. Cada campo. Sin saltar nada.

# Documento de Stack Soberano
# [Tu Nombre o Nombre del Negocio]
# Creado: [Fecha]
# Ultima Actualizacion: [Fecha]

---

## 1. INVENTARIO DE HARDWARE

### Maquina Principal
- **Tipo:** [Desktop / Laptop / Mac / Servidor]
- **CPU:** [Modelo] — [X] nucleos, [X] hilos
- **RAM:** [X] GB [DDR4/DDR5]
- **GPU:** [Modelo] — [X] GB VRAM (o "Ninguna — solo inferencia en CPU")
- **Almacenamiento:** [X] GB SSD libres / [X] GB totales
- **SO:** [Distro Linux / version macOS / version Windows]

### Red
- **Descarga:** [X] Mbps
- **Subida:** [X] Mbps
- **Latencia a APIs cloud:** [X] ms
- **Fiabilidad del ISP:** [Estable / Cortes ocasionales / No confiable]

### Capacidad de Tiempo de Actividad
- **Puede funcionar 24/7:** [Si / No — razon]
- **UPS:** [Si / No]
- **Acceso remoto:** [SSH / RDP / Tailscale / Ninguno]

### Costo Mensual de Infraestructura
- **Electricidad (estimado 24/7):** $[X]/mes
- **Internet:** $[X]/mes (porcion de negocio)
- **Costo total fijo de infraestructura:** $[X]/mes

---

## 2. STACK DE LLM

### Modelos Locales (via Ollama)
| Modelo | Tamano | Tokens/seg | Caso de Uso |
|--------|--------|-----------|-------------|
| [ej., llama3.1:8b] | [X]B | [X] tok/s | [ej., Clasificacion, extraccion] |
| [ej., mistral:7b] | [X]B | [X] tok/s | [ej., Resumen, borradores] |
| [ej., deepseek-coder] | [X]B | [X] tok/s | [ej., Generacion de codigo] |

### Modelos API (para salida de calidad critica)
| Proveedor | Modelo | Presupuesto Mensual | Caso de Uso |
|-----------|--------|---------------------|-------------|
| [ej., Anthropic] | [Claude 3.5 Sonnet] | $[X] | [ej., Contenido orientado al cliente] |
| [ej., OpenAI] | [GPT-4o-mini] | $[X] | [ej., Respaldo de procesamiento de volumen] |

### Estrategia de Inferencia
- **Lo local maneja:** [X]% de solicitudes ([listar tareas])
- **La API maneja:** [X]% de solicitudes ([listar tareas])
- **Costo combinado estimado por 1M tokens:** $[X]

---

## 3. PRESUPUESTO MENSUAL

| Categoria | Asignacion | Real (actualizar mensualmente) |
|-----------|-----------|-------------------------------|
| Creditos API | $[X] | $[  ] |
| Infraestructura (VPS, dominio, email) | $[X] | $[  ] |
| Herramientas (analiticas, email marketing) | $[X] | $[  ] |
| Reserva | $[X] | $[  ] |
| **Total** | **$[X]** | **$[  ]** |

### Objetivo de Ingresos
- **Mes 1-3:** $[X]/mes (minimo: cubrir costos)
- **Mes 4-6:** $[X]/mes
- **Mes 7-12:** $[X]/mes

---

## 4. ESTADO LEGAL

- **Estado laboral:** [Empleado / Freelance / Entre trabajos]
- **Clausula de PI revisada:** [Si / No / N/A]
- **Nivel de riesgo de clausula de PI:** [Limpio / Turbio — necesita revision / Restrictivo]
- **Entidad de negocio:** [LLC / Ltd / Empresa Individual / Aun ninguna]
  - **Estado/Pais:** [Donde esta registrada]
  - **EIN/ID Fiscal:** [Obtenido / Pendiente / No necesario aun]
- **Procesamiento de pagos:** [Stripe / Lemon Squeezy / Otro] — [Activo / Pendiente]
- **Cuenta bancaria de negocio:** [Abierta / Pendiente / Usando personal (arregla esto)]
- **Politica de privacidad:** [Hecha / Aun no — URL: ___]
- **Terminos de servicio:** [Hechos / Aun no — URL: ___]

---

## 5. INVENTARIO DE TIEMPO

- **Horas disponibles por semana para proyectos de ingresos:** [X] horas
  - **Mananas entre semana:** [X] horas
  - **Noches entre semana:** [X] horas
  - **Fines de semana:** [X] horas
- **Zona horaria:** [Tu zona horaria]
- **Mejores bloques de trabajo profundo:** [ej., "Sabado 6am-12pm, noches entre semana 8-10pm"]

### Plan de Asignacion de Tiempo
| Actividad | Horas/semana |
|-----------|-------------|
| Construir/programar | [X] |
| Marketing/ventas | [X] |
| Trabajo/entrega para clientes | [X] |
| Aprendizaje/experimentacion | [X] |
| Administracion (facturacion, email, etc.) | [X] |

> Regla: Nunca asignes mas del 70% del tiempo disponible.
> La vida pasa. El burnout es real. Deja margen.

---

## 6. INVENTARIO DE HABILIDADES

### Habilidades Principales (cosas que podrias ensenarle a otros)
1. [Habilidad] — [anos de experiencia]
2. [Habilidad] — [anos de experiencia]
3. [Habilidad] — [anos de experiencia]

### Habilidades Secundarias (competente pero no experto)
1. [Habilidad]
2. [Habilidad]
3. [Habilidad]

### Explorando (aprendiendo ahora o quieres aprender)
1. [Habilidad]
2. [Habilidad]

### Combinaciones Unicas
Que hace TU combinacion de habilidades inusual? (Esto se convierte en tu foso en el Modulo T)
- [ej., "Conozco tanto Rust COMO estandares de datos de salud — muy pocas personas tienen ambos"]
- [ej., "Puedo construir apps full-stack Y entiendo logistica de cadena de suministro de una carrera anterior"]
- [ej., "Soy fluido en 3 idiomas Y puedo programar — puedo servir mercados no angloparlantes que la mayoria de herramientas dev ignoran"]

---

## 7. RESUMEN DEL STACK SOBERANO

### Lo Que Puedo Ofrecer Hoy
(Basado en hardware + habilidades + tiempo, que podrias vender ESTA SEMANA si alguien preguntara?)
1. [ej., "Procesamiento local de documentos — extraer datos de PDFs de forma privada"]
2. [ej., "Scripts de automatizacion personalizados para [dominio especifico]"]
3. [ej., "Redaccion tecnica / documentacion"]

### Lo Que Estoy Construyendo
(Basado en el framework completo de STREETS — llena esto a medida que avances en el curso)
1. [Motor de Ingresos 1 — del Modulo R]
2. [Motor de Ingresos 2 — del Modulo R]
3. [Motor de Ingresos 3 — del Modulo R]

### Restricciones Clave
(Se honesto — estas no son debilidades, son parametros)
- [ej., "Solo 10 horas/semana disponibles"]
- [ej., "Sin GPU — solo inferencia en CPU, dependere de APIs para tareas LLM"]
- [ej., "Contrato de trabajo es restrictivo — necesito mantenerme en dominios no relacionados"]
- [ej., "No basado en EE.UU. — algunas opciones de pago/legales son limitadas"]

---

*Este documento es una referencia viva. Actualizalo mensualmente.*
*Proxima fecha de revision: [Fecha + 30 dias]*

Como Usar Este Documento

  1. Antes de iniciar cualquier proyecto nuevo: Revisa tu Stack Soberano. Tienes el hardware, tiempo, habilidades y presupuesto para ejecutar?
  2. Antes de comprar cualquier cosa: Revisa tu asignacion de presupuesto. Esta compra esta en el plan?
  3. Revision mensual: Actualiza la columna "Real" en tu presupuesto. Actualiza numeros de ingresos. Ajusta asignaciones basado en lo que esta funcionando.
  4. Cuando alguien pregunte a que te dedicas: Tu seccion "Lo Que Puedo Ofrecer Hoy" es tu pitch instantaneo.
  5. Cuando estes tentado a perseguir una nueva idea brillante: Revisa tus restricciones. Esto cabe dentro de tu tiempo, habilidades y hardware? Si no, agregalo a "Lo Que Estoy Construyendo" para despues.

El Ejercicio de Una Hora

Pon un temporizador de 60 minutos. Llena cada campo de la plantilla. No lo pienses demasiado. No investigues extensamente. Escribe lo que sabes ahora mismo. Puedes actualizarlo despues.

Los campos que no puedes llenar? Esos son tus tareas pendientes para esta semana:

Error Comun: Dedicar 3 horas a hacer el documento "perfecto" en vez de 1 hora a hacerlo "terminado." El Documento de Stack Soberano es una referencia de trabajo, no un plan de negocios para inversionistas. Nadie lo vera excepto tu. La precision importa. El formato no.

Punto de Control de la Leccion 6

Ahora deberias tener:

Modulo S: Completo

Lo Que Has Construido en Dos Semanas

Mira lo que ahora tienes que no tenias cuando empezaste:

  1. Un inventario de hardware mapeado a capacidades generadoras de ingresos — no solo especificaciones en una etiqueta.
  2. Un stack de LLM local de grado produccion con Ollama, con benchmark en tu hardware real, configurado para cargas de trabajo reales.
  3. Una ventaja de privacidad que entiendes como comercializar — con lenguaje especifico para audiencias especificas.
  4. Una base legal y financiera — entidad de negocio (o plan), procesamiento de pagos, cuenta bancaria, estrategia fiscal.
  5. Un presupuesto controlado con objetivos claros de ROI y un plazo de 90 dias para probar el modelo.
  6. Un Documento de Stack Soberano que captura todo lo anterior en una referencia unica que usaras para cada decision de aqui en adelante.

Esto es mas de lo que la mayoria de los desarrolladores jamas configura. En serio. La mayoria de las personas que quieren generar ingresos paralelos saltan directo a "construir algo genial" y luego se preguntan por que no pueden cobrar. Tu ahora tienes la infraestructura para cobrar.

Pero infraestructura sin direccion es solo un hobby caro. Necesitas saber hacia donde apuntar este stack.

Lo Que Sigue: Modulo T — Fosos Tecnicos

El Modulo S te dio la base. El Modulo T responde la pregunta critica: como construyes algo que los competidores no puedan copiar facilmente?

Esto es lo que cubre el Modulo T:

La diferencia entre un desarrollador que gana $500/mes y uno que gana $5,000/mes rara vez es habilidad. Son los fosos. Cosas que hacen tu oferta dificil de replicar, incluso si alguien tiene el mismo hardware y los mismos modelos.

La Hoja de Ruta Completa de STREETS

Modulo Titulo Enfoque Duracion
S Configuracion Soberana Infraestructura, legal, presupuesto Semanas 1-2 (completo)
T Fosos Tecnicos Ventajas defendibles, activos propietarios Semanas 3-4
R Motores de Ingresos Guias especificas de monetizacion con codigo Semanas 5-8
E Manual de Ejecucion Secuencias de lanzamiento, precios, primeros clientes Semanas 9-10
E Ventaja en Evolucion Mantenerse adelante, deteccion de tendencias, adaptacion Semanas 11-12
T Automatizacion Tactica Automatizar operaciones para ingresos pasivos Semanas 13-14
S Apilando Flujos Multiples fuentes de ingresos, estrategia de portafolio Semanas 15-16

El Modulo R (Motores de Ingresos) es donde se gana la mayor parte del dinero. Pero sin S y T, estas construyendo sobre arena.

Listo para la guia completa?

Has visto la base. La has construido tu mismo. Ahora obtiene el sistema completo.

Obtiene STREETS Core — el curso completo de 16 semanas con los siete modulos, plantillas de codigo de motores de ingresos, dashboards financieros y la comunidad privada de desarrolladores construyendo ingresos en sus propios terminos.

Tu equipo. Tus reglas. Tus ingresos.

Siguiente → Modulo T: Fosos Tecnicos