We don't promise anything we haven't built before.

Any agency can put "scalable architecture" or "mobile apps" on a list. We, next to each service, tell you which of our products we did it in and with what result. If something isn't backed up, it's because we haven't done it yet — and we'd rather tell you.

Before writing code Building Implementation and quality Integration Data and intelligence Operations

01 Before writing code

This is where it's decided whether the project goes well.

Most projects that fail don't fail while coding: they fail because no one understood the real process, or because the architecture didn't hold up what came later. All of this happens before the first line of code, and it's far cheaper than fixing it later.

Consulting and digital transformation

Understand before proposing

We assess feasibility, select technology and optimize processes. The most useful part is usually the uncomfortable one: telling you what not to build. Often the problem doesn't need a new system, but fixing the one you have or changing how you work.

What it includes

  • Mapping the real process, not the one in the manual.
  • Technical and effort feasibility study.
  • Technology selection that's justified, not trend-driven.
  • A phased roadmap, with what delivers value first.
  • Identifying what to automate and what to leave as is.

Where we've done it

  • All four products came out of this exercise. ResiHub exists because we mapped how a property manager actually operates, not how the rulebook says they do.
  • Cliento was built in phases: security and leads first, invoicing later. Four of five are complete and the fifth is in progress.
  • Requirements gathering
  • Feasibility
  • Phased roadmap
  • Process optimization

Software architecture

The decision that defines whether the system holds up

We design the foundation: data model, boundaries between modules, deployment strategy. It's the part no one sees and the one that determines whether in three years the system can still be touched or has to be thrown out. We work with Clean Architecture, CQRS and modular design when the problem justifies it — and with something simpler when it doesn't.

What it includes

  • Data model and persistence strategy.
  • Layer separation and boundaries between modules.
  • Versioned migrations from day one.
  • Authentication, roles and permissions strategy.
  • Architecture review of existing systems.

Where we've done it

  • Billium runs on Clean Architecture + CQRS in ASP.NET Core 9.
  • ResiHub covers 61 management areas with defined boundaries, and keeps growing without breaking what already worked.
  • TalentUs separates domain, data, application, IoC and presentation into five projects.
  • Clean Architecture
  • CQRS
  • Modular design
  • Repository pattern
  • Versioned migrations

UX/UI product design

Interfaces understood without a manual

We design for whoever will use the system eight hours a day, not for the screenshot that looks pretty in a proposal. That means forms that don't fight you, tables you can actually filter, and different dashboards by role: the manager and the operator don't need to see the same thing.

What it includes

  • Role-based flows, not a generic interface for everyone.
  • A reusable, consistent design system.
  • Responsive design: desktop, tablet and mobile.
  • Accessibility and light/dark mode where it applies.
  • Redesign of existing interfaces no one wants to use anymore.

Where we've done it

  • ResiHub has ~63 navigable sections and six roles with their own dashboards, each seeing only what's theirs.
  • Billium uses shadcn/ui on Radix with light/dark mode and Zod-validated forms.
  • Role-based design
  • Design systems
  • Responsive
  • Accessibility
  • Light/dark mode

Technical advisory and second opinion

A pair of eyes that has been through this

Sometimes you don't need us to build anything, but to review what you already have or what you're being proposed. We assess an architecture, another vendor's quote or a project going off the rails, and give you an honest read with no sales agenda.

What it includes

  • Technical review of an in-progress or stalled project.
  • Assessment of third-party proposals and quotes.
  • Technical due diligence before buying or investing.
  • Occasional guidance for an internal team on key decisions.

Why us

  • We maintain four systems in production, in two different stacks. Reading someone else's architecture is what we do every time we touch code we didn't write ourselves yesterday.
  • We don't sell you smoke: if the best answer is "your current system works, don't change it," we tell you that too.
  • Architecture review
  • Technical due diligence
  • Proposal assessment
  • Second opinion

Prototypes, MVP and proof of concept

Validate cheap before investing big

Before committing months and budget, we build a small version that tests the idea with real users. An MVP isn't a half-built system: it's the core that delivers value, done well, to learn before scaling — and not discover the mistake when it's already expensive to fix.

What it includes

  • Defining the minimal core that truly tests the idea.
  • Technical proof of concept for the most uncertain or risky part.
  • Built on foundations that hold if the MVP works.
  • A clear path from MVP to full product, in phases.

Where we've done it

  • Cliento started as the core — security, users and leads — and grew in phases to quotes, invoices and KPIs. That's exactly the path of an MVP.
  • ResiHub didn't start covering 61 management areas: it began small and each one earned its place through real use.
  • MVP
  • Proof of concept
  • Prototyping
  • Phased validation

02 Building

Working software, not progress slides.

We work in short iterations and deliver things you can open and test. It's the only honest way for you to see progress — and to tell us in time if we're drifting off.

Custom software development

Systems built around your operation

When no product on the market fits, or when fitting means changing how your company works to accommodate the software. We build the system around your operation, from gathering to production — and you keep the code.

What it includes

  • Backend, frontend and database.
  • Authentication, roles and granular permissions.
  • Reports and export to Excel, PDF and CSV.
  • Scheduled tasks and notifications.
  • Delivery of the code and the documentation.

Where we've done it

  • 61 management areas and 39 features in the ResiHub dashboard, all under one architecture.
  • TalentUs covers the 7 areas of human resources, from recruitment to payroll, with more than 30 functional modules.
  • Four complete products built from scratch, in two different stacks (.NET and Node).
  • ASP.NET Core 9
  • NestJS
  • React
  • Angular
  • TypeScript
  • PostgreSQL
  • SQL Server

Multi-tenant SaaS platforms

Our specialty — all four products are

Building a multi-tenant SaaS is easy to say and hard to do well. The problem isn't the interface: it's guaranteeing that one client's data never touches another's, not through a bug, not through an endpoint someone forgot to filter. That's solved in the architecture, not by reviewing by hand.

What it includes

  • Isolation applied automatically, not endpoint by endpoint.
  • Plans, limits and licenses with expiration control.
  • A super-admin panel to manage the platform.
  • Account suspension with immediate session revocation.
  • Soft delete with partial unique indexes.

Where we've done it

  • ResiHub handles the hardest case: property managers running several condominiums. A global guard checks on every request that the assignment is active, or returns 403.
  • Cliento resolves the tenant from the JWT and applies it automatically, via middleware and a TypeORM subscriber. No one can forget to filter.
  • Billium isolates each company on the same infrastructure, with its own digital certificate and NCF sequences.
  • Multi-tenancy
  • RBAC
  • JWT + refresh
  • Per-request guards
  • Plans and licenses
  • Soft delete

Mobile apps

iOS and Android, published in the stores

Native apps with React Native and Expo. The hard part of an app isn't the first screen: it's biometrics, push notifications that actually arrive, QR scanning in a garage with no signal, and the store publishing process. We've been through all of that twice.

What it includes

  • One codebase for iOS and Android.
  • Push notifications and real usage analytics.
  • Biometrics: Face ID, Touch ID and fingerprint.
  • QR scanning and camera.
  • Offline mode and deep links.
  • Builds and publishing with EAS.

Where we've done it

  • ResiHub Mobile: biometrics, visitor QR, WebSocket chat, payments and voting. In continuous evolution.
  • ResiHub Handy: a field app with a custom network client — retries, timeout and offline read cache.
  • ResiHub's backend exposes a dedicated layer for the mobile apps, separate from the web dashboard's.
  • React Native
  • Expo
  • EAS Build
  • NativeWind
  • Gluestack UI
  • Native push
  • Offline-first

Process automation

Let the system do the repetitive work

Every process someone does by hand every day, week or month is a candidate for automation: calculations, charges, alerts, closings. It's not about replacing people, but about letting them stop doing what a machine does better and without forgetting.

What it includes

  • Scheduled tasks: closings, calculations and periodic generation.
  • Flows that trigger actions when something happens, not when someone remembers.
  • Automatic notices and alerts by email and in the app.
  • Business rules that apply themselves across the whole operation.

Where we've done it

  • 17 scheduled tasks in ResiHub: recurring charges, monthly balances and automatic blocking of overdue units — all without human intervention.
  • Cliento creates the follow-up task on its own from each visit, and three daily jobs flag overdue items and alert on stalled opportunities.
  • Billium checks receipt status against the DGII on its own with a background job.
  • Scheduled tasks
  • Background jobs
  • Business rules
  • Automatic alerts

03 Implementation and quality

Get it working, and stand behind it.

Two things that tend to be left for last and shouldn't: getting the system into real operation — not "handing it over" — and being able to prove the code is well made, not just claim it.

System implementation

From installed to running in your operation

A system is useless installed; it's useful when people use it. We handle rolling the system out into your real operation: whether it's one of our products or third-party software, we configure it to fit you, migrate your data and support the go-live until the team works with it daily.

What it includes

  • Configuring the system to your operation, roles and permissions.
  • Migration of your existing data, validated before writing.
  • Bulk load of master data from your spreadsheets.
  • Guided go-live and team training.
  • Setting up the organization with its roles and its administrator.

Where we've done it

  • ResiHub has rollout solved in the product: creating an organization provisions its roles and its admin user in a single transaction.
  • The Excel import with preview → commit → undo is, literally, the initial data-load tool for a new client.
  • Billium bulk-imports customers from Excel or CSV with a downloadable template — the first step of every launch.
  • Custom configuration
  • Data migration
  • Initial load
  • Go-live
  • Onboarding training

Code and quality audit

Know what state it's really in

You inherited a system, or yours started having problems and you don't know why. We review the code against the same standard we build with: architecture, security, technical debt and maintainability. At the end you get a clear report with the urgent, the important and what can wait.

What it includes

  • Review of architecture and code organization.
  • Security review: authentication, permissions, sensitive data.
  • A technical-debt map prioritized by risk.
  • A concrete action plan, not a list of complaints.

Against what standard

  • The same one we build our own with: Clean Architecture, CQRS, strict TypeScript and versioned migrations.
  • We know where problems hide because we prevent them daily: per-tenant isolation, strict validation, encryption at rest.
  • Architecture review
  • Security review
  • Technical debt
  • Prioritized report

Automated testing

So a change doesn't break what already worked

The fear of touching the code comes from not knowing what will break. Automated tests remove that fear: every change is verified on its own against what was already supposed to work. We set up the test scaffolding and cover the critical stuff first — calculations, money, permissions — which is where a bug is expensive.

What it includes

  • Scaffolding setup: Jest, supertest and end-to-end tests.
  • Tests for critical services: calculations, charges, permissions.
  • Tests that run on their own on every change, inside CI.
  • Reproducing a bug as a test, so it doesn't come back.

Where we've done it

  • Cliento has tests on its critical services — the task scheduler and the notifications — with Jest and supertest.
  • The end-to-end test scaffolding is set up in our Node backends and runs in the integration flow.
  • Jest
  • supertest
  • e2e tests
  • CI tests
  • Critical-path coverage

04 Integration

Your software doesn't live alone.

Almost no project starts from scratch: there's a system that already works, a tax obligation to meet, or years of data to move without losing anything. This is the part that gets underestimated and the one that sinks the most projects.

DGII tax integrations

e-CF, 606/607/608 and TSS payroll

It's probably what sets us apart most in the Dominican market: we didn't read the regulation, we implemented it in full. XMLDSig signing, validation against the official XSDs, Seed → token authentication, the ten receipt types, intake with peer-to-peer acknowledgment and the report formats.

What it includes

  • e-CF issuance with digital signing and transmission.
  • Intake, acknowledgment (ARECF) and commercial approval (ACECF).
  • 606, 607 and 608 reports in the official format.
  • DR payroll: income tax, pension, health insurance, INFOTEP and TSS reports.
  • Connecting the tax layer to your current system.

Where we've done it

  • Billium implements the 10 types from E31 to E47, plus RFCE, ANECF, ACECF and ARECF, against the three DGII environments.
  • ResiHub generates 606, 607 and 608 with official export, and complete Dominican payroll with severance per articles 75–95.
  • e-CF E31–E47
  • Firma XMLDSig
  • Validación XSD
  • Semilla → token
  • 606 · 607 · 608
  • TSS

APIs and third-party integrations

Get your systems talking to each other

We design and build APIs so others can connect to your system, and we connect yours to the ones you already use. With the contract documented and versioned, because an undocumented API is a debt you pay every time someone new integrates.

What it includes

  • REST API documented with Swagger / OpenAPI.
  • API Key authentication with key rotation.
  • Webhooks with retries and delivery history.
  • Versioning so you don't break whoever already integrated.
  • Transactional email, push, WebSocket and storage.

Where we've done it

  • Billium exposes a public API with API Key, webhooks with an event catalog and retries, and api/v1 versioning.
  • ResiHub integrates real-time Socket.io, push with Expo, its own CDN and storage in AWS S3 or Azure Blob.
  • REST
  • Swagger / OpenAPI
  • API Key
  • Webhooks
  • Socket.io
  • SMTP · SendGrid · Mailjet

Migration and modernization

Get the legacy system out without shutting down operations

Phased modernization: the new system is stood up alongside the old one and both coexist until the replacement is complete. There's never a day when everything is shut off and you pray. Data is migrated with prior validation, because a badly migrated record is worse than not migrating it.

What it includes

  • Audit of the current system and its data model.
  • A phased plan with both systems coexisting.
  • Data migration with validation and rollback.
  • Documentation so you don't get trapped again.

Where we've done it

  • ResiHub has been evolving in production for years without outages: changing the data structure with the system live is routine for us.
  • ResiHub's import module loads data with preview → commit → undo: it validates every row before writing and can roll back a whole batch.
  • Phased modernization
  • Data migration
  • System coexistence
  • Versioned migrations
  • Safe rollback

05 Data and intelligence

Having the data isn't the same as using it.

Almost every company has years of stored information and makes decisions on intuition anyway. The problem is rarely a lack of data: it's that it's where no one looks, in a format no one reads.

Business Intelligence and Power BI

From raw data to decision

We start with the question, not the chart: what decision needs to be made, who makes it and how often. Then we build backward. A dashboard with five figures looked at every day is worth more than one with forty no one opens.

What it includes

  • Dashboards with Power BI or built into your system.
  • Real-time KPIs and role-based views.
  • Reports with filters, ranges and export.
  • Automatic alerts instead of reports no one opens.
  • A single source of truth for the whole company.

Where we've done it

  • ~68 reports in ResiHub: 50 predefined, ~15 generators and 3 tax formats. With export to Excel, PDF and CSV.
  • Cliento has a real-time KPI dashboard and reports on sales, pipeline, funnel and forecast.
  • The property-manager global view consolidates metrics across condominiums and exports to 3-sheet Excel and PDF with charts.
  • Power BI
  • Recharts
  • ApexCharts
  • Chart.js
  • ExcelJS
  • jsPDF

Applied Artificial Intelligence

Assistants connected to your real data

A chatbot that only chats is no use to anyone. What is useful is an assistant with tools: one that queries your database, computes over real information and writes with your context. The difference is in connecting it to your operation, not in the model it uses. We've already built one like that, in production: VERA.

What it includes

  • Assistants with access to your data via tools.
  • Assisted drafting of communications and documents.
  • Extraction and classification of information from documents.
  • Natural-language queries about your operation.
  • Built into your system, not in a separate tool.

Where we've done it

  • VERA —Virtual Executive for Residential Administration— is ResiHub's AI assistant, in production. It queries delinquency and treasury in natural language, reads bank transfer receipts and answers based on the condominium's rulebook.
  • It's not a chatbot: it executes actions —bookings, tickets, scheduled charges— always with prior confirmation, respects each role's permissions and keeps everything audited. It doesn't make up figures: it queries the real database.
  • VERA
  • LLM + tool use
  • Receipt reading (vision)
  • Actions with confirmation
  • Role-based permissions
  • Fully audited

06 Operations

Launch is the starting point.

This is where most agencies vanish. We live with our code every day: our products keep getting versioned, and that's the same commitment we offer.

Cloud and DevOps

Make deploying stop being scary

If deploying is an event planned weeks ahead and done at dawn, something is wrong. With containers and CI/CD, shipping becomes routine — and above all, reversible. That completely changes the speed at which your team can improve the product.

What it includes

  • Containers with Docker and reproducible environments.
  • CI/CD with GitHub Actions and automatic deployment.
  • Environment separation: development, testing and production.
  • Health checks and structured logging.
  • CDN, file storage and app builds.

Where we've done it

  • Billium runs with health checks, structured logging (Serilog + Seq) and background jobs with Hangfire.
  • ResiHub deploys with Docker on enterprise cloud (AWS / Azure), with its own CDN for receipts and documents.
  • Cliento uses Docker Compose, GitHub Actions and managed deployment on AWS / Azure.
  • Docker
  • GitHub Actions
  • AWS
  • Azure
  • CDN
  • EAS Build

Support and evolution

Support after launch

A system that doesn't evolve starts dying the day it launches, because the operation does change. We offer ongoing maintenance, monitoring and development of new features — with semantic versioning and a changelog, so you always know what changed and when.

What it includes

  • Bug fixing and corrective maintenance.
  • New features in iterations.
  • Dependency updates and security patches.
  • Semantic versioning and a changelog for every release.
  • Monitoring and incident response.

Where we've done it

  • Admin dashboard and mobile app: each service with its own versioning and changelog.
  • All four products are still in active evolution. None is a project delivered and forgotten.
  • Semantic versioning
  • Changelog
  • Evolutionary maintenance
  • Security patches
  • Monitoring

Not sure which one you need?

That's normal, and you don't need to know. Tell us the problem and we'll tell you what's needed — even if the answer is that you don't need to hire us.

Tell us your problem See use cases