Author: Hubtel

Engineering is a craft. Writing code isn’t just about functionality—it’s about creating something maintainable, efficient, and scalable. Yet, for years, software teams have struggled with an age-old dilemma: 

How do we measure the quality of our code? 

Some say, “You know clean code when you see it.” Others rely on instinct. But here’s the problem: gut feelings don’t scale. Codebases grow, engineers come and go, and what seemed like “good code” one day can become a cautionary tale the next. 

At Hubtel’s Code Quality Team, we decided to tackle this head-on. We needed something more than intuition—something measurable, actionable, and scalable. And so, we built the Code Confidence Index (CCI)—not just to measure code quality, but to improve it. 

READ ALSO: From Snail Mail to Warp Speed: How Hubtel Rocketed Its Product Delivery 

Why Code Quality Matters (And Why We’re Tired of Fighting Bad Code) 

Let’s not pretend: bad code is a productivity sinkhole. 

• It slows down development cycles. 

• It makes debugging feel like archaeology. 

• It increases technical debt faster than a high-interest loan. 

On the other hand, high-quality code accelerates everything. Developers ship features faster, fixes are easier, and scaling is a joy rather than a death march. 

But there’s a catch: quality must be measurable. If we can’t quantify it, we can’t improve it. That’s where CCI steps in. 

Introducing the Code Confidence Index (CCI): The Metric That Changed Everything 

Imagine trying to lose weight without a scale. You might feel healthier, but without numbers, how do you know you’re making progress? 

That was our approach to code quality—until we built CCI. 

CCI is a single, actionable score that evaluates the overall health of a codebase. Instead of vague statements like “This module feels messy,” we get hard data: 

Test Coverage: Are we testing enough of our code? 

Bugs & Vulnerabilities: How many issues are creeping into production? 

Code Complexity & Smells: How maintainable is our architecture? 

Duplications & Framework Hygiene: Are we following best practices? 

CCI doesn’t just diagnose issues—it guides improvement. A repository with a score of 58/100? It tells us exactly where to focus. A score of 80/100? It confirms our hard work is paying off. 

And it’s not just theoretical. We tested it, and the results were game-changing. 

Case Study: The Repository That Went From 58 to 80 

To see if CCI really worked, we applied it to a backend repository with a score of 58/100. 

The Diagnosis: A Codebase in Trouble 

Breaking down the numbers, we saw the problems clearly: 

• Test Coverage: 25% (far too low) 

• Bugs: 12 major issues 

• Security Vulnerabilities: 8 flagged risks 

• Code Smells: 250 problematic patterns 

• Cognitive Complexity: 2500 (dense, difficult-to-read code) 

• Duplicated Lines Density: 12% 

This wasn’t just an abstract number—this was friction in every commit, every merge, every deployment. 

The Plan: Smart, Targeted Fixes 

Rather than an endless refactor, we took a strategic three-phase approach: 

Phase 1: Boosting Test Coverage (2 Weeks) 

• Added unit tests for core logic 

• Implemented integration tests for key workflows 

• Increased coverage from 25% to 50% 

Phase 2: Fixing Bugs & Security Issues (1 Week) 

• Addressed 7 critical bugs 

• Fixed 5 high-priority security vulnerabilities 

• Reduced bug count from 12 to 5, vulnerabilities from 8 to 3 

Phase 3: Cleaning Up the Code (2 Weeks) 

• Refactored complex methods 

• Removed redundant, duplicated code 

• Reduced code smells from 250 to 100 

The Outcome: A Healthier, More Maintainable Codebase 

After just a few weeks, we saw dramatic improvements: 

• Test Coverage: 50% (+100% increase) 

• Bugs: Reduced from 12 to 5 

• Vulnerabilities: Down from 8 to 3 

• Code Smells: Dropped from 250 to 100 

• Cognitive Complexity: Reduced by 60% 

• Duplicated Lines Density: Cut in half 

Final CCI score: 80.3—a 38% increase. 

Beyond the numbers, the real impact was felt in daily development. PRs merged faster, debugging was smoother, and the once-dreaded repo became far easier to work with. 
 
Sustained Improvement Without Development Disruptions 

One of the greatest advantages of integrating CCI into our workflow is that it allows us to improve code quality without derailing development cycles. Traditionally, code quality initiatives often mean halting sprints for refactoring, leading to delays and frustrated teams. With CCI, quality improvement becomes a continuous process, not a roadblock. Engineers make incremental enhancements alongside feature development, ensuring that we build, ship, and refine without grinding productivity to a halt. 

How CCI is Reshaping Our Engineering Culture 

This wasn’t just about fixing one repository. CCI is changing the way we think about code quality. 

1. Code Quality Sessions That Matter 

We turned code reviews into structured quality sessions, where senior engineers review repositories, provide insights, and mentor teammates. Instead of nitpicking syntax, we now discuss real structural improvements. 

2. Data-Driven, Not Opinion-Driven Engineering 

Discussions about code quality are no longer subjective debates. Instead of “This feels off,” we now say: 

• “Our test coverage needs to improve by 15%.” 

• “We have too much cognitive complexity in this module—let’s refactor.” 

3. A Culture of Continuous Improvement 

Rather than vague aspirations to “write cleaner code,” teams now have clear targets. Engineers actively track their CCI scores, making quality improvement a habit, not an afterthought. 

READ ALSO: Scaling an Engineering Team from 16 to Over 100 in Less Than 4 Years: Hubtel’s Journey, A Tale of Growth, Innovation, and a Whole Lot of Coffee 

Beyond the Score: What This Means for Software Engineering 

CCI is more than a metric. It’s a philosophy. 

• It shifts quality from subjectivity to objectivity. 

• It turns code maintenance from a chore to a structured process. 

• It creates a feedback loop where engineers can see their progress. 

Software engineering isn’t just about building features. It’s about building sustainable systems that stand the test of time. And for that, code quality can’t be left to gut feelings. It needs to be measured, tracked, and continuously improved. 

Final Thoughts: Measuring What Matters 

For years, developers have debated what makes good code. With CCI, we no longer need to guess. We have the numbers, we have the process, and we have the results. 

So the next time someone says, “You know clean code when you see it,” ask them this: 

“Do you have the data to prove it?” 

Because at Hubtel, we do. 

Remember when dial-up was the only way to connect to the internet? Slow, painful, and enough to make you throw your computer out the window? That’s what our software builds felt like at Hubtel for a while.

Our codebase was exploding like a teenager’s growth spurt, and our build pipelines, which used to be pretty snappy, were suddenly resembling rush hour traffic on a Friday night.

Instead of popping champagne for new features, we were tapping our fingers impatiently, waiting for builds to crawl across the finish line. Talk about buzzkill. 

Our once-smooth process had become a tangled mess of resource crunches, technical hiccups, and enough waiting time to make a sloth look speedy.

Imagine this: every time we tweaked something, even a tiny thing, we were rebuilding the entire digital city, even if we’d only moved a single lamppost. Clearly, something had to be done. 

READ ALSO: Beyond Instinct: How the Code Confidence Index (CCI) is Transforming Code Quality at Hubtel 

The Roadblocks: Where We Hit Snags 

Resource Constraints & Costs: Think of scaling build pipelines like hosting a massive potluck. You want enough food for everyone, but you don’t want to end up with mountains of leftovers and a hefty grocery bill. We needed a smarter way to feed our builds without breaking the bank. 

Queue Times & Delayed Builds: Picture a Black Friday sale, but for code updates. With multiple teams pushing changes constantly, our build queues became a bottleneck of epic proportions. Developers were left twiddling their thumbs, releases were getting pushed back, and frustration levels were reaching boiling point. 

Mono-Repository Woes: Mono-repos are like giant filing cabinets – great for keeping everything organized, but a pain to search through. Unlike smaller, more focused repositories, our massive mono-repo meant we had to analyze everything, even for minor changes. It was like searching for a single grain of sand on a beach. 

Technical Hurdles: Beyond just throwing money at the problem (which, let’s face it, we didn’t have an endless supply of), we faced some serious technical challenges. Optimizing selective builds and automating dependency tracking required a serious overhaul of our build scripts. 

Our Game Plan: How We Turned It Around 

Instead of just adding more servers (because who has a money tree growing in their backyard?), we decided to get clever. We focused on automation, intelligent build detection, and resource optimization to transform our pipelines into high-speed bullet trains. 

1. Smart Build Detection: We built a system that could pinpoint exactly which parts of our code were affected by any changes. Think of it as a Sherlock Holmes code. This involved creating a kind of map of our codebase, understanding the relationships between different parts of the system.

Then, when a change was made, our system could trace its impact, identifying only the areas that needed to be rebuilt. This meant we only had to rebuild what was absolutely necessary. No more rebuilding the whole city for a single lamppost!

2. Selective Project Builds & Publishing: Our pipeline now intelligently detects changes and only builds and publishes the relevant projects.

This drastically reduces build times and eliminates wasted effort. We essentially taught our system to be a discerning chef, only preparing the dishes that were actually needed. This involves a few key steps: 

a. Change Detection: Our system analyzes the code changes and identifies the specific files that have been modified. 

b. Project Mapping: It then uses a map of our project dependencies to determine which projects are affected by those changes. Think of it like a spider web, where each project is a node, and the connections represent dependencies. When one node is touched (a file is changed), the system can trace the ripples to see which other nodes (projects) are also affected. 

c. Dependency Tracking: It goes a step further, understanding which projects depend on the affected projects. This ensures that even if a project itself hasn’t changed, if a project it relies on has, it will still be included in the build. 

d. Selective Building: Finally, it uses this information to build only the necessary projects and their dependencies, skipping everything else. 

e. Commit Message Influence (Targeted Builds): But we took it a step further! Developers can now directly influence the build pipeline using their commit messages. This is incredibly useful when a developer knows exactly which projects need to be built and wants to bypass the automatic dependency detection.

For example, if a developer makes a small, isolated change and wants to quickly deploy just that one piece, they can add a special tag or keyword to their commit message to specify the exact projects to build.

This gives developers fine-grained control and further optimizes the build process, allowing them to focus on precisely what needs to be released, instead of relying solely on the system’s automated dependency analysis.

This “targeted build” feature is like giving developers a “fast pass” for their builds, allowing them to jump the line when they know exactly what they need.

Build Pipeline comparison 

3. Automated Code Quality Checks: Every new pull request now gets a thorough code quality check-up, ensuring we maintain high standards without slowing things down. 

4. Automated Containerization: Say goodbye to manual Dockerfile management! Our pipeline now automatically containerizes our applications, making deployments smoother than a hot knife through butter. This involved automating the entire containerization process: 

a. Dockerfile Generation: Our system automatically generates Dockerfiles for each project, based on its dependencies and configuration. It’s like having a master chef who knows exactly what ingredients and instructions are needed for each dish. These Dockerfiles define the environment in which our applications will run. 

b. Dependency Management: The generated Dockerfiles include instructions for installing the necessary dependencies, ensuring that each container has everything it needs to run. 

c. Image Building: Our pipeline then automatically builds Docker images from these Dockerfiles. These images are like packaged versions of our applications, ready to be deployed. 

d. Registry Publishing: Finally, these images are automatically pushed to container registries (like Amazon ECR or GitHub Container Registry), making them readily available for deployment.

Automated Containerization Process

5. Dynamic Resource Allocation: We built a system that automatically scales our computing power up during peak build times and scales it back down when things are quieter.

This ensures we have the resources we need without wasting money. It’s like having a thermostat for our builds, keeping the temperature just right. 

The Payoff: Faster, Smoother, and More Scalable Builds 

The results? Let’s just say they were pretty impressive. Build times plummeted, queue times were slashed, and we significantly optimized our resource usage, saving a considerable chunk of change.

Developers went from dreading build times to getting feedback almost instantly. It was like going from snail mail to warp speed! 

READ ALSO: Scaling an Engineering Team from 16 to Over 100 in Less Than 4 Years: Hubtel’s Journey, A Tale of Growth, Innovation, and a Whole Lot of Coffee 

Lessons Learned: Smarter, Not Harder 

Our journey taught us a valuable lesson: optimizing build pipelines isn’t about throwing money at the problem; it’s about being smart, innovative, and always striving to improve. Through automation, selective builds, and dynamic resource management, we’ve built a system that’s not just good – it’s awesome. 

At Hubtel, we’re not resting on our laurels. We’re constantly looking for new ways to make our builds even faster and more efficient. Think of us as software chefs, always experimenting with new ingredients and techniques to create the ultimate recipe for speed and efficiency. 

So, if your builds are feeling a bit sluggish, take a page from our book. With the right strategies, even the most complex build systems can be transformed into lean, mean, speed machines that fuel innovation and seamless product delivery. 

In our mission to drive Africa forward by enabling everyone to find and pay for everyday essentials, gaining deep insights into our platform’s operations is crucial. As the platform continues to grow, encompassing various product lines and accommodating an increasing customer base, understanding its underpinnings becomes essential.  

In the process of gaining understanding in real-time, some key questions that various interested parties are looking for answers, include: 

• What is the resource consumption of the platform? 

• Which application should we optimize? 

• Which transactions are failing and what is causing it? 

• How are applications performing individually and as a platform? 

• How many transactions are processed successfully in any give elapse of time? 

• Which feature set is under-utilized and why? 

• Which application pages are slow and why? 

• What are the customer experiences across the platform? 

To answer these questions and more, a robust software observability strategy is required.  

READ ALSO: From Snail Mail to Warp Speed: How Hubtel Rocketed Its Product Delivery 

What is Observability?  

Observability is the process of understanding what’s happening inside a system based on its external outputs. It refers to the ability to infer the internal states of a system from the data it produces.

This capability is crucial for gaining insights into complex, distributed systems, often uncovering unknown issues or behaviours on our platform. Observability emphasizes a holistic understanding of the system’s behaviour. 

Highlights of Observability 

The benefits of adopting this approach include: 

• Operational Excellence: Our systems are not only operational but also measurable, debuggable, and performant. 

• Empowered Engineering: As engineers, we are empowered to diagnose, predict, and resolve issues on our platform quickly and effectively, ensuring an always-available platform for our customers. 

• Informed Decision-Making: We are well-equipped to support our product managers and research analysts in understanding user behavior on our platform, providing key insights to improve our product experiences. 

With observability, we shift from being reactive to proactive. This approach allows us to detect and resolve issues before they affect users, identify opportunities to optimize performance, and gather insights to enhance overall reliability.

Observability is essential for supporting continuous improvement in our software lifecycle, enabling data-driven decisions and fostering accountability. 

Types of Telemetry Signals 

Telemetry signals can be categorized into: 

Gen Alpha of Our Observability Journey 

The problem of instituting a robust observability solution, just like with every problem here at Hubtel, has gone through a series of solution iterations and refinements in a bid to identify the solution which adequately meets our aims. 

Our current observability solution can be broken into several parts which address different needs of our business, namely: 

1. User Events Analytics: This component focuses on capturing and analysing user interactions with our platform. By understanding user behaviour, we can enhance user experience, identify popular features, and detect any issues that users may encounter. Tracking user navigation paths to identify common drop-off points in the user journey. We leverage tools like Google Analytics, Mixpanel, Microsoft Clarity and other in house developed tools to capture and analyse user events, providing insights into user behaviour and engagement. 

2. Transaction Monitoring: Ensuring the reliability and performance of financial transactions is critical. This part of our observability solution monitors transaction success rates, failure rates, and processing times to ensure smooth and secure payment experiences. Monitoring the success rate of payment transactions to quickly identify and resolve any issues that may arise. We use tools such as StatsD and Grafana to monitor transaction metrics and visualize performance data, enabling us to quickly detect and address transaction issues. 

3. Infrastructure Monitoring: Our platform’s infrastructure must be robust and scalable to handle increasing loads. This component monitors the health and performance of our servers, databases, and network to ensure they are operating efficiently. Keeping track of server CPU and memory usage to prevent resource exhaustion and maintain optimal performance. Tools like Nagios and New Relic help us monitor infrastructure health, providing alerts and dashboards to keep track of resource usage and system performance. 

4. Application Monitoring: This part focuses on the performance and health of our applications. By monitoring application metrics, logs, and traces, we can quickly identify and resolve issues, ensuring our applications run smoothly and efficiently. Using traces to identify slow-performing API endpoints and optimizing them for better performance. We utilize Application Insights and New Relic for tracing Graylogs and ELK Stack (Elasticsearch, Logstash, Kibana) for log aggregation and analysis, to gain deep insights into application performance. 

By integrating these components into our observability strategy, we have gain comprehensive insights into our platform’s operations, proactively address issues, and continuously improve our services for our customers. 

However, this approach has come with its own challenges, such as: 

• Low Correlation of Events: Using different monitoring systems often makes it difficult to correlate related events across systems. This relies heavily on skilled personnel to draw such relations, and when they fail, it results in undesired system outcomes. 

• Duplicated Events: The decentralized nature of our observability solution leads to a single event being recorded in multiple monitoring systems, resulting in redundancy and increased costs for managing and storing these events. 

• Vendor Lock-In: Some monitoring tools require tight coupling with our services, limiting our flexibility and increasing costs. Switching providers or integrating new tools becomes challenging. 

• Low Reliability: Managing multiple solutions means handling various instances that hold key transaction information, which can hinder timely issue resolution. 

• Extra Development Activities: Setting up and maintaining monitoring systems requires additional effort, delaying deployments and increasing the workload for engineering teams. 

• Unregulated Costs: The costs associated with observability systems can be unpredictable and escalate quickly, impacting budget planning and resource allocation, especially when using different independent tools. 

Addressing these challenges is crucial for refining our observability strategy and ensuring it effectively supports our platform’s growth and reliability. 

Gen Omega of Our Observability Journey 

An effective observability strategy encompasses qualities such as simple tooling, cost-effective storage, and proactive alert and monitoring systems.  

So, in the next generation of our journey, we have adopted the use of OpenTelemetry. 

OpenTelemetry is an open-source observability framework designed to provide a standardized way to collect, process, and export telemetry data such as metrics, logs, and traces.

It is a collaborative project under the Cloud Native Computing Foundation (CNCF) and has quickly become the industry standard for observability due to its flexibility, interoperability, and comprehensive feature set. 

It contains: 

1. APIs and SDKs: OpenTelemetry provides language-specific APIs and SDKs that developers can use to instrument their applications. These tools enable the collection of telemetry data without being tied to a specific vendor or backend. 

2. Instrumentation Libraries: These libraries automatically capture telemetry data from popular frameworks and libraries, reducing the need for manual instrumentation. 

3. Collectors: OpenTelemetry Collectors are agents that receive, process, and export telemetry data. They can be deployed as standalone agents or as part of a larger observability pipeline. 

4. Exporters: Exporters are plugins that send telemetry data to various backends, such as Prometheus, Jaeger, Zipkin, and commercial observability platforms. This flexibility allows organizations to choose the best tools for their needs without being locked into a single vendor. 

5. Semantic Conventions: OpenTelemetry defines a set of semantic conventions to standardize the naming and structure of telemetry data. This ensures consistency and makes it easier to analyse data across different systems and tools. 

The benefits we derive from using this approach include: 

• Vendor-Neutral: OpenTelemetry’s vendor-neutral approach allows organizations to avoid vendor lock-in and switch between observability platforms with minimal effort. 

• Comprehensive Coverage: By supporting metrics, logs, and traces, OpenTelemetry provides a holistic view of system performance and behaviour. 

• Community-Driven: As an open-source project, OpenTelemetry benefits from contributions and innovations from a large and active community. 

• Ease of Use: With automatic instrumentation and a unified API, OpenTelemetry simplifies the process of collecting and analysing telemetry data. 

• Scalability: OpenTelemetry is designed to handle the demands of modern, distributed systems, making it suitable for organizations of all sizes. 

By integrating OpenTelemetry with observability backends like Honeycomb, New Relic, DataDog, or Grafana, we can establish a comprehensive observability strategy.

This integration ensures complete oversight of our platform, covering transaction monitoring, infrastructure health, application performance, and user events. 

Adopting OpenTelemetry allows us to gain deep insights into our platform, enhance reliability, and improve the overall user experience. 

Frontend observability is another aspect of our strategy essential for understanding user interactions and ensuring smooth, responsive, and error-free experiences on our platform.

By focusing on real user behavior and browser-side performance, it bridges the gap between backend operations and user experiences.

Key components include Core Web Vitals, Real User Monitoring (RUM), Session Replay, Synthetic Monitoring, Error Monitoring, and User Perception Metrics. These tools help measure performance, detect errors, and optimize workflows, ensuring our platform remains reliable and user-friendly.

Through proactive monitoring and analysis, we can swiftly address issues and enhance user satisfaction, aligning with our mission to drive Africa forward. 

READ ALSO: Beyond Instinct: How the Code Confidence Index (CCI) is Transforming Code Quality at Hubtel 

Conclusion 

Hubtel’s journey towards a robust observability strategy has been marked by continuous improvement and adaptation.

By leveraging OpenTelemetry, we aim to overcome the challenges of our previous approaches and build a more cohesive, scalable, and cost-efficient observability framework.

This transition not only enhances our ability to monitor and optimize our platform but also empowers our engineering teams to deliver superior user experiences.

As we continue to evolve, our commitment to observability will remain a cornerstone of our mission to drive Africa forward, ensuring that we can proactively address issues, make informed decisions, and maintain the highest standards of operational excellence. 

Lorem ipsum dolor sit amet, consectetur adipiscing elit. Ut ultricies rutrum lorem. Aenean tempus arcu a ipsum condimentum cursus. Quisque finibus dapibus est nec tristique. Phasellus vel lectus turpis. Quisque eget mauris in metus sodales hendrerit. Morbi feugiat rutrum pharetra. Mauris tortor nunc, porttitor vel egestas fermentum, pharetra ac velit. Aliquam dignissim finibus ipsum, at fringilla turpis condimentum quis. Nam orci mauris, condimentum sed lacus ac, dictum porttitor nisi. Nulla facilisi. Phasellus a iaculis mauris, at commodo tortor. Donec facilisis sapien sapien, a vehicula purus sodales vitae. Integer in mattis nisl. Phasellus a mauris quis metus tempus vehicula.

Donec cursus vel dolor eget consequat. Nam scelerisque nulla sed felis efficitur lacinia. Pellentesque vestibulum placerat lectus in euismod. Donec rutrum dignissim sem, ut molestie arcu mattis non. In vel porta nulla, ac dapibus est. Praesent elementum tincidunt ornare. Aliquam egestas risus magna, eget dapibus sem tempus iaculis. Proin vel enim a velit posuere semper et porttitor neque. Nulla pulvinar purus eu mattis vehicula. Suspendisse mattis, urna in interdum tincidunt, lacus tellus luctus neque, sed placerat sapien tortor sed ex. Proin vitae felis auctor, fermentum felis ac, euismod erat.

Curabitur rutrum pharetra risus at viverra. Integer pellentesque odio sapien, vel imperdiet tellus sodales ut. Nullam sit amet ligula nec leo aliquet sollicitudin sed quis tellus. Cras vestibulum justo id sodales condimentum. Praesent posuere odio sollicitudin, luctus leo vel, vulputate urna. Vestibulum nec finibus orci. Vivamus ultrices sapien vel tristique malesuada. Ut erat risus, pretium et elit id, pharetra pellentesque lectus. Nulla eget cursus purus, quis consectetur odio. Pellentesque lobortis nunc id sem ornare, non posuere dolor euismod. Sed finibus, lacus lacinia dapibus facilisis, risus massa convallis augue, vitae commodo leo nibh at nulla. Etiam laoreet porta efficitur. Etiam egestas rhoncus tempor. Orci varius natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. Vivamus maximus, purus posuere porta euismod, leo massa ullamcorper arcu, id blandit dui neque eu eros. Suspendisse eget ipsum ut lectus dapibus porttitor.

In the last quarter of 2024, the Hubtel AI lab collaborated with Hubtel’s management team to develop “HubtelWay,” a bespoke artificial intelligence platform designed to deliver up-to-date information. HubtelWay is shorthand for Hubtel’s unique organizational culture, policies, and leadership practices. 

This system is a chatbot aimed at assisting over 700 Hubtel employees. It answers specific questions and addresses their concerns without the need for any human involvement.

The use of in-house chatbots within organizations is steadily gaining popularity. For example, Deloitte recently announced the deployment of an AI chatbot to support employees in audit and assurance tasks. JP Morgan and Morgan Stanley have developed chatbots to assist with research analysis and high-end customer financial advice.

These advancements reflect a shift in the conversation around artificial intelligence—from building products for external consumers to finding high-value utility within the company for employees.

Esther Crawford, Director of Product at Meta, recently shared this on Threads to celebrate the launch of Metamate, an internal AI chatbot for Meta’s employees: “You’ve never used Metamate if you don’t work at Meta. It’s an AI for employees that’s trained on an enormous corpus of internal company docs. I use it all the time for efficiency gains. Any sizable company operating without an internal AI tool is already behind the curve.”

At Hubtel, we agree! Building custom chatbots for internal knowledge sharing not only supports transparency around policies and regulations but is also a smart way to cut down on Human Resource management costs. Especially for fast-growing companies like Hubtel, having a scalable system that can support an expanding team is crucial.

READ ALSO: Scaling an Engineering Team from 16 to Over 100 in Less Than 4 Years: Hubtel’s Journey, A Tale of Growth, Innovation, and a Whole Lot of Coffee 

How HubtelWay AI works

HubtelWay AI operates using Retrieval-Augmented Generation (RAG) with OpenAI models to process our internal knowledge base (the ‘corpus’ of documents). The system breaks down company documents into smaller, focused chunks of text. Using an embedding model, these chunks are converted into unique vector embeddings—essentially numerical representations that capture the meaning of each piece of content. These embeddings are then stored in a vector database for efficient retrieval.

When an employee asks a question, HubtelWay AI converts the query into the same vector format. It then finds the most relevant document chunks. These chunks provide context for the Large Language Model (LLM) to generate responses based strictly on Hubtel’s documentation.

Data integrity and privacy are essential in such a system. The system is designed to follow Hubtel’s data policy, which maintains data confidentiality and protects employees’ privacy. Personal data or sensitive employee information is not stored or shared, as the chatbot only accesses anonymized and non-personally identifiable organizational content to provide responses.

Practical Applications and Future Enhancements

Imagine a new team member joining Hubtel. Instead of spending weeks navigating various documents, they can simply ask HubtelWay AI questions like, “What are Hubtel’s core values?” or “How does Hubtel approach teamwork?” This immediate access to cultural knowledge allows them to align with our ways of working from day one.

For current team members, HubtelWay AI offers reliable support for day-to-day decisions. Whether refreshing their understanding of company policies or checking details about our leadership structure, the system provides consistent information across all our locations. This uniformity is essential as we expand across cities.

As we look towards the future, HubtelWay AI may incorporate more personalized features. These may include department-specific knowledge or project-based frequently asked questions (FAQs) to better cater to specialized teams. In addition, we are exploring the integration of real-time updates. This feature would allow the chatbot to reflect any new policy changes instantly. This way, employees will always have access to the most current information.

READ ALSO: From Snail Mail to Warp Speed: How Hubtel Rocketed Its Product Delivery 

Embrace the HubtelWay…

We encourage all ‘Hubtelites’ to make HubtelWay AI their first stop for questions about the company. Whether you’re a new team member finding your feet or a seasoned ‘Hubtelite’ exploring new aspects of our organization, HubtelWay AI is your gateway to a deeper understanding of the Hubtel Way—safeguarded by technology that values both efficiency and privacy.

Reaching the stage where tackling scaling challenges is part of your daily hurdles is a great place to be. It’s in one way or the other, the kind of problem every innovation team aspires to face. It’s a sign your innovations are succeeding, but it also requires evolving your teams and systems to meet new challenges and opportunities. Scaling an engineering team from a modest 16 to over 100 engineers is a significant milestone for any company, and at Hubtel, this journey has been one of excitement, learning, and growth. It reflects our commitment to building not just an engineering powerhouse, but a culture and ecosystem where innovation thrives.  

As a fintech company heavily engaged in e-commerce and building systems that significantly impact both our operations and many key businesses in the market, our ability to scale quickly became a critical component of our success. 

Let’s explore the strategies, challenges, and lessons learned in scaling Hubtel’s engineering team to meet the demands of an evolving industry, complex projects, and the need for a robust technological infrastructure to support our growing suite of products and services. 

READ ALSO: HubtelWay AI: An Artificial Intelligence Solution to Enhance Organizational Culture

1. The Need for Scaling: Recognizing the Inflection Point 

Scaling Hubtel’s engineering team was not a decision made overnight. It was the result of careful consideration and an assessment of where the company was headed. In our early stages, the engineering team was a lean 16-person group that handled all aspects of product development, from coding and infrastructure to bug fixes and deployments. This worked well when our operations were focused on relatively limited product offerings. 

However, as we expanded our vision to “Drive Africa forward by enabling everyone find and pay for everyday essentials” and widen our product scope, particularly into more complex B2B services, it became clear that we needed more hands-on-deck. We were reaching an inflection point where our current capacity couldn’t keep up with the new projects and demands. Our ambitions to deliver a best-in-class fintech platform required us to reimagine what our engineering team would look like in order to meet the technical and operational challenges ahead. 

2. Laying the Foundation: A Clear Framework for Growth 

Before jumping into the hiring frenzy, we needed to put a framework in place. Scaling is not just about adding more people, it’s about hiring the right people, at the right time, for the right reasons. The following were our foundational pillars for this process: 

Defining Roles and Responsibilities 

The first step was defining what roles we needed to fill. Let me say that we have long mastered the practice of maintaining a clear separation of concerns in Hubtel engineering frontend, backend, mobile, Infrastructure, with each team operating with specific objectives. But in a smaller team, engineers often wear many hats, juggling between multiple projects and responsibilities and while this flexibility is valuable in a small setup, we recognized that to scale effectively, we had to specialize. 

We clearly defined product categories and formed a full engineering team around each product (frontend developers, backend engineers, machine learning engineers, data engineers, DevOps specialists, quality assurance (QA) engineers, and product managers). This specialization allowed each team member to sharply focus all their expertise on a single product and give their best, giving them a singularity of focus, improving both the speed and quality of work. 

Establishing Core Competencies 

We identified core competency areas that every engineer needed to excel in. These included both technical skills, such as proficiency in key programming languages and frameworks (e.g., C#,.NET, JavaScript, Reactjs, Vuejs), and soft skills like communication, problem-solving, and collaboration. Since engineers often work across teams, strong cross-functional communication became essential as we scaled.  

To ensure fair, data-driven hiring decisions, we created a detailed competency matrix used in all interviews. This matrix allowed us to score prospective engineers in each competency area, ensuring we evaluated both technical expertise and cultural fit as accurately and consistently as possible. 

Creating a Scalable Hiring Process 

Hiring quickly doesn’t mean hiring haphazardly. We knew we needed a robust hiring framework that would allow us to evaluate candidates quickly and fairly. Our hiring process was designed to be rigorous, with multiple stages of interviews: an initial talent phone screening – to show appreciation for the time the talent invested in the application and explain the journey ahead, an online assessment that tests both technical, cognitive and soft skills, and a physical interview followed by a coding challenge that reflects real-world problems engineers would face at Hubtel. 

3. Attracting Talent: Building a Pipeline of Engineers 

One of the biggest challenges we faced in scaling Hubtel’s engineering team was finding the right talent. As competition for skilled engineers has grown globally, especially in the fintech space, we needed to think creatively about how to attract talent. 

Branding Hubtel as a Destination for Engineers 

Building a strong employer brand became crucial during this phase. We focused on positioning Hubtel as a place where engineers could tackle complex, meaningful challenges. This was largely achieved through intentional leadership, fostering a positive internal culture, and benefiting from word-of-mouth referrals, as our engineers and network shared their positive experiences, attracting top talent organically. They highlighted the exciting work we were doing in fintech and how they were driving impactful changes in revenue mobilisation  in the utility sector, instant services, e-commerce etc. 

Partnerships with Universities and Coding Academies 

Another key strategy for talent sourcing was building strong relationships with educational institutions. We partnered with many universities and coding academies, such as the University of Ghana (UG), University of Mines and Technology (UMaT), Ashesi University, and Bluecrest College, among others, to create a pipeline of young, enthusiastic engineers. Through internships, workshops, and mentorship programs, we not only gave back to the community but also developed a steady stream of new talents that could be integrated into our team. 

Referrals and Word of Mouth 

Word of mouth became one of the most powerful tools in attracting talent. We incentivized our existing employees to refer talented engineers to us, creating a culture where our engineers felt proud of working at Hubtel and excited to bring others into the fold. 

4. Talent Development: Onboarding and Growing Engineers from Within 

Hiring engineers is only part of the equation. Developing talent from within has been equally important in our scaling journey. One of our core beliefs at Hubtel is that a great engineer is not just one who knows how to code, but one who continues to learn and grow, especially in leadership. 

Onboarding Mentorship and Knowledge Sharing 

Our onboarding process is a crucial first step in integrating new hires. We’ve designed a comprehensive structure to ensure that new team members quickly familiarize themselves with our tools, processes, and way of working in an immersive and efficient manner. Following this, new hires are paired with senior engineers who provide ongoing mentorship and support, helping them deepen their understanding and adjust smoothly while reinforcing a culture of collaboration and teamwork. 

We also created a knowledge-sharing culture, where engineers regularly share what they were working on, new technologies they were exploring, or challenges they were facing. This kind of open communication not only increased the overall knowledge base of the team but also built a sense of camaraderie. 

Continuous Learning and Development 

To achieve our goals, we invested heavily in learning and development programs ranging from paying for online courses and certifications to organizing an in-house training academy (Hubtel Academy). By providing engineers with opportunities to enhance their skills and explore new technologies, we ensured they remained at the forefront of the industry. At the same time, this approach helped them build the capacity to integrate and lead new team members, fostering a smooth transition into our culture. 

5. Building a Culture of Collaboration and Innovation 

One of the challenges of scaling is maintaining the culture that made you successful in the first place. . During the pivotal phase of scaling Hubtel’s engineering team, we were intentional about preserving our culture of learning, collaboration and innovation. This wasn’t just about ensuring that everyone worked well together; it was about fostering an environment where people were excited to bring new ideas to the table without promoting speculative import of culture. 

Product-Specific Teams  

One of our greatest innovations was transitioning from cross-product teams to product-specific teams. This played a key role in scaling Hubtel’s engineering team effectively. By having engineers, product managers, designers, and other professionals dedicated to individual products, we created a clear focus for each team, allowing engineers to specialize and deeply understand the product they were working on. This structure not only improved efficiency and innovation but also provided a clearer path for scaling the engineering team, as we could hire and grow talent based on the specific needs of each product. This targeted approach helped us expand the team strategically both vertically for a specific product and horizontally across the organization. 

Fostering Innovation to Support Team Scaling 

By setting up a dedicated innovation and tooling team, we created a structured pathway for engineers to contribute new ideas without disrupting their primary responsibilities. This approach not only encouraged continuous improvement but also allowed scaling Hubtel’s engineering team more effectively. Engineers could focus on their core tasks while still having a platform to propose innovations, which were then reviewed and refined by the dedicated team. As successful innovations were implemented across product teams, it improved processes and workflows, allowing us to onboard and integrate new engineers more efficiently. This structure ensured that as our numbers grew, the quality of work and pace of innovation remained high across the organization. 

6. Scaling Engineering Leadership 

As our engineering team grew, so did the need for more structured leadership. Leading 16 engineers is very different from leading 100. We needed to ensure that communication, performance, and team dynamics remained effective, even as the team expanded. 

Introducing Engineering Managers and Leads 

To manage the growing team, we introduced a layer of engineering managers and leads. These leaders were responsible for the day-to-day management of engineers, helping with everything from setting individual goals to removing roadblocks. This allowed the broader engineering leadership to focus on higher-level strategic decisions while ensuring that every engineer had the support they needed to succeed. 

Regular Feedback and Reviews 

We fueled the success of our scaling structure with the scaling structure itself. Yes, you read that right, and no, we do not claim to have invented a perpetual motion structure, I will explain. We implemented regular feedback loops in each and every single node of our structures, spanning from interviews through onboarding to exit interviews and everything in between. Also, we ensure feedback and metrics are collected, analyzed and fed back into the system to ensure everyone in the team had a clear understanding of how we were performing and where we could improve. We encouraged a culture of open, constructive feedback.  Not only did it help the engineers grow, but it also ensured that we were intentionally improving our structure and the team as a whole. 

7. The Challenges of Scaling 

Scaling is never without its challenges. Throughout this journey, we faced several hurdles that required careful thought and strategy to overcome. 

Onboarding New Engineers 

Bringing in new engineers quickly can overwhelm existing teams if not done correctly. We invested heavily in our onboarding process (we will talk about this in a later post), ensuring that new hires have a smooth transition into the company. We created detailed onboarding documents, set up mentoring programs, and scheduled regular check-ins to ensure that new engineers were integrating well into their teams. 

Communication and Alignment 

Another challenge we faced was ensuring that communication remained effective as the team grew. With a small team, it’s easy to keep everyone on the same page, but as the team expanded, we had to be more intentional about communication. We implemented regular all-hands meetings, team stand-ups, and project syncs to keep everyone aligned on goals and priorities. 

Maintaining Quality 

One of the most significant challenges in scaling is maintaining the quality of the work being produced. As we brought in more engineers, we needed to ensure that they were all producing high-quality code and following best practices. We did this by implementing rigorous code reviews, automated testing, and continuous integration pipelines. These processes allowed us to catch issues early and maintain the quality of our product, even as the number of contributors grew. 

READ ALSO: Hubtel’s Observability Journey: How We Enhanced Performance and Reliability

8. Looking Ahead: The Next Phase of Growth 

As we reflect on our journey from 16 engineers to over 100, it’s clear that we’ve come a long way—but our growth story is just starting. Tech space continues to evolve rapidly, and as a company with a very ambitious mission, we need to stay ahead of the curve. 

Stay tuned—we’ll be talking about scaling from 100 to 1,000 engineers in less than a year before you know it!  

Looking ahead, we plan to continue scaling our team with an even greater focus on diversity and inclusion. We believe that. 

Join us on this exciting journey! 

As we approach our 20th anniversary in May 2025, it’s an exciting time to reflect on Hubtel’s journey and look ahead to the future of engineering at our company. Hubtel has crafted a bold vision: ‘to be Africa’s most useful company,’ powering convenience for millions across the continent. Our mission—’to drive Africa forward by enabling everyone find and pay for everyday essentials’—continues to guide us daily. 

The Engineering Department: Building the Future Today 

At the heart of Hubtel’s success is a vibrant and ever-evolving engineering team. Our engineering department is not just about writing code; it’s about creating solutions that impact lives. As Head of Engineering, my goal is to foster a culture of innovation, “hyperproductivity,” and ownership among our team of over 100 talented engineers. 

READ ALSO: From Snail Mail to Warp Speed: How Hubtel Rocketed Its Product Delivery 

Our engineers, though many are new to Hubtel, share a passion for problem-solving and a commitment to our mission. Together, we’re pushing boundaries with cutting-edge technologies—from .NET Core and React (and Vue) on the frontend to Apache NiFi in data engineering. Now, we’re infusing AI into our processes and products, exploring new possibilities in our dedicated AI lab. 

Our Objectives: Engineering Excellence with Purpose 

The objectives of the engineering department align with Hubtel’s broader vision. We ensure that we deliver services that are reliable, impactful, and always available. Here’s what we’re focused on: 

• Innovation and Experimentation: Our newly-opened AI lab to experiment with emerging technologies and use cases that will shape the future of our product offerings. 

• Talent Development: Establishing a strong hiring framework and fostering leadership within the team is essential. We believe in infusing fresh minds into our engineering community and supporting their growth through well-organized tooling and frameworks. 

• Quality and Reliability: Our commitment is to produce services that are always available and reliable. We measure success by the confidence in the code we write and the performance of our deployed services in production. 

• Empowering Engineers: We encourage our engineers to take ownership of their work and drive the vision and mission of Hubtel from their areas of responsibility. Through regular feedback, professional development opportunities, and a collaborative culture, we strive to keep our team engaged and motivated. 

• Leveraging Data: Utilising data gathered from our users to drive informed decisions and improvements is at the core of our approach. 

Celebrating Two Decades of Innovation and Looking Ahead 

As we celebrate two decades of transforming the digital landscape, the engineering team is more energized than ever. We’re not just building software; we’re crafting experiences that make life easier for businesses and individuals across Africa. The next chapter of Hubtel’s story is about reaching new heights—exploring opportunities, enhancing product offerings, and pushing the limits of what’s possible. 

READ ALSO: Beyond Instinct: How the Code Confidence Index (CCI) is Transforming Code Quality at Hubtel 

Join Us on This Journey 

This blog will be a window into our world—a place where we share our challenges, triumphs, and insights. Whether you’re an engineer at Hubtel or a tech enthusiast curious about our work, we hope you find inspiration here.

Welcome to the Hubtel Engineering Blog. Here’s to the next 20 years of innovation, collaboration, and impact! 

And, oh—this was certainly not written by an LLM 

Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nullam iaculis nibh sit amet molestie congue. Aenean nec maximus magna. Aliquam turpis quam, fermentum at arcu non, convallis interdum nulla. Nulla eu imperdiet justo, efficitur commodo nisl. Nulla ac eros aliquam, suscipit ipsum ut, vehicula felis. Proin maximus bibendum augue, et venenatis nulla consectetur nec. Ut a dui et nisl fringilla tristique. Aenean id risus in urna laoreet cursus a non mauris. Nulla rutrum nec ex eget aliquet.

Vestibulum lacinia aliquet urna quis ultrices. Donec in dui eu metus efficitur posuere. Donec id purus dolor. Phasellus fringilla facilisis rutrum. Aenean ut leo ac quam molestie imperdiet eget in tortor. Donec elementum, urna vel porttitor venenatis, urna leo euismod ligula, rhoncus ullamcorper augue erat et metus. Aenean convallis dolor ex, et elementum quam tincidunt id. Quisque eu ultricies ex. Sed gravida dignissim ligula, a ullamcorper erat auctor viverra. Quisque condimentum volutpat leo, in fringilla mauris efficitur eu. Phasellus vestibulum cursus porta. Fusce molestie interdum semper. Fusce et est malesuada, vehicula tellus non, tempor neque. Quisque id nisi vitae massa accumsan tristique. Curabitur ultricies nec turpis nec dignissim.

Aliquam augue erat, vehicula et massa viverra, euismod iaculis erat. Phasellus ex neque, dapibus tristique malesuada ultrices, dapibus non lectus. Nulla est arcu, sodales ac est vel, volutpat facilisis mauris. Ut accumsan rutrum dolor a viverra. Vestibulum mattis augue eget erat ullamcorper congue. Curabitur consectetur feugiat lorem, quis elementum eros interdum id. Maecenas eu sapien commodo justo ullamcorper cursus. In fermentum sed leo aliquam efficitur.

Nullam egestas orci at feugiat tempor. Maecenas nec risus non magna bibendum tempor. Praesent malesuada volutpat tincidunt. Maecenas consequat ante non vestibulum rutrum. Aenean gravida, metus eu posuere malesuada, nibh lorem malesuada urna, vel commodo quam lectus sed leo. Donec eu neque odio. Donec efficitur non tortor ut malesuada. Etiam et volutpat arcu.

Nulla gravida et dolor eget pretium. Morbi aliquet elit vel enim consequat, at efficitur augue consectetur. Curabitur elementum neque eu libero placerat faucibus. Vestibulum sagittis tincidunt porttitor. Donec suscipit eros non dolor dictum, eu auctor quam mattis. Morbi magna enim, dictum sed tincidunt maximus, cursus eu sapien. Ut vitae consequat ex, vitae eleifend nibh. Sed fringilla eros odio, a fermentum lectus porttitor vitae.

Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nullam iaculis nibh sit amet molestie congue. Aenean nec maximus magna. Aliquam turpis quam, fermentum at arcu non, convallis interdum nulla. Nulla eu imperdiet justo, efficitur commodo nisl. Nulla ac eros aliquam, suscipit ipsum ut, vehicula felis. Proin maximus bibendum augue, et venenatis nulla consectetur nec. Ut a dui et nisl fringilla tristique. Aenean id risus in urna laoreet cursus a non mauris. Nulla rutrum nec ex eget aliquet.

Vestibulum lacinia aliquet urna quis ultrices. Donec in dui eu metus efficitur posuere. Donec id purus dolor. Phasellus fringilla facilisis rutrum. Aenean ut leo ac quam molestie imperdiet eget in tortor. Donec elementum, urna vel porttitor venenatis, urna leo euismod ligula, rhoncus ullamcorper augue erat et metus. Aenean convallis dolor ex, et elementum quam tincidunt id. Quisque eu ultricies ex. Sed gravida dignissim ligula, a ullamcorper erat auctor viverra. Quisque condimentum volutpat leo, in fringilla mauris efficitur eu. Phasellus vestibulum cursus porta. Fusce molestie interdum semper. Fusce et est malesuada, vehicula tellus non, tempor neque. Quisque id nisi vitae massa accumsan tristique. Curabitur ultricies nec turpis nec dignissim.

Aliquam augue erat, vehicula et massa viverra, euismod iaculis erat. Phasellus ex neque, dapibus tristique malesuada ultrices, dapibus non lectus. Nulla est arcu, sodales ac est vel, volutpat facilisis mauris. Ut accumsan rutrum dolor a viverra. Vestibulum mattis augue eget erat ullamcorper congue. Curabitur consectetur feugiat lorem, quis elementum eros interdum id. Maecenas eu sapien commodo justo ullamcorper cursus. In fermentum sed leo aliquam efficitur.

Nullam egestas orci at feugiat tempor. Maecenas nec risus non magna bibendum tempor. Praesent malesuada volutpat tincidunt. Maecenas consequat ante non vestibulum rutrum. Aenean gravida, metus eu posuere malesuada, nibh lorem malesuada urna, vel commodo quam lectus sed leo. Donec eu neque odio. Donec efficitur non tortor ut malesuada. Etiam et volutpat arcu.

Nulla gravida et dolor eget pretium. Morbi aliquet elit vel enim consequat, at efficitur augue consectetur. Curabitur elementum neque eu libero placerat faucibus. Vestibulum sagittis tincidunt porttitor. Donec suscipit eros non dolor dictum, eu auctor quam mattis. Morbi magna enim, dictum sed tincidunt maximus, cursus eu sapien. Ut vitae consequat ex, vitae eleifend nibh. Sed fringilla eros odio, a fermentum lectus porttitor vitae.

Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nullam iaculis nibh sit amet molestie congue. Aenean nec maximus magna. Aliquam turpis quam, fermentum at arcu non, convallis interdum nulla. Nulla eu imperdiet justo, efficitur commodo nisl. Nulla ac eros aliquam, suscipit ipsum ut, vehicula felis. Proin maximus bibendum augue, et venenatis nulla consectetur nec. Ut a dui et nisl fringilla tristique. Aenean id risus in urna laoreet cursus a non mauris. Nulla rutrum nec ex eget aliquet.

Vestibulum lacinia aliquet urna quis ultrices. Donec in dui eu metus efficitur posuere. Donec id purus dolor. Phasellus fringilla facilisis rutrum. Aenean ut leo ac quam molestie imperdiet eget in tortor. Donec elementum, urna vel porttitor venenatis, urna leo euismod ligula, rhoncus ullamcorper augue erat et metus. Aenean convallis dolor ex, et elementum quam tincidunt id. Quisque eu ultricies ex. Sed gravida dignissim ligula, a ullamcorper erat auctor viverra. Quisque condimentum volutpat leo, in fringilla mauris efficitur eu. Phasellus vestibulum cursus porta. Fusce molestie interdum semper. Fusce et est malesuada, vehicula tellus non, tempor neque. Quisque id nisi vitae massa accumsan tristique. Curabitur ultricies nec turpis nec dignissim.

Aliquam augue erat, vehicula et massa viverra, euismod iaculis erat. Phasellus ex neque, dapibus tristique malesuada ultrices, dapibus non lectus. Nulla est arcu, sodales ac est vel, volutpat facilisis mauris. Ut accumsan rutrum dolor a viverra. Vestibulum mattis augue eget erat ullamcorper congue. Curabitur consectetur feugiat lorem, quis elementum eros interdum id. Maecenas eu sapien commodo justo ullamcorper cursus. In fermentum sed leo aliquam efficitur.

Nullam egestas orci at feugiat tempor. Maecenas nec risus non magna bibendum tempor. Praesent malesuada volutpat tincidunt. Maecenas consequat ante non vestibulum rutrum. Aenean gravida, metus eu posuere malesuada, nibh lorem malesuada urna, vel commodo quam lectus sed leo. Donec eu neque odio. Donec efficitur non tortor ut malesuada. Etiam et volutpat arcu.

Nulla gravida et dolor eget pretium. Morbi aliquet elit vel enim consequat, at efficitur augue consectetur. Curabitur elementum neque eu libero placerat faucibus. Vestibulum sagittis tincidunt porttitor. Donec suscipit eros non dolor dictum, eu auctor quam mattis. Morbi magna enim, dictum sed tincidunt maximus, cursus eu sapien. Ut vitae consequat ex, vitae eleifend nibh. Sed fringilla eros odio, a fermentum lectus porttitor vitae.

“Never be afraid to jump at the sun, you will never reach it, but your feet will leave the ground.” (Bram, 2017) 

And jump we did. The Hubtel story, often told, is a testament to the power of ambition and the lessons learned along the path of embracing failure.  

Origins and Early Wins: 

Founded in 2005 as SMSGH by Alex Bram, Ernest Apenteng,  and Leslie Gyimah, three ambitious undergraduates, the company started as SMSGH with a mission to simplify business to customer communication via SMS. The founders’ entrepreneurial spirit, honed through various earlier ventures, proved crucial in navigating early challenges. SMSGH saw quick success, making its first sale after five months and securing significant contracts within its first year. By 2007, the company was a pioneer, launching Africa’s first online SMS portals and alert systems for banks, reaching an impressive $1 million in revenue that year. 

Pivotal Transformation: 

Despite initial success, the company recorded slowing growth rates around 2013-2014, which prompted the need for a strategic shift. The company leaders participated in the Stanford Seed Business Transformation program in 2016 which led to the birth of the Hubtel brand with a new emphasis on payments and customer services. The Hubtel mobile app launched in 2017, aiming to be a “super-app” connecting users and businesses. Hubtel obtained approval from the Bank of Ghana to operate as an Enhanced Payment Services Provider in 2019, solidifying its position in the fintech space. 

Growth and Recognition: 

Since rebranding in 2017, Hubtel has experienced phenomenal growth, attaining a full license as an Enhanced Payment Services Provider in 2022 and becoming Ghana’s largest fintech by the end of that year. The company takes pride in its workforce, which has expanded significantly over the past 2 years to 650+ employees across Ghana, reflecting the company’s impact and success.  

The Hubtel mobile application taps into a vast market, with 4300+ restaurants and eateries, 632 pharmacies and shops, and 382 active riders in 8 cities across the country. This extensive network facilitates an average of 42,000+ orders monthly, serving a customer base of 10,500+ monthly.  

The Hubtel Legacy 

Over the past years, Hubtel has had a significant impact on various industries in Ghana, including telecom, entertainment, banking, education, retail, healthcare, and utilities.   

In the utilities sector, Hubtel worked with the Electricity Company of Ghana (ECG) from July 2022 to plug payment processing leakages and grow monthly revenues by nearly 100% to GHS1.2 billion.  Due to this significant feat, in March 2024, the company signed a commercial agreement with the nation’s largest distributor of power, Electricity Company of Ghana (ECG)  

In the education sector, Hubtel provides a mobile application that helps schools manage school fee payments. This has streamlined payment processes and improved the financial management of early childhood schools across Ghana.  

In the healthcare sector, Hubtel has played a key role in the digital transformation of hospitals. This has increased efficiency and transparency, benefiting both patients and staff.  

Hubtel’s story embodies the power of innovation, adaptability, and unwavering dedication in a competitive tech landscape. The company transitioned from a focused SMS provider to a leading fin offering a ‘super-app’ that facilitates everyday transactions. Hubtel’s emphasis on pivoting to meet market needs and overcoming obstacles serves as an inspiration for businesses in Ghana and beyond. 

Discover more of the Hubtel story here: hubtel.com/19-years 

Great news! There’s a new way to pay on the Hubtel app. 

It’s simple! Now, when you place an order, we only charge you once we’ve confirmed that your order is available and ready for delivery. This means you won’t be charged until we confirm your order.  

Previously, order confirmation required upfront payment, with reimbursements issued when an item is unavailable. For a smoother experience, we now confirm the availability of your order with the restaurant before charging your account. 

How does it work? 

1. Open the Hubtel app.  

2. Tap on ‘Food’ or ‘Everyday Essentials’ and select the meal or items you want to be delivered.  

3. Add to your order and confirm.  

4. Select your delivery time. 

5. Confirm delivery. 

6. Tap on “Mobile Money” and select your preferred mobile wallet 

7. Tap on “Place Order” 

After tapping on ‘Place Order,’ your order will be confirmed with the retailer or restaurant to ensure food or item availability. Once confirmation is done, your account will be debited. 

It’s important to note that this feature is currently only available on the Hubtel mobile app and supported only through MTN Mobile Money and Telecel Cash. 

Whether you’re at home, at work, or out and about, order your everyday essentials and favorite meals and have them delivered in no time. Download the Hubtel app and enjoy a new level of convenience.