Learn with people.
Explore technology with other students, exchange what you discover and get help when something doesn't make sense.
loading…
DPRIME is a student-led technology community where we learn, experiment, build projects, share knowledge and grow together.
students → learners → developers → builders
You don't have to know everything before you join.
DPRIME brings students together around technology, curiosity and the willingness to keep learning. It's a space to ask questions, exchange ideas, work on things that interest you and meet people who are on a similar journey.
Explore technology with other students, exchange what you discover and get help when something doesn't make sense.
Take what interests you beyond theory. Work on projects, experiment with different technologies and learn by actually making things.
Meet students with different interests and strengths, share knowledge, collaborate and grow alongside people who want to build something too.
DPRIME grew through self-learning, consistency, presentations, projects and a lot of figuring things out along the way.
DPRIME began in January 2026 with Paul Ogutu as our group leader. We were students who wanted to learn technology, but there was no manual telling us exactly what to do. We decided to figure it out together.
We started with the fundamentals: HTML and CSS. Our first major milestone was building a portfolio. It was simple, but it was the first time we turned what we were learning into something of our own.
We learned how to use Git and GitHub, push our work, manage changes and collaborate on code. It wasn't always smooth. Sometimes even getting the right tools installed became a challenge.
We agreed on what we would learn during the week, studied independently, then met twice a week to share what we had discovered. We presented ideas, explained concepts to one another and helped each other through difficult parts.
We spent roughly three months learning Python. The goal wasn't simply to finish tutorials. We wanted to reach the point where we could actually use Python to build things.
We moved deeper into computer science and data. Data Structures and Algorithms, NumPy, Pandas and databases became part of our foundation and prepared us for backend development.
We learned APIs, routing, backend architecture, Pydantic validation, database integration and the other foundations needed to build backend systems. Then we started putting those concepts into real projects.
After spending time deep in backend development, we returned to the frontend. We revisited HTML and CSS, then moved into JavaScript and began connecting our knowledge into complete applications.
We moved into React and started building frontend projects such as Movie Explorer. From there we learned TypeScript, bringing us to the technologies we are using to build DPRIME today.
No shortcuts. No one handed us the answers.We kept learning until we could build.
Before the polished projects came the small moments that made everything else possible.
The moment coding stopped being something we heard about and became something we could actually do.
The first time several people had to turn separate pieces of work into one working product.
The moment something we built left our laptops and became accessible to the outside world.
Because nothing teaches developers quite like something suddenly breaking.
The point where building became more than an exercise. Someone else actually depended on what we made.
Realising that becoming good at technology isn't about knowing everything. It's about being willing to keep learning.
DPRIME isn't built around everyone knowing the same thing. Different members explore different areas, then bring what they learn back to the team.
Interfaces, interaction and experiences people actually use.
APIs, business logic and the systems behind the interface.
Learning how information is stored, connected and managed.
Understanding what happens between writing code and shipping it.
Exploring how intelligent systems can solve practical problems.
Learning to think beyond code and understand the people using it.
DPRIME is a student technology community where people learn by actually building. You don't have to know everything before you join. You just need curiosity, consistency and a willingness to contribute.
LEARN
COLLABORATE
BUILD
GROW
DPRIME is more than code and projects. We make time to step away from our screens, explore, have fun, and build the friendships that make the community what it is.
A day away from the screens. We explored Nyeri Hills, spent time together, and strengthened the friendships behind DPRIME.
A chance to relax, connect, laugh, and spend time together outside our usual learning sessions.
Regular sessions where we share what we have learned, present ideas, solve problems together, and help each other improve.
From learning sessions to walks, trips and community activities.
Our projects are where what we learn turns into something real. We experiment, make mistakes, solve problems and build together.
We don't want the website to only show finished work. This is what we're learning, building and shipping along the way.
Redesigning our online home to tell the story of the community behind the code.
A real project built by the team as we continue turning ideas into working software.
Improving our development workflow, collaboration, code quality and understanding of production systems.
We ask questions, experiment and stay willing to learn something we don't understand yet.
Progress comes from showing up repeatedly, especially when the code doesn't work.
We believe people learn faster when they share knowledge and solve problems together.
If we build it, we care about what happens after it leaves our laptops.

DPRIME is made up of students with different interests, strengths and experiences, learning from one another and building together.
DPRIME is still growing. If you're a student interested in technology, development, design or building things with other curious people, there's a place for you here.
As our skills grow, we take on projects that challenge us to apply what we've learned and create useful software.