Ask a room full of stakeholders what a product should do, and you'll often get several different answers. Ask what problem they're actually trying to solve, and the picture usually becomes much clearer.
That gap, between what people ask for and what they actually need, is where software projects can go off course.
At JRC Software, we believe good product development starts by understanding the problem before committing to the solution. That means bringing strategy, UX, product design, and engineering considerations together early, so teams can validate what they are building and why before development moves too far.
Design Thinking Is Not Just "Making It Look Nice"
There's a common misconception that design belongs to the visual layer of a product, something that happens after the important engineering decisions have already been made.
Good product design is broader than that.
It's about understanding users, identifying the problems worth solving, challenging assumptions, exploring possible solutions, and validating ideas before significant development effort is committed.
For us, that means asking:
- Who will actually use this product?
- What are they trying to accomplish?
- Where are the current frustrations or inefficiencies?
- Is the proposed solution addressing the underlying problem?
- What can we validate before we build the full system?
The goal isn't to design more screens. It's to make better decisions about what should be built.
Why This Comes Before Code, Not After
A feature can be technically sound and still fail to deliver value if users don't understand it, don't trust it, or don't need it in the form it was built.
Finding that out after development can mean expensive changes across design, engineering, testing, and deployment.
Early prototypes, mockups, and user feedback can expose these issues sooner. They give stakeholders something tangible to react to and give engineering teams a clearer understanding of what needs to be built.
This fits naturally with JRC's approach to software delivery. JRC provides UX and product design alongside capabilities including AI, data engineering, cloud engineering, platform engineering, quality engineering, and secure development.
How It Works in a Real Engagement
Understand the Actual Users. The person commissioning a system isn't necessarily the person using it every day.
An operations director may define the requirements for a platform, while frontline employees use it under very different conditions.
Understanding users and their context helps uncover requirements that may not appear in an initial specification.
Reframe the Problem Before Solving It. Clients sometimes arrive with a solution already in mind:
"We need a dashboard."
"We need a mobile app."
"We need to automate this process."
Those may be the right answers. But they may also simply be the first solutions that came to mind.
The more useful question is: what problem are we trying to solve?
Sometimes the answer is a dashboard. Sometimes it may be a notification system, a workflow change, an integration, or an entirely different product experience.
Starting with the problem gives the team room to find the right solution rather than simply building the requested one.
Prototype Before Committing Significant Engineering Effort.
Clickable prototypes and early design concepts allow stakeholders and potential
users to react to an idea before the complete system is built.
That feedback can reveal confusion, missing requirements, unnecessary complexity, or assumptions that need to be revisited.
It also gives engineering teams a clearer target as the solution moves into development.
Test With Users, Not Just Internal Consensus.
Internal
stakeholders know the business and project extremely well, which makes their input
valuable. But it can also make it difficult for them to see the product through
the eyes of someone encountering it for the first time.
User feedback can surface friction and misunderstandings that aren't obvious from inside the project team.
The earlier those issues are discovered, the more options the team has to address them.
Design Thinking and Trust, Especially in AI
User-centred thinking becomes particularly important as software incorporates more AI.
JRC develops AI-driven software solutions using Generative AI and Machine Learning to automate workflows, enhance user experiences, and create new business capabilities.
But an AI feature isn't successful simply because the underlying technology works.
Users may need to understand what the system is doing, when its output should be trusted, and where human judgement still matters. Those questions have a product and design dimension as well as a technical one.
Why It Fits Naturally Into an Integrated Delivery Model
Design works best when it isn't isolated from engineering.
JRC describes its offering as end-to-end software delivery, from strategy and design through build, launch, and scale. It also positions itself as taking ownership across the full delivery lifecycle, from discovery to deployment.
That allows product and design decisions to be considered alongside technical realities from the beginning.
UX considerations can inform engineering decisions. Engineering constraints can inform product decisions. Security, scalability, quality, and performance can be considered as part of the solution rather than treated as problems to solve at the end.
The result isn't simply a better-looking interface. It's a better-aligned product, where the problem, the user experience, and the technology are considered together.
Start With the Problem
The best software isn't necessarily the software with the most features or the most polished interface.
It's software that solves the right problem for the right people, in a way that works in the real world.
That's why we believe the first question shouldn't be:
"What should we build?"
It should be:
"What problem are we actually trying to solve?"
Once that is clear, the screen, and everything behind it, has a much better chance of being worth building.
Have an idea that needs the right problem definition before it needs code?
Let's talk about what problem is actually worth solving.