Tech house · developer cohort · Kigali, Rwanda
Three days in a tech house. Walk out with a demo real app.
Friday to Sunday in a private mansion in Kigali — all meals provided, instructors in the room, zero distractions. Architect a real application, design clean user experiences, build a secure backend with an admin dashboard, and deploy with a professional workflow. Built the way developers build.
The method
Most workshops build screens. This one builds systems.
AI-assisted development means anyone can generate code. What separates a prototype from a product is everything around the code: architecture, security, admin operations, and deployment. That's what we teach — how to use AI without losing technical control.
Describe the app, accept whatever structure the AI invents, hope it holds together.
You map frontend, backend, database, and API communication before writing code — then build inside that structure.
A pretty frontend with nothing behind it. No accounts, no data, no operations.
Microservices in Docker containers — auth, payments, core API — plus a database, an admin dashboard, and an AI agent manager keeping it all running.
Everyone is an admin, every route is open, and the beginner mistakes ship to production.
User roles, protected routes, permission-based access, and secure API practices from the first session.
The project lives and dies on one laptop. No version control, no path to production.
Version control, environments, CI/CD, and a deployment pipeline — the workflow real teams use to ship.
The tech house
Not a classroom. A house full of builders.
For three days, a private mansion in Kigali runs like an early-stage startup — every room a workspace, every meal taken care of, every instructor within reach. You move in Friday morning with an idea and move out Sunday night with an app.
A private mansion
Whiteboards in the living room, build stations in every corner, fast internet, and gardens to think in — a house set up for one thing: shipping.
All meals provided
Breakfast, lunch, and dinner cooked on site, and coffee that never runs out. You never break your flow to go find food.
Builders on every side
A small cohort and instructors under one roof, Friday to Sunday. Ideas get pressure-tested over dinner, and debugging help is one couch away.
What you will build
Not just an app. A production architecture.
By Sunday night this system exists — your backend split into Docker-packaged microservices, with a dedicated payments service and an AI agent manager running operations from its own container. Built by you, understood by you.
Mobile app
The core screens and flows of your app — reusable components, real navigation, managed state.
Admin dashboard
An internal tool to manage users, data, and records — the part most builders never learn to make.
Microservices backend
Your backend split into focused services — auth, payments, core API — that scale and fail independently.
Docker containers
Every service packaged in its own container — isolated, reproducible, and ready to run on any host.
Payments microservice
A dedicated service for money — mobile money and card flows, isolated from the rest of your system.
Agent manager
An AI agent in its own microservice that helps run your app — health checks, restarts, and operational reports.
User authentication
Accounts, login, and session handling — with user access cleanly separated from admin access.
Database structure
Tables, relationships, and data models designed for your product — and planned for scale.
Security setup
Roles, protected routes, permission-based access, and secure API practices baked in.
API integration
Frontend and services talking properly — dynamic data, loading states, error handling.
Deployment workflow
Version control, environments, and a CI/CD pipeline that moves your containers toward production.
Docs & roadmap
A documented repository and a clear technical roadmap for everything you build after the house empties out.
The disciplines
Ten sessions, four ways of thinking.
Every session trains one of the four disciplines that separate developers from prompt-typers.
Think like a developer
Turn an idea into a structured product and a mapped architecture — before any code.
- Problem, user & core features
- MVP vs full product
- Frontend / backend / database
- Auth flow, roles & API design
Design the experience
Design flows and screens for usability, not just looks — for the app and the dashboard.
- User flows & navigation
- Screen hierarchy
- Mobile-first thinking
- Requirements → screens
Build the system
Frontend, backend, database, and admin dashboard — connected by real APIs.
- App foundation & components
- Microservices & data models
- Payments service & API wiring
- Admin dashboard & operations
Secure & ship
Protect the app, deploy it professionally, and leave with a plan to keep building.
- Roles & protected routes
- Docker, version control & CI/CD
- Agent manager for ai ops
- Launch checklist & roadmap
The program · Friday–Sunday
Ten sessions. Every one ends with something real.
Instructors in the house the whole time. You work on your app idea — not a toy project we picked for you.
From idea to real product
Define the problem, the user, and the core features. MVP vs full product, user journey, and a roadmap that avoids overbuilt ideas.
your app defined, first-version features chosenHow real apps are structured
Frontend vs backend vs database, API communication, auth flow, user roles — how professional teams plan applications.
your own app architecture, mappedDesigning the user experience
User flows, navigation, screen hierarchy, and mobile-first design thinking — for the app and the admin dashboard.
your app flow & dashboard structure, v1Building the mobile app foundation
Project structure, main screens, reusable components, connected navigation, managed state — ready for a backend.
first working version of your frontendBackend and database planning
Tables and relationships, data models, API endpoints, CRUD, validation — and how to split the backend into microservices, with payments as its own service.
your services & database structure, v1Connecting the app to the backend
API requests, forms wired to real data, dynamic content, loading and error states, and basic debugging.
an app that talks to its backendBuilding the admin dashboard
Admin login, managing users and app data, viewing submissions or orders, role-based access, operational workflows.
a working admin dashboard on your dataSecurity, authentication & permissions
User vs admin auth, account security, protected routes, permission-based access, and the beginner mistakes to avoid.
user and admin access properly separatedDeployment and DevOps basics
Version control, environment variables, CI/CD pipelines, Docker containers, hosting, production vs development — plus wiring up the agent manager that helps run it all.
your containers deployed or deploy-readyFinal build review & launch plan
Test, review the architecture, fix bugs, polish the UI, document the project, and build your launch checklist.
a working app, a roadmap, and next stepsFit check
Built for people who want to build the serious way.
No advanced programming background required — just comfort with a computer and the will to learn technical concepts.
The tech house is for you if you're…
- A startup founder or tech-curious entrepreneur who wants the app to actually exist.
- An aspiring developer or university student who learns best by shipping.
- A freelancer or product builder adding real app development to your toolkit.
- A designer who wants to understand what happens behind the screens.
- A developer who wants an AI-assisted workflow — with technical control intact.
It's not for you if…
- You want passive video lectures you can watch at 2× and forget.
- You're looking for a drag-and-drop template to reskin.
- You believe prompting alone replaces understanding your own product.
- You can't commit three full, focused days in Kigali.
Reserve your seat
Three days. One house. Your app.
Small cohorts are the whole point — every participant gets architecture reviews and hands-on help from instructors who build for a living. The mansion's address arrives with your confirmation.
- Three full days in a private mansion in Kigali — Friday to Sunday
- All meals provided: breakfast, lunch, and dinner, all three days
- You build your own app idea, with per-project architecture reviews
- All templates: product spec, architecture map, security checklist, launch checklist
- Post-cohort roadmap and community access to keep building
- Full refund until 7 days before your cohort — no questions
FAQ
The fine print, in plain type.
Do I need to know how to code?
No advanced programming background is required. You should be comfortable using a computer and willing to learn technical concepts. We use AI-assisted development throughout — the skill we teach is directing it with technical control: understanding the architecture, reviewing what gets built, and knowing why it works.
Will I really have a working app by Sunday night?
You'll leave with a working app foundation: a mobile frontend connected to a real backend and database, with authentication, an admin dashboard, and a security setup — deployed or fully prepared for deployment through a professional workflow. It's a real system to keep building on, not a finished business — and you'll leave with the technical roadmap for what comes next.
Where in Kigali does it take place?
In a private mansion in Kigali — the exact address and directions arrive with your registration confirmation. The house opens Friday morning, and all meals — breakfast, lunch, and dinner — are provided on all three days, so once you're in, you just build.
What do I need to bring?
A laptop and charger, and an app idea you care about (if you don't have one, we'll help you pick a strong practice project in Session 1). Food is taken care of. A pre-cohort checklist with account setup instructions arrives the week before, so Friday starts at full speed.
How is this different from other app workshops?
Most workshops stop at a quick prototype — screens with nothing behind them. Here you build the real structure behind professional applications: backend, database, authentication, an admin dashboard, security, and deployment. You won't just build screens; you'll learn to think through architecture and long-term scalability.
How do I pay?
MTN Mobile Money, Airtel Money, card, or bank transfer. Payment instructions arrive after you reserve. The launch-discount rate of 350,000 RWF applies while seats last; the standard rate is 500,000 RWF. The price is all-inclusive — venue, instruction, materials, and all meals.
What if I can't make Cohort 1?
Reserve at the current price and roll to Cohort 2 (August 14–16) at no charge, or take a full refund up to 7 days before your cohort starts.