import { useEffect, useState } from "react";

export function useFetch<T>(url: string) {
  const [data, setData] = useState<T | null>(null);
  useEffect(() => {
    fetch(url).then((res) => res.json()).then(setData);
  }, [url]);
  return data;
}

type Status = "idle" | "loading" | "success" | "error";

interface Config {
  runtime: "edge" | "nodejs";
  regions: string[];
  cache: { ttl: number; swr: boolean };
}

class Queue<T> {
  private items: T[] = [];
  push(item: T) {
    this.items.push(item);
  }
  pop(): T | undefined {
    return this.items.shift();
  }
}

SELECT id, nombre, estado FROM registros
WHERE activo = true ORDER BY prioridad DESC;

.grid {
  display: grid;
  grid-template-columns: repeat(12, 1fr);
  gap: 1.5rem;
}

$ deploy --env=production --region=auto
> build completed in 4.21s

import { useEffect, useState } from "react";

export function useFetch<T>(url: string) {
  const [data, setData] = useState<T | null>(null);
  useEffect(() => {
    fetch(url).then((res) => res.json()).then(setData);
  }, [url]);
  return data;
}

type Status = "idle" | "loading" | "success" | "error";

interface Config {
  runtime: "edge" | "nodejs";
  regions: string[];
  cache: { ttl: number; swr: boolean };
}

class Queue<T> {
  private items: T[] = [];
  push(item: T) {
    this.items.push(item);
  }
  pop(): T | undefined {
    return this.items.shift();
  }
}

SELECT id, nombre, estado FROM registros
WHERE activo = true ORDER BY prioridad DESC;

.grid {
  display: grid;
  grid-template-columns: repeat(12, 1fr);
  gap: 1.5rem;
}

$ deploy --env=production --region=auto
> build completed in 4.21s

import { useEffect, useState } from "react";

export function useFetch<T>(url: string) {
  const [data, setData] = useState<T | null>(null);
  useEffect(() => {
    fetch(url).then((res) => res.json()).then(setData);
  }, [url]);
  return data;
}

type Status = "idle" | "loading" | "success" | "error";

interface Config {
  runtime: "edge" | "nodejs";
  regions: string[];
  cache: { ttl: number; swr: boolean };
}

class Queue<T> {
  private items: T[] = [];
  push(item: T) {
    this.items.push(item);
  }
  pop(): T | undefined {
    return this.items.shift();
  }
}

SELECT id, nombre, estado FROM registros
WHERE activo = true ORDER BY prioridad DESC;

.grid {
  display: grid;
  grid-template-columns: repeat(12, 1fr);
  gap: 1.5rem;
}

$ deploy --env=production --region=auto
> build completed in 4.21s

import { useEffect, useState } from "react";

export function useFetch<T>(url: string) {
  const [data, setData] = useState<T | null>(null);
  useEffect(() => {
    fetch(url).then((res) => res.json()).then(setData);
  }, [url]);
  return data;
}

type Status = "idle" | "loading" | "success" | "error";

interface Config {
  runtime: "edge" | "nodejs";
  regions: string[];
  cache: { ttl: number; swr: boolean };
}

class Queue<T> {
  private items: T[] = [];
  push(item: T) {
    this.items.push(item);
  }
  pop(): T | undefined {
    return this.items.shift();
  }
}

SELECT id, nombre, estado FROM registros
WHERE activo = true ORDER BY prioridad DESC;

.grid {
  display: grid;
  grid-template-columns: repeat(12, 1fr);
  gap: 1.5rem;
}

$ deploy --env=production --region=auto
> build completed in 4.21s

import { useEffect, useState } from "react";

export function useFetch<T>(url: string) {
  const [data, setData] = useState<T | null>(null);
  useEffect(() => {
    fetch(url).then((res) => res.json()).then(setData);
  }, [url]);
  return data;
}

type Status = "idle" | "loading" | "success" | "error";

interface Config {
  runtime: "edge" | "nodejs";
  regions: string[];
  cache: { ttl: number; swr: boolean };
}

class Queue<T> {
  private items: T[] = [];
  push(item: T) {
    this.items.push(item);
  }
  pop(): T | undefined {
    return this.items.shift();
  }
}

SELECT id, nombre, estado FROM registros
WHERE activo = true ORDER BY prioridad DESC;

.grid {
  display: grid;
  grid-template-columns: repeat(12, 1fr);
  gap: 1.5rem;
}

$ deploy --env=production --region=auto
> build completed in 4.21s

import { useEffect, useState } from "react";

export function useFetch<T>(url: string) {
  const [data, setData] = useState<T | null>(null);
  useEffect(() => {
    fetch(url).then((res) => res.json()).then(setData);
  }, [url]);
  return data;
}

type Status = "idle" | "loading" | "success" | "error";

interface Config {
  runtime: "edge" | "nodejs";
  regions: string[];
  cache: { ttl: number; swr: boolean };
}

class Queue<T> {
  private items: T[] = [];
  push(item: T) {
    this.items.push(item);
  }
  pop(): T | undefined {
    return this.items.shift();
  }
}

SELECT id, nombre, estado FROM registros
WHERE activo = true ORDER BY prioridad DESC;

.grid {
  display: grid;
  grid-template-columns: repeat(12, 1fr);
  gap: 1.5rem;
}

$ deploy --env=production --region=auto
> build completed in 4.21s

import { useEffect, useState } from "react";

export function useFetch<T>(url: string) {
  const [data, setData] = useState<T | null>(null);
  useEffect(() => {
    fetch(url).then((res) => res.json()).then(setData);
  }, [url]);
  return data;
}

type Status = "idle" | "loading" | "success" | "error";

interface Config {
  runtime: "edge" | "nodejs";
  regions: string[];
  cache: { ttl: number; swr: boolean };
}

class Queue<T> {
  private items: T[] = [];
  push(item: T) {
    this.items.push(item);
  }
  pop(): T | undefined {
    return this.items.shift();
  }
}

SELECT id, nombre, estado FROM registros
WHERE activo = true ORDER BY prioridad DESC;

.grid {
  display: grid;
  grid-template-columns: repeat(12, 1fr);
  gap: 1.5rem;
}

$ deploy --env=production --region=auto
> build completed in 4.21s

import { useEffect, useState } from "react";

export function useFetch<T>(url: string) {
  const [data, setData] = useState<T | null>(null);
  useEffect(() => {
    fetch(url).then((res) => res.json()).then(setData);
  }, [url]);
  return data;
}

type Status = "idle" | "loading" | "success" | "error";

interface Config {
  runtime: "edge" | "nodejs";
  regions: string[];
  cache: { ttl: number; swr: boolean };
}

class Queue<T> {
  private items: T[] = [];
  push(item: T) {
    this.items.push(item);
  }
  pop(): T | undefined {
    return this.items.shift();
  }
}

SELECT id, nombre, estado FROM registros
WHERE activo = true ORDER BY prioridad DESC;

.grid {
  display: grid;
  grid-template-columns: repeat(12, 1fr);
  gap: 1.5rem;
}

$ deploy --env=production --region=auto
> build completed in 4.21s

import { useEffect, useState } from "react";

export function useFetch<T>(url: string) {
  const [data, setData] = useState<T | null>(null);
  useEffect(() => {
    fetch(url).then((res) => res.json()).then(setData);
  }, [url]);
  return data;
}

type Status = "idle" | "loading" | "success" | "error";

interface Config {
  runtime: "edge" | "nodejs";
  regions: string[];
  cache: { ttl: number; swr: boolean };
}

class Queue<T> {
  private items: T[] = [];
  push(item: T) {
    this.items.push(item);
  }
  pop(): T | undefined {
    return this.items.shift();
  }
}

SELECT id, nombre, estado FROM registros
WHERE activo = true ORDER BY prioridad DESC;

.grid {
  display: grid;
  grid-template-columns: repeat(12, 1fr);
  gap: 1.5rem;
}

$ deploy --env=production --region=auto
> build completed in 4.21s

import { useEffect, useState } from "react";

export function useFetch<T>(url: string) {
  const [data, setData] = useState<T | null>(null);
  useEffect(() => {
    fetch(url).then((res) => res.json()).then(setData);
  }, [url]);
  return data;
}

type Status = "idle" | "loading" | "success" | "error";

interface Config {
  runtime: "edge" | "nodejs";
  regions: string[];
  cache: { ttl: number; swr: boolean };
}

class Queue<T> {
  private items: T[] = [];
  push(item: T) {
    this.items.push(item);
  }
  pop(): T | undefined {
    return this.items.shift();
  }
}

SELECT id, nombre, estado FROM registros
WHERE activo = true ORDER BY prioridad DESC;

.grid {
  display: grid;
  grid-template-columns: repeat(12, 1fr);
  gap: 1.5rem;
}

$ deploy --env=production --region=auto
> build completed in 4.21s

import { useEffect, useState } from "react";

export function useFetch<T>(url: string) {
  const [data, setData] = useState<T | null>(null);
  useEffect(() => {
    fetch(url).then((res) => res.json()).then(setData);
  }, [url]);
  return data;
}

type Status = "idle" | "loading" | "success" | "error";

interface Config {
  runtime: "edge" | "nodejs";
  regions: string[];
  cache: { ttl: number; swr: boolean };
}

class Queue<T> {
  private items: T[] = [];
  push(item: T) {
    this.items.push(item);
  }
  pop(): T | undefined {
    return this.items.shift();
  }
}

SELECT id, nombre, estado FROM registros
WHERE activo = true ORDER BY prioridad DESC;

.grid {
  display: grid;
  grid-template-columns: repeat(12, 1fr);
  gap: 1.5rem;
}

$ deploy --env=production --region=auto
> build completed in 4.21s

import { useEffect, useState } from "react";

export function useFetch<T>(url: string) {
  const [data, setData] = useState<T | null>(null);
  useEffect(() => {
    fetch(url).then((res) => res.json()).then(setData);
  }, [url]);
  return data;
}

type Status = "idle" | "loading" | "success" | "error";

interface Config {
  runtime: "edge" | "nodejs";
  regions: string[];
  cache: { ttl: number; swr: boolean };
}

class Queue<T> {
  private items: T[] = [];
  push(item: T) {
    this.items.push(item);
  }
  pop(): T | undefined {
    return this.items.shift();
  }
}

SELECT id, nombre, estado FROM registros
WHERE activo = true ORDER BY prioridad DESC;

.grid {
  display: grid;
  grid-template-columns: repeat(12, 1fr);
  gap: 1.5rem;
}

$ deploy --env=production --region=auto
> build completed in 4.21s

import { useEffect, useState } from "react";

export function useFetch<T>(url: string) {
  const [data, setData] = useState<T | null>(null);
  useEffect(() => {
    fetch(url).then((res) => res.json()).then(setData);
  }, [url]);
  return data;
}

type Status = "idle" | "loading" | "success" | "error";

interface Config {
  runtime: "edge" | "nodejs";
  regions: string[];
  cache: { ttl: number; swr: boolean };
}

class Queue<T> {
  private items: T[] = [];
  push(item: T) {
    this.items.push(item);
  }
  pop(): T | undefined {
    return this.items.shift();
  }
}

SELECT id, nombre, estado FROM registros
WHERE activo = true ORDER BY prioridad DESC;

.grid {
  display: grid;
  grid-template-columns: repeat(12, 1fr);
  gap: 1.5rem;
}

$ deploy --env=production --region=auto
> build completed in 4.21s

import { useEffect, useState } from "react";

export function useFetch<T>(url: string) {
  const [data, setData] = useState<T | null>(null);
  useEffect(() => {
    fetch(url).then((res) => res.json()).then(setData);
  }, [url]);
  return data;
}

type Status = "idle" | "loading" | "success" | "error";

interface Config {
  runtime: "edge" | "nodejs";
  regions: string[];
  cache: { ttl: number; swr: boolean };
}

class Queue<T> {
  private items: T[] = [];
  push(item: T) {
    this.items.push(item);
  }
  pop(): T | undefined {
    return this.items.shift();
  }
}

SELECT id, nombre, estado FROM registros
WHERE activo = true ORDER BY prioridad DESC;

.grid {
  display: grid;
  grid-template-columns: repeat(12, 1fr);
  gap: 1.5rem;
}

$ deploy --env=production --region=auto
> build completed in 4.21s

import { useEffect, useState } from "react";

export function useFetch<T>(url: string) {
  const [data, setData] = useState<T | null>(null);
  useEffect(() => {
    fetch(url).then((res) => res.json()).then(setData);
  }, [url]);
  return data;
}

type Status = "idle" | "loading" | "success" | "error";

interface Config {
  runtime: "edge" | "nodejs";
  regions: string[];
  cache: { ttl: number; swr: boolean };
}

class Queue<T> {
  private items: T[] = [];
  push(item: T) {
    this.items.push(item);
  }
  pop(): T | undefined {
    return this.items.shift();
  }
}

SELECT id, nombre, estado FROM registros
WHERE activo = true ORDER BY prioridad DESC;

.grid {
  display: grid;
  grid-template-columns: repeat(12, 1fr);
  gap: 1.5rem;
}

$ deploy --env=production --region=auto
> build completed in 4.21s

import { useEffect, useState } from "react";

export function useFetch<T>(url: string) {
  const [data, setData] = useState<T | null>(null);
  useEffect(() => {
    fetch(url).then((res) => res.json()).then(setData);
  }, [url]);
  return data;
}

type Status = "idle" | "loading" | "success" | "error";

interface Config {
  runtime: "edge" | "nodejs";
  regions: string[];
  cache: { ttl: number; swr: boolean };
}

class Queue<T> {
  private items: T[] = [];
  push(item: T) {
    this.items.push(item);
  }
  pop(): T | undefined {
    return this.items.shift();
  }
}

SELECT id, nombre, estado FROM registros
WHERE activo = true ORDER BY prioridad DESC;

.grid {
  display: grid;
  grid-template-columns: repeat(12, 1fr);
  gap: 1.5rem;
}

$ deploy --env=production --region=auto
> build completed in 4.21s

import { useEffect, useState } from "react";

export function useFetch<T>(url: string) {
  const [data, setData] = useState<T | null>(null);
  useEffect(() => {
    fetch(url).then((res) => res.json()).then(setData);
  }, [url]);
  return data;
}

type Status = "idle" | "loading" | "success" | "error";

interface Config {
  runtime: "edge" | "nodejs";
  regions: string[];
  cache: { ttl: number; swr: boolean };
}

class Queue<T> {
  private items: T[] = [];
  push(item: T) {
    this.items.push(item);
  }
  pop(): T | undefined {
    return this.items.shift();
  }
}

SELECT id, nombre, estado FROM registros
WHERE activo = true ORDER BY prioridad DESC;

.grid {
  display: grid;
  grid-template-columns: repeat(12, 1fr);
  gap: 1.5rem;
}

$ deploy --env=production --region=auto
> build completed in 4.21s

import { useEffect, useState } from "react";

export function useFetch<T>(url: string) {
  const [data, setData] = useState<T | null>(null);
  useEffect(() => {
    fetch(url).then((res) => res.json()).then(setData);
  }, [url]);
  return data;
}

type Status = "idle" | "loading" | "success" | "error";

interface Config {
  runtime: "edge" | "nodejs";
  regions: string[];
  cache: { ttl: number; swr: boolean };
}

class Queue<T> {
  private items: T[] = [];
  push(item: T) {
    this.items.push(item);
  }
  pop(): T | undefined {
    return this.items.shift();
  }
}

SELECT id, nombre, estado FROM registros
WHERE activo = true ORDER BY prioridad DESC;

.grid {
  display: grid;
  grid-template-columns: repeat(12, 1fr);
  gap: 1.5rem;
}

$ deploy --env=production --region=auto
> build completed in 4.21s

import { useEffect, useState } from "react";

export function useFetch<T>(url: string) {
  const [data, setData] = useState<T | null>(null);
  useEffect(() => {
    fetch(url).then((res) => res.json()).then(setData);
  }, [url]);
  return data;
}

type Status = "idle" | "loading" | "success" | "error";

interface Config {
  runtime: "edge" | "nodejs";
  regions: string[];
  cache: { ttl: number; swr: boolean };
}

class Queue<T> {
  private items: T[] = [];
  push(item: T) {
    this.items.push(item);
  }
  pop(): T | undefined {
    return this.items.shift();
  }
}

SELECT id, nombre, estado FROM registros
WHERE activo = true ORDER BY prioridad DESC;

.grid {
  display: grid;
  grid-template-columns: repeat(12, 1fr);
  gap: 1.5rem;
}

$ deploy --env=production --region=auto
> build completed in 4.21s

import { useEffect, useState } from "react";

export function useFetch<T>(url: string) {
  const [data, setData] = useState<T | null>(null);
  useEffect(() => {
    fetch(url).then((res) => res.json()).then(setData);
  }, [url]);
  return data;
}

type Status = "idle" | "loading" | "success" | "error";

interface Config {
  runtime: "edge" | "nodejs";
  regions: string[];
  cache: { ttl: number; swr: boolean };
}

class Queue<T> {
  private items: T[] = [];
  push(item: T) {
    this.items.push(item);
  }
  pop(): T | undefined {
    return this.items.shift();
  }
}

SELECT id, nombre, estado FROM registros
WHERE activo = true ORDER BY prioridad DESC;

.grid {
  display: grid;
  grid-template-columns: repeat(12, 1fr);
  gap: 1.5rem;
}

$ deploy --env=production --region=auto
> build completed in 4.21s

import { useEffect, useState } from "react";

export function useFetch<T>(url: string) {
  const [data, setData] = useState<T | null>(null);
  useEffect(() => {
    fetch(url).then((res) => res.json()).then(setData);
  }, [url]);
  return data;
}

type Status = "idle" | "loading" | "success" | "error";

interface Config {
  runtime: "edge" | "nodejs";
  regions: string[];
  cache: { ttl: number; swr: boolean };
}

class Queue<T> {
  private items: T[] = [];
  push(item: T) {
    this.items.push(item);
  }
  pop(): T | undefined {
    return this.items.shift();
  }
}

SELECT id, nombre, estado FROM registros
WHERE activo = true ORDER BY prioridad DESC;

.grid {
  display: grid;
  grid-template-columns: repeat(12, 1fr);
  gap: 1.5rem;
}

$ deploy --env=production --region=auto
> build completed in 4.21s

import { useEffect, useState } from "react";

export function useFetch<T>(url: string) {
  const [data, setData] = useState<T | null>(null);
  useEffect(() => {
    fetch(url).then((res) => res.json()).then(setData);
  }, [url]);
  return data;
}

type Status = "idle" | "loading" | "success" | "error";

interface Config {
  runtime: "edge" | "nodejs";
  regions: string[];
  cache: { ttl: number; swr: boolean };
}

class Queue<T> {
  private items: T[] = [];
  push(item: T) {
    this.items.push(item);
  }
  pop(): T | undefined {
    return this.items.shift();
  }
}

SELECT id, nombre, estado FROM registros
WHERE activo = true ORDER BY prioridad DESC;

.grid {
  display: grid;
  grid-template-columns: repeat(12, 1fr);
  gap: 1.5rem;
}

$ deploy --env=production --region=auto
> build completed in 4.21s

import { useEffect, useState } from "react";

export function useFetch<T>(url: string) {
  const [data, setData] = useState<T | null>(null);
  useEffect(() => {
    fetch(url).then((res) => res.json()).then(setData);
  }, [url]);
  return data;
}

type Status = "idle" | "loading" | "success" | "error";

interface Config {
  runtime: "edge" | "nodejs";
  regions: string[];
  cache: { ttl: number; swr: boolean };
}

class Queue<T> {
  private items: T[] = [];
  push(item: T) {
    this.items.push(item);
  }
  pop(): T | undefined {
    return this.items.shift();
  }
}

SELECT id, nombre, estado FROM registros
WHERE activo = true ORDER BY prioridad DESC;

.grid {
  display: grid;
  grid-template-columns: repeat(12, 1fr);
  gap: 1.5rem;
}

$ deploy --env=production --region=auto
> build completed in 4.21s

import { useEffect, useState } from "react";

export function useFetch<T>(url: string) {
  const [data, setData] = useState<T | null>(null);
  useEffect(() => {
    fetch(url).then((res) => res.json()).then(setData);
  }, [url]);
  return data;
}

type Status = "idle" | "loading" | "success" | "error";

interface Config {
  runtime: "edge" | "nodejs";
  regions: string[];
  cache: { ttl: number; swr: boolean };
}

class Queue<T> {
  private items: T[] = [];
  push(item: T) {
    this.items.push(item);
  }
  pop(): T | undefined {
    return this.items.shift();
  }
}

SELECT id, nombre, estado FROM registros
WHERE activo = true ORDER BY prioridad DESC;

.grid {
  display: grid;
  grid-template-columns: repeat(12, 1fr);
  gap: 1.5rem;
}

$ deploy --env=production --region=auto
> build completed in 4.21s

GovTech / Smart City

Transformación digital para gobiernos y ciudades más inteligentes

Ayudamos a gobiernos y municipios a modernizar su gestión con tecnología, datos e innovación: procesos más simples, decisiones más eficientes y servicios pensados para las personas.

Contactanos Conocé nuestros servicios

Gestión pública
Datos e innovación
Smart Cities

Misión

Acompañar a gobiernos y municipios en su transformación digital, combinando tecnología, datos, innovación y gestión pública para crear procesos más eficientes, servicios más simples y ciudades más inteligentes, sostenibles y centradas en las personas.

Visión

Ser un referente en soluciones GovTech y Smart City en Argentina y Latinoamérica, conectando gobiernos con tecnología, conocimiento y ecosistemas de innovación para impulsar nuevas formas de gestionar y construir ciudades.

Cómo trabajamos

Nuestros valores

Los principios que guían cada proyecto que encaramos junto a gobiernos y municipios.

Innovación

Buscamos nuevas formas de resolver problemas públicos con tecnología y creatividad.

Impacto

Medimos nuestro trabajo por el resultado real que genera en la vida de las personas.

Cercanía

Trabajamos codo a codo con los equipos de gobierno, entendiendo su realidad.

Colaboración

Creemos en construir junto a otros actores del ecosistema público y privado.

Datos para decidir

Convertimos datos en información útil para tomar mejores decisiones de gobierno.

Simplicidad

Diseñamos soluciones simples de usar, tanto para el Estado como para la ciudadanía.

Transparencia

Actuamos con honestidad y criterios claros en cada proyecto que encaramos.

Sostenibilidad

Pensamos soluciones que perduren en el tiempo, más allá de una gestión puntual.

Qué hacemos

Servicios y soluciones

Cuatro pilares para acompañar la transformación digital de gobiernos y municipios.

Transformación digital

Modernización de procesos y trámites de gobierno para hacerlos más simples, rápidos y accesibles.

Digitalización de trámites y procesos internos
Gobierno electrónico y ventanilla única digital
Acompañamiento en el cambio organizacional

Datos y analítica pública

Infraestructura y análisis de datos para una gestión pública basada en evidencia.

Tableros de indicadores y datos abiertos
Integración de fuentes de datos municipales
Modelos de análisis para la toma de decisiones

Smart City / IoT

Soluciones de ciudad inteligente que conectan sensores, infraestructura y datos urbanos.

Monitoreo urbano con sensores IoT
Movilidad, alumbrado y ambiente inteligente
Plataformas de gestión de ciudad centralizadas

Consultoría en gestión pública

Acompañamiento estratégico a equipos de gobierno en el diseño e implementación de políticas.

Diagnóstico y hoja de ruta de innovación
Diseño de políticas públicas basadas en datos
Capacitación de equipos de gobierno

Casos de uso

Portafolio

Proyectos en los que trabajamos junto a gobiernos locales.

Modernización municipal

Villa Allende Digital

Rediseño y digitalización de trámites municipales para reducir tiempos de gestión y mejorar la experiencia de la ciudadanía.

Villa Allende

Digitalización de servicios
Modernización municipal

Software de gestión interna

Gestión de obras y maquinaria municipal

Plataforma interna para planificar obras, consultar la disponibilidad de maquinaria y organizar cuadrillas y recursos, agilizando la resolución de problemas como el bacheo y el mantenimiento urbano.

Solución para municipios

Planificación de obras
Gestión de recursos

Atención ciudadana

Ramal Sistema de reclamos de Poda y cuidado de espacios verdes

Sistema que unifica los reclamos que llegan por WhatsApp, web, teléfono y redes en un solo lugar, con seguimiento y trazabilidad de cada caso hasta su resolución.

Solución para municipios

Omnicanalidad
Atención ciudadana
Poda y cuidado de espacios verdes

Salud animal y tenencia responsable

Zoonosis - Municipalidad de Villa Allende

Aplicación para el registro municipal de mascotas: permite dar de alta animales y sus responsables, llevar el historial de vacunación, y gestionar adopciones, todo en un solo lugar y con información siempre actualizada para el área de Zoonosis.

Municipalidad de Villa Allende

Mascotas
Adopción
Vacunación
Registro