From Idea to Pilot Customer: Building Lobocon

Lobocon started as a side project to sharpen my backend skills. I wanted to learn NestJS properly and understand how to build enterprise-grade applications. What I didn't expect was for it to turn into a real product with actual customers.

The Beginning: Just Learning

I picked construction management as the domain because I had some exposure to the industry through friends. The goal was simple: build something complex enough to learn NestJS, TypeORM, and PostgreSQL properly. No grand vision, no business plan, just code.

I spent evenings and weekends building out the core features: user authentication, project management, expense tracking. The architecture was probably over-engineered for what it was, but that was the point. I wanted to understand dependency injection, decorators, and how to structure a real application.

@Injectable()
export class ProjectService {
  constructor(
    @InjectRepository(Project)
    private projectRepository: Repository<Project>,
    private readonly cacheManager: Cache,
  ) {}

  async createProject(createProjectDto: CreateProjectDto): Promise<Project> {
    const project = this.projectRepository.create(createProjectDto);
    await this.projectRepository.save(project);
    await this.cacheManager.del('projects:list');
    return project;
  }
}

The Conversations That Changed Everything

A few months in, I was showing the project to a friend who works as a project manager at a construction company. He got excited. Really excited. He started asking questions about features I hadn't even thought about: "Can multiple people access this?" "Can we track materials separately from labor?" "What about photo documentation?"

That conversation led to more conversations with other PMs. I learned that construction companies in Kenya are still using WhatsApp groups, Excel sheets, and physical notebooks to manage projects. There was a real problem here, and I had accidentally built something that could solve it.

The Pivot

I had to make a decision: keep this as a learning project or turn it into a real product? The tech stack I had chosen (NestJS, PostgreSQL, TypeORM, Redis) was solid enough for production. The architecture could scale. The question was whether I wanted to commit to building a business.

After more conversations with PMs, I decided to go for it. But I had to change my approach. Instead of building features to learn, I needed to build features that solved real problems.

Rebuilding for Real Users

The first version was too complex. PMs didn't need all the features I had built. They needed: - Simple project creation and tracking - Bills of Quantities (BOQs) management - Expense tracking with receipts - Role-based access for different team members - Mobile-friendly interface

I stripped out the over-engineered parts and focused on these core features. I added proper error handling, implemented Redis caching for performance, and set up a CI/CD pipeline with GitHub Actions.

// Simple BOQ calculation
async calculateBOQ(projectId: number): Promise<BOQSummary> {
  const cacheKey = `boq:${projectId}`;
  const cached = await this.cacheManager.get(cacheKey);
  
  if (cached) return cached;
  
  const items = await this.boqRepository.find({ 
    where: { projectId } 
  });
  
  const summary = {
    totalCost: items.reduce((sum, item) => sum + item.cost, 0),
    itemCount: items.length,
    categories: this.groupByCategory(items)
  };
  
  await this.cacheManager.set(cacheKey, summary, 3600);
  return summary;
}

Getting the First Pilot

One of the PMs I had been talking to agreed to pilot Lobocon with his company. They had three active projects and about 20 team members. It was the perfect test case.

The first week was rough. There were bugs I hadn't caught in testing. The mobile experience wasn't as smooth as it needed to be. But the core value was there, and they stuck with it.

What I Learned

Building Lobocon taught me more than any tutorial or course ever could:

1. **Talk to users early and often.** The conversations with PMs shaped the entire product. Without them, I would have built the wrong thing.

2. **Over-engineering has its place.** The solid architecture I built while learning made it easier to pivot to a real product. The time spent learning NestJS properly paid off.

3. **Start with the problem, not the solution.** I got lucky that my learning project solved a real problem. But once I knew the problem, I had to rebuild with that in mind.

4. **Production is different from development.** Error handling, caching, monitoring, these things matter when real people depend on your software.

5. **The tech stack matters less than execution.** NestJS, PostgreSQL, TypeORM, Redis, these are all great tools. But what matters is solving the problem well.

Where We Are Now

Lobocon is live at lobocon.co. The pilot company is using it daily to manage their projects. We're tracking BOQs, expenses, and project progress in real-time. The feedback has been positive, and we're in discussions about expanding to more projects.

The journey from learning project to real product wasn't planned, but I'm glad it happened. There's still a lot of work to do: more features to build, more customers to find, more bugs to fix. But having real people use something you built is incredibly motivating.

If you're building something to learn, show it to people. You never know where the conversations might lead.