Frequently asked questions

We are a software development and consulting partner. We help you move from idea → working product → stable long-term system.

Our core focus areas are:

• Custom web applications and mobile apps
• Dashboards, analytics and reporting solutions
• API development, integrations and automation
• UX/UI design for new and existing products
• Support, maintenance & optimisation of live systems

We are comfortable working across different domains. Common ones include:

• Healthcare & health-tech (maternal & newborn health, clinics, programs)
• E-commerce & service marketplaces
• Education / e-learning & internal training platforms
• NGOs / social impact programs & data systems
• Custom internal tools for operations, HR, travel, approvals, etc.

If your domain is different, we typically spend extra time in the discovery phase to understand your context properly.

Common engagement models:

• Fixed-scope projects – clear features, timeline and cost agreed upfront.
• Time & material – for evolving products; you pay for actual effort in a controlled way.
• Retainer / long-term support – we act as your extended product/tech team.

In all models, you get a single point of contact / project lead, regular check-ins, and clear documentation.

We aim for 95%+ on-time delivery across projects, with realistic timelines communicated upfront.

To keep delivery on track, we:

• Break work into small milestones / sprints
• Share regular demos instead of surprises at the end
• Flag scope changes early with impact on time & cost
• Keep a clear list of “must-have” vs “nice-to-have” items

If something genuinely impacts the timeline (e.g. external dependency), we inform you early and propose options.

We follow a simple, transparent flow:

1. Discovery – understand your goals, users, constraints, success metrics.
2. Scope & proposal – define modules, timelines, tech stack, and commercials.
3. Design – UX flows, wireframes, UI screens (as needed).
4. Build – backend, frontend, integrations, internal testing.
5. Review & refine – client demos, feedback rounds, UAT.
6. Go-live – deployment, configuration, training.
7. Post-launch support – bug fixes, optimisation, new features.

For larger programs, we repeat this cycle for each phase or module instead of doing everything at once.

We usually select the stack based on your context, team and budget. Common choices:

• Web: PHP (Laravel / CodeIgniter), Node.js, modern frontends (React / Vue / plain Bootstrap)
• Mobile: Native Android, cross-platform approaches where suitable
• Databases: MySQL / MariaDB, PostgreSQL; occasionally NoSQL if required
• Dashboards: Tableau, custom web dashboards, embedded analytics
• Cloud & infra: AWS, Azure, other providers as per client preference

If you already have a preferred stack, we try to align with that so your internal team can maintain it later.

We start simple but with a clean structure. For most projects we:

• Use modular code, clear separation between backend, frontend, and integrations
• Design APIs that can be reused by web, mobile and third-party systems
• Keep an eye on performance (queries, indexing, caching where needed)
• Leave room for scaling out (database optimisation, load balancing, micro-services later if required)

We don’t over-engineer on day one, but we avoid dead ends that make future scaling painful.

For custom projects executed for you, you own the code and IP once payments as per agreement are completed.

We typically:

• Host the project code in a private repository (Git)
• Provide you access / ownership to the repos on completion
• Document any third-party dependencies and licenses

For any reusable internal frameworks or libraries we use across clients, that is clearly discussed in the SOW.

We use a mix, depending on clarity of scope:

• Fixed cost – when requirements are clear and frozen; we agree on milestones & payment schedule.
• Time & material – when requirements will evolve; you get a transparent rate card and effort tracking.
• Retainer – for ongoing support or a shared team working across multiple small tasks.

We’re happy to start with a small discovery / prototype phase to reduce uncertainty, and then shift to a fixed-scope engagement.

Support is not an afterthought for us. Typical options:

• Stabilisation period immediately after launch with priority bug fixing.
• Ongoing maintenance (SLAs for response and resolution times).
• Feature enhancement cycles – we collect feedback and plan periodic releases.

Communication happens over a shared channel (e.g. email, ticketing tool, or your preferred system) with clear tracking of issues.

We define this clearly in the support agreement. As a guideline:

• Critical issues (system down, blocking) – first response within a few business hours.
• High priority (major function impacted) – triage and plan within agreed SLA.
• Minor issues / enhancements – bundled into planned releases.

For mission-critical systems, we can design a stronger SLA based on your needs and time zones.

Security and confidentiality are standard, not “extras”:

• We sign NDA / confidentiality agreements where required.
• Use role-based access and keep dev/test/live environments separated.
• Follow basic application security practices (input validation, auth, HTTPS, etc.).
• Never use your production data in casual test environments without masking / consent.

If you have specific compliance requirements (e.g. health data guidelines, data residency), we plan the architecture accordingly.

You can host on your own infrastructure or on cloud providers (AWS, Azure, etc.). We usually recommend:

• Using your own cloud account so that you control access and billing.
• Clearly separating environments for development, testing and production.

If you prefer, we can initially host in our account during development and later migrate everything to yours.

We do both:

• Custom solutions – tailored to your exact workflow, data, and users.
• Re-usable modules / internal products – e.g. common dashboards, admin panels, auth modules.

Wherever it saves time and cost, we use existing components and then customise the last mile for your use-case.

Don’t worry if you don’t have a formal document yet. A simple starting point is:

• What problem are you trying to solve?
• Who are the main users? (field staff, managers, customers, etc.)
• Any existing systems / data / Excel sheets we should connect with?
• Rough timelines and constraints (budget, devices, locations).

You can share this via email, or fill our Project Intake / Get a Quote form. From there, we set up a short call and move into the discovery phase.

We adapt to your comfort but usually use:

• Email / messaging for day-to-day updates.
• Shared documents for requirements, decisions, and notes.
• Issue tracker / task board (or your preferred tool) for features and bugs.
• Regular review calls (weekly/fortnightly) for demos and decisions.

Transparency is a priority: you should always know what we are working on and what’s coming next.

Yes. Many projects involve improving or extending existing systems instead of replacing them immediately.

We can help you:

• Review current architecture, database and code quality.
• Stabilise critical issues and reduce downtime.
• Plan a phased modernisation (module by module).
• Migrate or clean existing data where needed.

The aim is to avoid risky “big bang” migrations and move in safe, manageable steps.