Overview
Workpunkt is a production SaaS platform managing complex workflows for students, agents, counsellors, and administrators across the international education and placement industry.
My role on this project was Project Lead and Engineering Manager. I owned the technical direction, coordinated the development team, drove sprint planning and delivery, and also contributed directly to the codebase throughout the product's lifecycle.
The repository crossed 2,000+ commits — a reflection of the sustained, team-wide effort involved in shipping and iterating on a real production system.
My Role: Lead, Not Just Engineer
This was not a solo build. I led a team of developers, which meant my responsibilities spanned both management and hands-on engineering:
- Architecture decisions — defining the data model, API contracts, authorization model, and service boundaries for the team to build against
- Sprint planning and delivery — scoping work, assigning tasks, tracking progress, and managing delivery timelines
- Code reviews — reviewing pull requests, maintaining code quality standards, and ensuring consistency across the codebase
- Unblocking the team — jumping into the codebase directly when a feature was blocked, a design decision was unclear, or a deadline was at risk
- Stakeholder communication — translating business requirements into technical scope and keeping non-technical stakeholders informed on progress
Balancing people management with hands-on contribution is a different kind of engineering problem. You have to know when to lead and when to ship.
Technical Scope
The system managed a complex domain with meaningful relationships between:
- Students and their applications
- Agents and the students they manage
- Counsellors and their assigned casework
- Documents, verification states, and deadlines
- Institutions and application pipelines
This was not a simple CRUD application. Every role had different views, permissions, and available actions — and those rules had to be enforced at the backend, not just the UI.
Architecture Decisions
As lead, I defined the foundational technical decisions the team built on top of:
PostgreSQL + Prisma — a relational model was the right fit given the consistency requirements between entities. Prisma gave the team a type-safe, self-documenting interface to the database.
Role-Based Access Control — authorization was treated as a backend concern from day one. User roles govern what operations the backend permits, not just what the frontend shows.
Workflow State Machines — application management is not simple CRUD. Applications move through defined states:
Created → Documents Submitted → Verified → Under Review → Processed
The team designed the backend to validate state transitions explicitly, so invalid operations were rejected at the server level.
API-first design — the frontend consumes a clearly defined API contract. This gave team members working on different parts of the stack the ability to work in parallel without blocking each other.
Hands-On Engineering Contributions
While managing the team, I also contributed directly to the codebase:
- Implemented core authorization middleware and role-permission mappings
- Contributed to the Prisma schema design and migration strategy
- Built several API route handlers and data access layers
- Reviewed and refactored frontend components for consistency
- Debugged production issues and worked on performance bottlenecks
- Helped implement the document upload and verification workflow
Staying in the codebase while leading the team kept me grounded in the actual engineering problems the team was facing, and made my technical guidance relevant rather than abstract.
What 2000+ Commits Means
A 2000+ commit repository is not just a vanity metric. It represents:
- Continuous iteration across multiple team members
- Regular code reviews and merge cycles
- Bug fixes, feature additions, and refactors over time
- A living codebase that evolved as the product matured
- A team that was consistently shipping and improving
Maintaining quality, consistency, and direction across that volume of work is the core challenge of engineering leadership.
Production Engineering
Docker-based deployment gave the team a consistent environment from development through production. The application was also designed with long-term maintainability in mind:
- Typed APIs and typed database access
- Clear separation of concerns across layers
- Centralized authorization
- Reusable frontend components
- Modular backend logic
Takeaway
Workpunkt was my first significant experience operating at the intersection of technical ownership and team leadership.
Architecting a system is one thing. Architecting a system while coordinating a team, managing delivery, maintaining code quality, and staying hands-on in the codebase is a different challenge entirely.
It reinforced something I believe strongly: the best engineering leaders stay close to the code. Not to micromanage, but to earn trust, spot problems early, and make better decisions.