# Introducing Project TechPaila

Five years ago, I was a kid in rural Nepal who was interested in computers and didn't own one.

There was a government school not far from me that taught computer science. It was free. I didn't know it existed until someone happened to mention it, and studying there is a big part of why I'm doing a computer science bachelor's now.

That "someone happened to mention it" part is the whole problem. I got lucky. Most students don't.

So I built TechPaila for the Zerops Challenge hackathon. It's a map of every government secondary school in Nepal that teaches a technical or vocational program.

%[https://youtu.be/S9zZ-BcKtRI] 

## The problem

Nepal's government funds technical streams in hundreds of secondary schools. Computer engineering, civil, electrical, plant science, animal science. They start from Grade 9, and they're free.

The information exists. It sits in a government program implementation booklet, in a table, in an annex, as a PDF. If you know the document number, you can find it. If you're a 14-year-old in a village who wants to learn to code, you will never find it, and neither will your parents or your teacher.

So the schools stay invisible to exactly the students they were funded for. That's the gap TechPaila fills.

## What it does

Open the app and you get a normal map, with Nepal highlighted. Click your province and it zooms in. Click your district and the schools appear.

There's a directory you can filter by program and by location, with school names in English and Nepali. The whole interface switches between the two languages with one tap.

And there's a recommendation flow, which is the part I care about most. You pick a program, share your location or choose a district, and it ranks the schools that teach it: the ones in your own district first, then the ones within about 30 km. Each result tells you why it's there.

There's also a fullscreen map mode, and results can drop a pin so you can see where a school actually sits.

Live app: https://nodejs-134-3000.sea1.zerops.app/

## The data

The dataset is 537 schools, transcribed from the government's own program implementation booklet (कार्यक्रम कार्यान्वयन पुस्तिका २०७९/८०, Annex 11), which lists the schools approved to run technical streams.

Here's what those 537 schools actually teach:

| Program | Schools |
| --- | --- |
| Plant science (बाली विज्ञान) | 204 |
| Civil engineering | 142 |
| Computer engineering | 109 |
| Animal science (पशु विज्ञान) | 46 |
| Electrical engineering | 35 |
| Agriculture (कृषि प्राविधिक) | 1 |

That distribution surprised me. I went in thinking about computer engineering because that's my own story, and it turns out plant science is by far the biggest category. Agriculture and animal science together account for 251 of the 537. For a country where most people still work in agriculture, that makes sense, and it changed how I think about who this tool is for. It isn't only for kids who want to code.

Every school record carries the district, the local level (municipality or rural municipality), the program, and a romanized English version of the Nepali name so the search works in either script. The `source` field on every record cites the booklet, so anyone can check where a row came from.

Two things about the data I want to be upfront about. It came from images of the booklet, so some Devanagari spellings will be slightly off. And the English names are transliterations, not official spellings, which means a school might appear as "Suryoday" where its signboard says "Suryodaya". Good enough to search. Not good enough to be authoritative yet.

## How it's built

Next.js 16 with the App Router, React 19, TypeScript, Tailwind 4, and Leaflet for the map.

```plaintext
Browser
  ├── MapExplorer (province / district / municipality state)
  │     ├── MapView (Leaflet + GeoJSON layers)
  │     ├── Controls (dropdowns)
  │     └── Schools (filtered list)
  └── Recommend (FAB widget)
        ├── program pick → geolocation / district fallback
        └── rank by district + ~30 km

Data
  ├── schools.json
  ├── place-names.json (EN/NE labels)
  ├── district / municipality centroids
  └── public/geo/*.geojson
```

A few decisions worth explaining.

The map isn't a hand-drawn SVG. I use Leaflet with OpenStreetMap tiles, so the surrounding countries render as an ordinary map and only Nepal is highlighted and clickable. Leaflet draws the GeoJSON boundaries as SVG paths anyway, so I get the interactive SVG behaviour without writing projection or pan-zoom code myself.

Leaflet needs `window`, which doesn't exist during server rendering, so the map component is loaded client-only:

```typescript
const MapView = dynamic(() => import('./MapView'), { ssr: false });
```

That one line is the only real Next.js-specific piece in the whole map feature.

There's no database. The school list and the boundaries are read-only, so they're served as static files and filtered in the browser. That was deliberate. It keeps the thing fast, keeps hosting costs near zero, and leaves almost nothing to secure. It also means whoever inherits this later doesn't inherit a database to maintain.

Distance ranking uses municipality centroids when a school's municipality matches the GeoJSON, and falls back to the district centroid when it doesn't. It's approximate. Real coordinates are on the list below.

## Running it on Zerops

The build and deploy config is short:

```yaml
zerops:
  - setup: app
    build:
      base: nodejs@22
      buildCommands:
        - npm install
        - npm run build
      deployFiles: ./
    run:
      base: nodejs@22
      ports:
        - port: 3000
          httpSupport: true
      start: npm start
```

I built the whole project inside ZCP, against the live Node.js service, editing on the service filesystem and running builds over SSH. Brand assets are served from Zerops Object Storage.

Two honest notes from that experience. The browser IDE got slow enough that I moved back to a local editor for a stretch, and I'd love to attach the Zerops environment to local VS Code the way Codespaces does. I also hit random disconnects while researching in another tab. The session came back and restarted the dev server, which was good, but I had to re-authenticate for git push afterwards, which wasn't.

## What's next

Right now the app can tell a student which schools exist near them. It can't yet tell them how to reach one.

So the next pieces are exact coordinates for each school, with real pins rather than municipality centroids, and contact details so a family can call before travelling.

After that, the data. What I have is transcribed from one booklet from one year. The full, current, correct list lives with the Ministry of Education, and the right move is to get it from them directly.

And then the actual goal. The Ministry doesn't publish anything like this today, as far as I can find. I'd like to build it properly and hand it over, so it becomes a public tool that outlives a hackathon project. That's also why there's no database and no complicated infrastructure. Something simple is something someone else can actually take on.

## Links

*   Live app: [https://nodejs-134-3000.sea1.zerops.app/](https://nodejs-134-3000.sea1.zerops.app/)
    
*   Demo video: [https://youtu.be/S9zZ-BcKtRI](https://youtu.be/S9zZ-BcKtRI)
    
*   Source code: [https://github.com/aashishpanthi/techpa](https://github.com/aashishpanthi/techpaila)ila
    

The name is two words. Tech and *paila*, which is Nepali for step. A first step into technical education. That's all this is meant to be, for the next kid who's curious about computers and doesn't know the school down the road is waiting for them.