Process
From idea to production — and after.
Six phases, one team. Most engagements end at launch; ours continue, because a product is not finished when it ships.
Process
From idea to production.
Most engagements end at launch. Ours continue: the people who build your product stay responsible for it once it is live.
01
Discover
We start from the problem, not the stack. Users, constraints and risks are written down before anything is built.
- Scope
- Constraints
- Fixed quote
02
Design
Interface, architecture and data model are designed together, so the experience and the system agree.
- Interface
- Architecture
- Data model
03
Engineer
Production-grade code from the start: typed end to end and documented as it is written.
- Application
- APIs
- Documentation
04
Deploy
Automated builds and releases to the web, the App Store and Google Play, on environments we set up.
- CI/CD
- Environments
- Store release
LaunchWhere most engagements end.
05
Operate
Monitoring, security patches, encrypted backups and on-call. Restores are rehearsed, not assumed.
- Monitoring
- Patches
- Backups
06
Scale
Performance, capacity and new features as usage grows — planned by the people who built the system.
- Capacity
- Performance
- Roadmap
Phase by phase
What happens, and what you receive.
01
Discover
We start from the problem: who it is for, what exists today and what has to be true for it to succeed. Constraints and risks are written down. Then the scope, the price and the schedule are fixed in the contract.
- Written scope
- Constraints and risks
- Fixed price and schedule
02
Design
Interface, architecture and data model are designed together. Store rules, permissions and data separation are settled here — not after a review rejection or a security incident.
- Interface designs
- Architecture
- Data model
03
Engineer
Production-grade code from the start, typed end to end and documented as it is written. Architecture decisions are recorded with their reasons and the alternatives set aside.
- Application and APIs
- Repository in your name
- Technical documentation
04
Deploy
Automated builds and releases to the web, the App Store and Google Play, on environments we set up. Published under your publisher name or ours, as decided in the contract.
- CI/CD pipeline
- Environments
- Store releases
05
Operate
Continuous monitoring, security patches applied and verified, encrypted backups with restores actually rehearsed, on-call, and a monthly report of availability, incidents and fixes.
- Monitoring and on-call
- Backups and restore drills
- Monthly report
06
Scale
Performance, capacity and new features as usage grows, planned with the people who built the system — and an exit procedure written from day one, if you ever want to leave.
- Capacity planning
- Roadmap
- Documented exit
Working together
What you can hold us to.
One contract, one party responsible
From first mockup to on-call, the same team answers — from code to server.
A price set before we start
Scope, amount and schedule are fixed in the contract. A change of scope is discussed and quoted first.
Your code, your accounts
Repository, store accounts, domain names and data stay in your name, or are transferred to you.
An exit written on day one
The handover procedure is documented at the start, not negotiated at the end.
Questions
What people ask us.
Do you build for clients, or publish your own apps?
Both. We publish our own products and take on our clients’ — development, release, hosting and operations. The craft is the same; what changes is who owns the application at the end.
Under whose name will the app be published?
Under yours if you hold a developer account, under ours if you would rather we carry the release. Both work and are decided in the contract; the seller name shown on the store listing follows directly from that.
Do you handle hosting too?
Yes, and it is what sets us apart most: we operate what we build. Monitoring, security patches, backups and on-call are part of the contract, not an add-on.
What if I want to take my app back?
The exit procedure is written at the start of the project, not negotiated at the point of leaving. Code, data, store accounts and domain names come back to you, with the documentation another team needs to pick it up.
How long does a first version take?
It depends entirely on scope, and an answer given before looking would be worthless. We scope first, quote second, and the schedule is fixed in the contract.
What is the link with the Tensly agency in France?
They are two separate companies. The French agency builds websites and projects for its clients in France; Tensly Solutions LLC publishes and operates applications. Each has its own contracts and obligations.
Have something worth building?
Tell us what you’re building. We reply within two working days with an honest first view on feasibility, scope and order of magnitude.