Digital Product Strategy

Talk to one of our experts
Digital Product Strategy

If you run into a different problem, don't hesitate to contact us and together we'll find the right solution

Get in touch with us

What product development means

A digital product is not a project that ends at handover; it is something that can be shown, delivered, maintained and extended as your business grows. The difference between an application and a product lies in the questions answered before the first line of code: who it serves, what problem it solves, how you measure that it worked and on what terms we stop. Product strategy is where those answers are given — on paper, cheaply — instead of being discovered later, in code, where the same correction costs tens to hundreds of times more. We work with the practices of mature product teams: separated responsibilities, written priorities and points fixed in advance where the answer can also be "we are not continuing".

A product passes four tests

Before calling anything a "product", we check four things, in the order that matters. 1It can be shown and sold — someone can clearly demonstrate what it does and why it is worth paying for, even if work remains. 2It can be delivered — it works for a real user, not only in a presentation, and the process that produces it is settled. 3It can be maintained — documentation, tests and people who can repair it without its original author all exist. 4It can scale — it holds up when users, data and simultaneous operations grow. A product that passes only the first two tests turns, within two years, into a liability: it runs, but nobody can change it any more.

Three responsibilities, not one person

In a healthy product, three responsibilities are distinct and held by different people. 1The business owner answers for "what" and "for whom": they know the market, gather the requirements and make sure the product answers a real need. 2The process owner is the link between business and engineering: they turn market requirements into functional specifications, so both teams see the same thing. 3The technical owner answers for "how": they design the system, distribute the work and oversee every technical aspect. When one person carries all three, one of them is always lost — usually the one that should have said "we are not building this".

Decision gates: continue, hold, recycle or stop

Between stages we place gates — points fixed in advance where an explicit decision is taken, instead of drifting onward out of inertia. At each gate the answer can be: continue, hold, recycle the stage with different assumptions, or stop. Their purpose is not bureaucratic but economic: a change of direction at the first gate costs the price of a conversation; the same change made after launch costs thousands of times more. Gates keep a continuous conversation running between the people who sell and the people who build, instead of a single handover of requirements at the start, after which each side goes its own way.


The stages of product development

The stages below apply to any product, whether an application, a platform or a system that also drives physical equipment. The first of them — analysis — normally consumes between a quarter and a third of the total effort, and that is precisely why it is not shortened: the most frequent cause of delay is the late discovery of a requirement.

Each stage ends with concrete deliverables and with a decision, not with a silent move to the next one. The last three — training, go-live and maintenance — are the ones most often left out of proposals, even though whether the product actually gets used depends on them.

  1. Analysis

    What the product must do, and under what quality constraints, is settled before any line of code. It yields the usage journeys, a list of functionality that leaves no room for interpretation, and the measurable criteria by which the product will be called good.

  2. Design

    How it will be built is settled: the structure of the system, how data is organized, the interfaces between the parts and, where relevant, the equipment and how it integrates. This is also where prototypes verify feasibility before building at scale.

  3. Development

    The code is written, with coding standards, naming conventions and peer reviews. What already exists in mature form on the market is integrated and configured rather than rewritten — we build only where building brings something that cannot be bought.

  4. Testing

    Each piece is checked on its own, the pieces together and then the whole system, along real usage journeys. Performance, security, compatibility and ease of use are checked here too, and defects enter a tracking process, not an email.

  5. Deployment

    The product is installed and configured in the real working environment, migrating existing data where relevant. The deliverable is not only the working system but also the documentation that lets it be reinstalled without us.

  6. Training

    The people who will use the product are prepared before go-live, by user category, with materials that stay with you. A good product used wrongly produces the same numbers as a bad one.

  7. Go-live

    The system moves into productive use, with intensive monitoring and support at hand in the first days and weeks. Final acceptance is signed after a period of stable operation, not on launch day.

  8. Support and maintenance

    After launch the product receives corrections, preventive measures and small improvements, within the agreed response terms. Without this stage, everything built before degrades quietly.

The release rhythm — a business decision, not a technical one

Not every product launches the same way. The classic release takes the complete product to market at once, which suits functionality that cannot be broken into useful pieces. The incremental release puts a useful core out earlier, with the rest planned from the start. Continuous improvement starts from an initial specification and rewrites it as the market responds — flexible, but with appreciably higher risk and effort. In practice we use a combination of the last two: we plan the whole product from the start, but deliver step by step and correct once we see how it is used.

A launch is not a moment but a sequence of thresholds

The alpha version stays inside and exercises our own processes, with nearly all functionality implemented. The beta version goes to a limited group of real users and passes acceptance testing against the criteria set during analysis; there can be several, each with a clear deadline for feedback. Then come the release candidates — versions submitted for verification and remade until no blocking defect appears any more. Only then is the full version released, once it is confirmed that it answers the requirements in the initial document.


The specifications that hold a product up

Most product failures come not from the code but from things nobody wrote down: who decides what, what belongs in the first release, when it counts as finished. That is why each stage produces a document with a designated author and a clear dependency on the one before it — none of them is written "in parallel", so that they never end up describing different products. The documents are not for the file but for decisions: from them follow what gets built, how it is tested and what is accepted at the end.

  1. Product requirements

    Written by: the business owner

    The usage journeys — who interacts with the product, for what task and in what order — plus the list of functionality, worded to leave no room for interpretation and split across two priorities. It is the only document written to be understood identically by you and by the developers.

  2. System architecture

    Written by: the technical owner

    The languages used, the code versioning system, the databases and their structure, the development tools, how the working environment is installed and configured, and the procedure by which the product reaches release. It is written only after the requirements have been agreed.

  3. Functional specifications

    Written by: the process owner

    Interface flows and screens: navigation, the layout of elements, forms, the installation and licensing process and the way the system handles errors in front of the user. This is where the product becomes visible before it exists.

  4. Technical specifications

    Written by: the technical owner

    Component diagrams and the relations between them, the structure of the data, the algorithms and the technical handling of errors. The document that actually says how the code is written; it follows the functional specifications rather than preceding them.

  5. Acceptance criteria

    Written by: the business owner

    The minimum, non-technical requirements the product must meet in order to be accepted: response times, the documentation that accompanies delivery, anything else that matters at handover. They are written before construction, so they are not negotiated afterwards.

  6. Test plan

    Written by: the quality team

    What is tested manually and what automatically, on which platforms, with which kinds of check — consistency, navigation, error cases, behaviour under load, re-checking old functionality after every addition — and how responsibilities are divided in the team.

  7. Increment plan

    Written by: the process owner

    Increments from one day to two weeks, tasks drawn from a shared list and grouped by priority, the testing schedule and the simple rule that nothing moves on until everything committed in the current increment is finished and tested.

What goes into the first release

Two lists, not one: what must exist for the product to make sense, and what would be good to have. This separation is the cheapest budget control instrument there is, because it moves the discussion from "do we cut it or not" to "now or later". The same hierarchy applies to defects found in testing: those that stop the product working, those that affect essential functionality but can wait, and those attached to optional functionality. Only the first block a launch; the rest go into the next plan instead of endlessly postponing an otherwise usable product. At the end of every increment priorities are re-set, because what looked essential in January may no longer be in March.


The architecture of the solution

Architecture is the set of decisions most expensive to change later, so we take them early, explicitly and in writing. We describe it through two complementary views, because they answer different questions: where the system runs, and how its parts talk to one another. We do not start from a technology preference but from the real forces of your business — what has to keep working when the internet drops, which data must never mix, which parts have to be switchable on or off without stopping the rest.

Physical architecture — where the system runs

This view says what runs centrally and what runs on site. Centrally sit the shared services, the consolidated data and the reports — wherever it is useful for a single installation to serve several working locations, with strict separation between them. On site sits everything that cannot wait for a round trip across the network and cannot afford an internet outage: the link to the equipment, the working terminals, the flow that has to run offline too. The split is not a preference but the consequence of two measurable requirements — response time and continuity of operations. When the link drops, the site carries on by itself, and whatever happened meanwhile synchronizes automatically on return, with nothing lost.

Logical architecture — how the parts communicate

Modules do not call one another directly, because that is how the system you can no longer change piece by piece comes into being. They communicate through messages: requests to execute on one side, facts that have already happened on the other. The effects are concrete. A part can be started, stopped or replaced without stopping the rest, so you can begin with what you need and add as you go. What happened stays in a journal that is never rewritten, so a figure can still be explained a year later, to an auditor or a funder. And the current state and the history sit apart, each with its own role: one says how things are, the other says how they got there.

At the end of the strategy what stays with you is the documents, not a presentation: the requirements, the architecture, the acceptance criteria and the increment plan. With them you can build with us, with your own team or with anyone else — a partner whose interest is to also tell you "don't build" has to leave that exit open too.

Request the product strategy

Together we build for you

Together we build for you.

Get in touch with one of our experts

The technologies we build with

Ubuntu ServerJava (OpenJDK)Node.jsNginxApacheBashLaravel ReverbDockerDocker ComposeKubernetesHelmAnsibleJenkinsGitGitLabPrometheusGrafanaNagiosSonarQubeKibanaLogstashPHPLaravelComposerFilamentLaravel SanctumEloquent ORMC#Visual StudioJavaScriptTypeScriptReactAngularjQueryD3.jsTailwind CSSHTML5CSS3VitenpmReact NativeExpofastlaneAndroidiOSSwiftXcodeAndroid StudioCocoaPodsGradleApache CordovaIonicFramework7Electronelectron-builderRedisRabbitMQApache KafkaPostgreSQLMySQLMariaDBOracleSQL ServerMongoDBElasticsearchCassandraCouchbaseHadoopMinIOApache IcebergParquetDuckDBPyIcebergpgvectorMilvusNeo4jOpenSearchpgAdminPythonC++LuaPyTorchTensorFlowKerasOpenCVLangChainHugging FaceOpenAIAnthropicAWSAzureGoogle CloudTwilioStripePayPalPestVitestJestPlaywrightMaestroCypress
@Cronoxy 2006 - 2026. Together we change the world.