# What Programming Languages Are Used in the Open‑SEO Project? A Complete Technical Breakdown

> Discover the programming languages powering the open-seo project. Explore TypeScript for application code and SQL for database needs in this technical breakdown.

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

---

**The open‑seo project is built primarily with TypeScript for its application codebase and SQL for database migrations.** Configuration files use JSON, YAML, and Dockerfile syntax, but these are supporting infrastructure rather than primary programming languages.

This article examines the source structure of **every-app/open-seo** to identify exactly which languages power this SEO management platform. Understanding the stack helps contributors onboard faster and informs architectural decisions for similar projects.

## Primary Programming Language: TypeScript

TypeScript dominates the repository, appearing in both `.ts` and `.tsx` extensions throughout the codebase.

### Server-Side TypeScript (`*.ts`)

The back-end logic, API routes, and utility modules all use standard TypeScript files:

- **[`src/server.ts`](https://github.com/every-app/open-seo/blob/main/src/server.ts)** – Main application entry point that bootstraps the HTTP server
- **`src/routes/`** – API endpoint definitions for project management, reporting, and integrations
- **`src/lib/`** – Shared utilities, database connection helpers, and validation logic

TypeScript's static typing provides compile-time safety for the server's data modeling and API contracts.

### Client-Side TypeScript with React (`*.tsx`)

The front-end interface uses TSX files combining TypeScript with JSX syntax:

- **[`src/client/features/projects/ProjectSwitcher.tsx`](https://github.com/every-app/open-seo/blob/main/src/client/features/projects/ProjectSwitcher.tsx)** – React component for navigating between SEO projects
- **`src/client/pages/`** – Route-level page components with typed props and state
- **`src/client/hooks/`** – Custom React hooks with inferred return types

These files embed HTML-like markup directly within TypeScript, enabling type-checked component interfaces.

```typescript
// Example: A typed server function for project retrieval
// File location: src/lib/project.ts (inferred from project structure)
export async function getProject(projectId: string) {
  const project = await db.project.findUnique({ where: { id: projectId } });
  return project;
}

```

```typescript
// Example: A typed React component (TSX pattern)
// File location: src/client/features/projects/ProjectSwitcher.tsx
interface ProjectSwitcherProps {
  projects: Project[];
  currentProjectId: string;
}

export function ProjectSwitcher({ projects, currentProjectId }: ProjectSwitcherProps) {
  return (
    <select value={currentProjectId}>
      {projects.map(p => <option key={p.id} value={p.id}>{p.name}</option>)}
    </select>
  );
}

```

## Secondary Programming Language: SQL

The project uses raw SQL for database schema management through the **Drizzle ORM** migration system.

### Migration Files (`*.sql`)

Located in the `drizzle/` directory, these files define incremental database changes:

- **[[`drizzle/0031_furry_monster_badoon.sql`](https://github.com/every-app/open-seo/blob/main/drizzle/0031_furry_monster_badoon.sql)](https://github.com/every-app/open-seo/blob/main/drizzle/0031_furry_monster_badoon.sql)** – Example migration creating or modifying tables
- Earlier numbered files (`0001_` through `0030_`) represent the schema evolution history

```sql
-- Example migration pattern from drizzle/*.sql files
CREATE TABLE IF NOT EXISTS projects (
  id TEXT PRIMARY KEY,
  name TEXT NOT NULL,
  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

```

TypeScript application code typically references these tables through Drizzle's query builder rather than writing inline SQL, maintaining type safety across the stack.

## Configuration and Infrastructure Languages

While not primary programming languages, these file types appear throughout the repository for tooling and deployment:

| File Type | Purpose | Example Path |
|-----------|---------|--------------|
| **JSON** | Dependency management, TypeScript config, manifest files | [[`package.json`](https://github.com/every-app/open-seo/blob/main/package.json)](https://github.com/every-app/open-seo/blob/main/package.json), [`tsconfig.json`](https://github.com/every-app/open-seo/blob/main/tsconfig.json) |
| **YAML** | CI/CD pipelines, Docker Compose, Kubernetes configs | `.github/workflows/`, [`docker-compose.yml`](https://github.com/every-app/open-seo/blob/main/docker-compose.yml) |
| **Dockerfile** | Container image builds | [`Dockerfile.selfhost`](https://github.com/every-app/open-seo/blob/main/Dockerfile.selfhost) |

These configure the runtime environment but do not contain executable application logic.

## How the Languages Interact

The open‑seo architecture follows a pattern common in modern full-stack TypeScript applications:

1. **TypeScript server** handles HTTP requests, business logic, and external API integrations
2. **TypeScript client** (compiled from TSX) provides the browser-based dashboard interface
3. **SQL migrations** version-control the database schema separately from application code

This separation ensures that database changes are explicit, reviewable, and reversible through the numbered migration files in `drizzle/`.

## Summary

- **TypeScript (`.ts` / `.tsx`)** constitutes the overwhelming majority of source code, powering both server API logic and React front-end components
- **SQL (`.sql`)** manages database schema through Drizzle ORM migrations in the `drizzle/` directory
- **JSON, YAML, and Dockerfile** provide configuration and deployment infrastructure but are not primary development languages

The open‑seo project's language selection emphasizes type safety across the entire stack, from database queries to UI components.

## Frequently Asked Questions

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

The core application logic is TypeScript, including both server-side `.ts` files and React `.tsx` components. SQL appears in migration files for database versioning, and configuration uses JSON, YAML, and Dockerfile syntax. No other programming languages like Python, Go, or Rust appear in the primary codebase.

### Why does open‑seo use raw SQL instead of TypeScript for database migrations?

Raw SQL in numbered migration files provides explicit, transparent schema changes that can be reviewed in version control. The Drizzle ORM executes these migrations while the application code uses TypeScript-friendly query builders. This pattern separates schema evolution from runtime application logic.

### What JavaScript runtime does open‑seo use?

Based on the [`package.json`](https://github.com/every-app/open-seo/blob/main/package.json) configuration and server architecture, the project runs on **Node.js** with TypeScript compiled to JavaScript at build time. The [`Dockerfile.selfhost`](https://github.com/every-app/open-seo/blob/main/Dockerfile.selfhost) containerizes this Node.js runtime for deployment.