# Programming Languages Used in open-seo: A Complete Technical Breakdown

> Discover the programming languages powering open-seo. Explore the technical breakdown of TypeScript, TSX, JavaScript, SQL, YAML, and Docker in this comprehensive guide.

- Repository: [Every App/open-seo](https://github.com/every-app/open-seo)
- Tags: deep-dive
- Published: 2026-07-29

---

**open-seo relies primarily on TypeScript and TSX for its full-stack architecture, while leveraging JavaScript, SQL, YAML, and Docker for supporting infrastructure and tooling.**

The **every-app/open-seo** repository is a modern SEO management platform that demonstrates how a unified TypeScript codebase can power both React frontends and server-side logic. Understanding the programming languages used in open-seo reveals a strategic blend of core application code and configuration languages optimized for developer experience and deployment flexibility.

## TypeScript and TSX: The Core Language Stack

**TypeScript** dominates the open-seo codebase, serving as the primary programming language for the React user interface, TanStack router configurations, and server-side functions. The project uses **TSX** (TypeScript with JSX) extensively for component development, enabling type-safe JSX syntax throughout the application.

The router configuration in [`src/router.tsx`](https://github.com/every-app/open-seo/blob/main/src/router.tsx) demonstrates this pattern:

```typescript
// src/router.tsx
import { createRouter as createTanStackRouter } from "@tanstack/react-router";
import { routeTree } from "./routeTree.gen";
import { DefaultCatchBoundary } from "./client/components/DefaultCatchBoundary";
import { NotFound } from "./client/components/NotFound";

export function getRouter() {
  const router = createTanStackRouter({
    routeTree,
    defaultPreload: "intent",
    defaultErrorComponent: DefaultCatchBoundary,
    defaultNotFoundComponent: () => <NotFound />,
    scrollRestoration: true,
  });

  return router;
}

```

This file illustrates how TypeScript interfaces with the TanStack ecosystem. Additional configuration files like [`web/vite.config.ts`](https://github.com/every-app/open-seo/blob/main/web/vite.config.ts) and [`drizzle.config.ts`](https://github.com/every-app/open-seo/blob/main/drizzle.config.ts) further confirm TypeScript's role in build tooling and ORM setup, managing both SQLite and Postgres database adapters through type-safe configurations.

## Supporting Languages and Infrastructure Configuration

While TypeScript handles application logic, open-seo incorporates several auxiliary languages for specific operational needs.

### JavaScript for Utility Scripts

Plain **JavaScript** appears in Node.js utility scripts and release tooling that execute outside the main TypeScript compilation pipeline. The repository includes files like `scripts/release-notes.mjs` and compiled CLI authentication helpers that handle auxiliary tasks such as data seeding and release automation.

### SQL for Database Migrations

Raw **SQL** powers the database schema definitions and migration scripts managed by the Drizzle ORM. Migration files located in directories like `drizzle-pg/` contain platform-specific SQL for Postgres deployments:

```sql
-- drizzle-pg/0012_dashboard.sql
CREATE TABLE dashboard (
  id          SERIAL PRIMARY KEY,
  user_id     INTEGER NOT NULL,
  created_at  TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
  updated_at  TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

```

These SQL files execute during deployment to establish table structures, indexes, and relationships outside the TypeScript type system.

### YAML for DevOps and Workspace Management

**YAML** configures the project's monorepo structure and deployment orchestration. The [`pnpm-workspace.yaml`](https://github.com/every-app/open-seo/blob/main/pnpm-workspace.yaml) file defines the workspace layout for the pnpm package manager, while [`compose.yaml`](https://github.com/every-app/open-seo/blob/main/compose.yaml) handles Docker Compose orchestration for local development environments.

### Dockerfile and Containerization

The `Dockerfile.selfhost` uses **Dockerfile** syntax to define container images for self-hosting scenarios, specifying base images, dependency installation, and runtime configurations necessary for containerized deployment.

### JSON and Markdown for Metadata and Documentation

**JSON** and **JSONC** (JSON with Comments) appear in [`package.json`](https://github.com/every-app/open-seo/blob/main/package.json) manifests and configuration files like `wrangler.jsonc`, while **Markdown** documents the project structure in [`README.md`](https://github.com/every-app/open-seo/blob/main/README.md) and other specification files.

## Summary

- **TypeScript/TSX** serves as the dominant programming language for open-seo's React frontend, TanStack router, and server-side functions.
- **JavaScript** handles utility scripts and Node.js tooling executed outside the main application build.
- **SQL** defines database schemas and migrations for Postgres and SQLite through Drizzle ORM.
- **YAML** manages monorepo workspaces and container orchestration configurations.
- **Dockerfile**, **JSON**, and **Markdown** provide container definitions, package manifests, and project documentation respectively.

## Frequently Asked Questions

### Is open-seo written entirely in TypeScript?

No, while **TypeScript** is the primary programming language for application logic in the every-app/open-seo repository, the project incorporates JavaScript for utility scripts, SQL for database migrations, YAML for configuration, and Dockerfiles for containerization. The main application code in [`src/router.tsx`](https://github.com/every-app/open-seo/blob/main/src/router.tsx) and configuration files like [`drizzle.config.ts`](https://github.com/every-app/open-seo/blob/main/drizzle.config.ts) are TypeScript, but supporting infrastructure uses additional languages.

### What database does open-seo use?

According to the source code analysis, open-seo supports both **SQLite** and **Postgres** databases, configured through the Drizzle ORM. The presence of [`drizzle-pg/0012_dashboard.sql`](https://github.com/every-app/open-seo/blob/main/drizzle-pg/0012_dashboard.sql) and similar migration files indicates Postgres support, while the [`drizzle.config.ts`](https://github.com/every-app/open-seo/blob/main/drizzle.config.ts) file configures adapters for multiple database engines.

### Why does open-seo use YAML files?

The repository uses **YAML** for project-level configuration that requires human-readable structure without the strict syntax of JSON. Files like [`pnpm-workspace.yaml`](https://github.com/every-app/open-seo/blob/main/pnpm-workspace.yaml) define the monorepo workspace layout for pnpm, while [`compose.yaml`](https://github.com/every-app/open-seo/blob/main/compose.yaml) manages Docker Compose services, making dependency and service management more maintainable than equivalent JSON configurations.

### Can I contribute to open-seo if I only know JavaScript?

Yes, though **TypeScript** is preferred for core contributions, plain **JavaScript** skills remain valuable for utility scripts located in the `scripts/` directory and for understanding compiled outputs. However, modifying the React components in [`src/router.tsx`](https://github.com/every-app/open-seo/blob/main/src/router.tsx) or server functions requires TypeScript familiarity to maintain type safety across the full-stack architecture.