DEV Community: Bilal Shemsu

Building an education platform in Ethiopia - Addis Entrance Hub

Bilal Shemsu — Sat, 20 Jun 2026 00:06:57 +0000

Addis Entrance Hub (AEH)

Four years ago, I started thinking about building Addis Entrance Hub (AEH). At that time, I kept asking myself: why do so many students fail Grade 12 or get low scores in high school?

When I was in Grade 10, I discussed this with my friends. We tried to understand the problem and look for solutions. As we started analyzing patterns, we realized that students mainly needed resources such as exams, books, references, past papers, mock exams, and more.

However, when we looked deeper into our school, other students, and even some research and feedback, we discovered something more serious. The problem was not only a lack of resources, but also that the resources were scattered, unorganized, and there was no centralized platform.

So my friend and I came up with an idea: why don't we build Addis Entrance Hub?

From a Telegram Group to a Nationwide Platform

We started very simply by creating a Telegram group. We shared past exams and talked about our idea. Without any platform, app, or large promotion, the community grew from 0 to 800 students within six months, just by sharing among friends.

When we saw that students expected more, I decided to build the first version of AEH from scratch. The goal was to create a system where students could easily access, search, practice, read, watch, and get educational resources in one place.

Free for Every Ethiopian Student

At first, we planned to make it paid. But after talking to many students and observing different schools, we made a strong decision. We would make it completely free for everyone.

No subscription
No payment
No difference between government and private school students
No barriers

We wanted to build a nationwide platform where any student with a phone and internet access could use it easily.

To sustain the system, we planned other income sources:

Education-based e-commerce
Advertising from high traffic
Freelance work

Winning a Competition and Scaling Up

We released the first platform on a free server and reached around 1,000 students. Later, when we joined Grade 11, we participated in an innovation and technology competition and won. We used the prize money to pay for a better server and migrated AEH to a paid server.

From there, we continued building features step by step. After students took the national exam, they gave us real feedback. The system actually helped them.

Building Through Grade 12

When we reached Grade 12, things became more challenging. We had classes, exams, side projects, and personal development to manage. Still, we kept updating the platform and supporting students. During this time, we reached:

3,000 active users
Over 150,000 monthly traffic

We were doing all of this while preparing for our own national exams.

Expanding into Career Guidance and University Support

After the exams, we realized something important. Support should not stop there. Students still need help choosing their field, understanding what they are passionate about, what they are good at, and which university to join.

So we expanded AEH into a full guidance platform. We started providing:

Career guidance
University information
Decision support

Students showed even more interest.

Helping Students When the System Failed

When the national exam results came out, my friend and I checked ours. The results were not exactly what we expected, but they were not bad either. Instead of focusing on that, we shifted our attention to helping other students, especially those facing internet problems or system issues.

We successfully helped over 200 students access their results and solve their problems. Because of our guidance, many students were able to make decisions faster and with more confidence.

Then we waited for the university announcements.

I remember when I was preparing to take the ASTU entrance exam. At night, I motivated the students who were taking the exam alongside me, and that motivation also helped me become more confident.

After that, students again faced problems accessing their results because the official system failed. Through our community, we found solutions and helped them check their results.

Joining ASTU and Continuing to Build

Eventually, we joined Adama Science and Technology University (ASTU) and started our freshman courses. While there, I talked to many students, and their feedback motivated me even more to continue building and improving AEH.

During freshman year, I also tried to build an Ethiopian student-focused AI system using RAG, but I had to postpone it due to infrastructure limitations.

Growth and Impact

By this time, AEH had grown significantly:

Metric	Count
Active Users	5,900+
Monthly Traffic	200,000+
Telegram Channel Members	4,000+
Community Group Members	900+
Quiz Channel Members	311
Resource Channel Members	419
TikTok Views	200,000+

We had already integrated AI using prompt engineering during our Grade 12 period, so students did not need to leave the platform to ask questions.

Around the same time, we converted AEH into a Telegram Mini App.

I also explored building a mobile app using Android Studio while dealing with Grade 12 stress, even though I am mainly a PHP and Laravel developer. The first version was not perfect, but later my friend improved it significantly and made it much better.

One of the biggest improvements was solving the internet problem by making the app offline-first. This surprised the community and removed a major barrier for students.

Keeping It Alive

Throughout the journey, one of our biggest struggles was covering server costs. For two years, we managed through prize money, freelance work, and personal effort.

This year was more difficult, so we decided to ask for sponsorship and infrastructure support. After posting our request, within about one hour, someone reached out and covered our server expenses for the year.

Now AEH is stable again and continues to serve, guide, and support students. Open for sponsor.

This is what Addis Entrance Hub is.

🚀 Building a Production-Ready REST API in Go (Without Any Framework)

Bilal Shemsu — Tue, 16 Jun 2026 22:40:58 +0000

Most tutorials teach Go APIs using frameworks.

I wanted to understand what really happens under the hood.

So I built a fully working blog API using only Go’s standard library (net/http), SQLite, and a simple deployment pipeline.

No frameworks. No magic. Just clean fundamentals.

🧠 Why I Built This

As a developer coming from frameworks like Laravel, I kept asking:

What does a framework actually do for me?
Can I build a clean API without one?
How does Go handle HTTP and concurrency at a low level?

This project is my answer.

⚙️ Tech Stack

Go (net/http) — raw HTTP handling
SQLite (modernc.org/sqlite) — no external dependencies, pure Go
sqlx — cleaner database interactions
Nginx — reverse proxy
systemd — process management
GitHub Actions — CI/CD automation

📁 Project Structure

.
├── main.go
├── database/
│   └── db.go
├── models/
│   └── post.go
└── .github/
    └── workflows/

Key Idea:

Separate HTTP logic from database logic — even without a framework.

🌐 API Endpoints

Method	Endpoint	Description
GET	`/`	Welcome message
GET	`/posts`	List posts
POST	`/posts`	Create post
GET	`/posts/{id}`	Get one
PUT	`/posts/{id}`	Update
DELETE	`/posts/{id}`	Delete

🔥 What Makes This Interesting?

1. No Router Library

Routing is handled manually:

One handler per path
switch r.Method handles multiple HTTP verbs
URL params are extracted manually

This shows you what frameworks like Gin or Echo abstract away.

2. Manual JSON Handling

json.NewDecoder(r.Body).Decode(&post)
json.NewEncoder(w).Encode(post)

You control everything:

Input validation
Response format
Error handling

3. Clean Separation of Concerns

Even without a framework:

Handler → Model → Database

Handlers = HTTP logic
Models = SQL queries
Database = storage

4. SQLite Without CGO 🤯

Using:

modernc.org/sqlite

Means:

No C dependencies
Easier deployment
Works perfectly in CI/CD

5. Production-Style Deployment

This is where most tutorials stop — but this project goes further.

🔁 Deployment Flow

git push origin main
       ↓
GitHub Actions
       ↓
SSH into VPS
       ↓
git pull + build
       ↓
systemctl restart
       ↓
Live 🚀

⚡ What I Learned

🧩 1. Frameworks Hide Complexity

Things Laravel does automatically:

Routing
Request parsing
Validation
ORM abstraction

In Go, you do it yourself — and that’s how you really learn.

🧠 2. net/http Is More Powerful Than Expected

With just:

http.HandleFunc()
http.ListenAndServe()

You can build a complete API.

⚠️ 3. You Must Be Careful

No framework means:

You handle errors manually
You manage structure yourself
You enforce best practices

🚀 4. DevOps Matters More Than Code

The biggest upgrade in this project wasn’t CRUD.

It was:

systemd auto-restart
Nginx reverse proxy
CI/CD pipeline

That’s what makes it real-world ready.

📌 If I Improve This Further

Next steps I would take:

Add middleware (logging, auth)
Use a router (like chi or gin)
Add validation layer
Introduce environment configs
Add Docker support

💡 Final Thoughts

If you're learning Go:

👉 Don’t start with frameworks
👉 Start with net/http

Because once you understand this level…

You can use any framework with confidence.

👨‍💻 Source Code

(You can link your GitHub repo here)

🙌 Let’s Connect

If you're also learning Go or building APIs, I’d love to hear how you're approaching it.

⭐ If this helped you, consider sharing it!