For companies to remain competitive, they require smart systems that solve their unique day to day business problems. However, when applying these systems many decision makers get lost in the complexity due to limited communication and collaboration within the implementation process.
We are at the cutting edge of the latest optimisation methodologies and web technologies. However, unlike many other optimisation, and analytics companies out there, one of our main goals is to make powerful optimisation accessible in the real world to bring value to our clients.
We specialise in the development of web applications and smart optimisation engines– delivered in less time than you would probably think. It’s not unusual for us to go from an initial workshop with a client, to understanding their problem, and then having a fully functional optimiser in a production environment within three months.
On top of this the same people are often involved through the entire SDLC (software development life cycle) i.e. from the spec/design, theory, implementation and delivery/support. This reduces the overhead many organisations incur by having different people in business analytics and developer positions. The people implementing the solution actually understand and work with you to solve your problem.
So, how do we go about delivering an Optimisation solution?
It is important that the core problems facing our customers are well understood. This allows for far more accuracy and rigour in determining not only the costs involved, but the project schedule.
The One Week Spec
Our approach often involves having a Biarri employee go out to the client’s site for a couple of days to spend time with the domain experts and stakeholders to understand the problem. They’ll then go back the Biarri office and write up their understanding of the specification (often including some design mock-ups / screenshots). This spec may go through a few iterations with the client until it is agreed what the problem is that is being addressed, what is in scope and what is out of scope.
Once the scope of the project has been agreed on, a price estimate is put together along with a project plan to outline timing along with some design mockups (if relevant).
This entire process typically takes about a week for small-medium projects.
Go / No- Go Decision
Once the specification of the scope has been agreed on, along with estimates and project plans, the client can then decide if they wish to proceed with the project. We’ve found that this approach works well for both Biarri and the client.
The benefits for both parties is that they can spend a small period of time together to ensure they can work together.
The benefits for our clients include
- Determining if Biarri can understand their problem adequately
- Determine if Biarri has the capability to provide a solution
- Get a fixed price and project schedule
- Lower risk as they can pull out after the initial specification phase without ever having to commit to a larger more expensive project.
- If they choose to go ahead with the main project they do so with the increased confidence built up during the initial specification stage
The benefits for us include
- Being able to understand the problem and provide more accurate estimates before committing to a project that may not have been well understood at the start
- Understanding what resources are required for the project.
Formulating the Mathematics
Not everything we do has an optimisation engine in it. Sometimes we develop modelling/simulation engines, predictive engines, simple web apps, or complex operational cloud based systems. However, optimisation engines are a large part of what we do and provides significant value to our clients. If an optimisation engine is required we start formulating the mathematics before we start writing any computer code.
This has significant benefits
- It helps us to ensure we understand the entire problem in enough detail (as we can’t formulate it without understanding it). The formulation process often drives out some of the details of the problem missed in the initial workshops.
- It helps to ensure we take the right approach the first time. This is because during the formulation stage we start to not only get a feel for if it is theoretically possible to solve the problem, but also if the theory is practically implementable.
- We start to get a feel for how large the problem is and start to address questions like the amount of memory required and solvability duration.
- We’ll often have internal brainstorming meetings with a group of keen mathematicians who love to solve these types of problems which usually results in a better approach being taken.
- Having the mathematics formulated can help resolve issues later if the computer optimiser is not behaving as expected. In other words, it can help identify if the problem is with the theory (i.e. the formulation) or the implementation (i.e. the computer code).
- Having the mathematics formulated actually helps with the structure of the computer code as we’ll often architect the code to match up to the variables, constraints, data and equations in the formulation.
- Many issues get resolved during the formulation stage. This is much faster and cheaper than trying to resolve the issues after many weeks of code have already been written.
Implementation – Mitigation by Iteration
Once we are satisfied that we have a good approach to solving the problem on paper we then go about actually implementing the solution by writing the computer program. We often write our own solutions from scratch, or reuse some of our pre-existing IP, when developing optimisation engines for our clients
The implementation of the solution is usually broken down into two broad categories:
- Front-end: This involves the design and implementation of the web user interface. This is where the client interacts with the engine using a web browser.
- Back-end: This involves the development of the optimisation that runs on a cloud server, the database server and infrastructure that holds it all together.
The implementation is often done in stages with the most critical functionality being implemented first. We prefer to keep the client engaged during these stages, to ensure we’re on the right track, by getting them to test out the functionality as it’s developed. This is very easy to do because all the client has to do to run our tools is open a web browser, enter the relevant URL (for our cloud testing server) and login. There is no need for them to install any software on their computer (which is the traditional approach to software which can be difficult in large organisations with strict IT policies).
This process of iterating constantly with the client helps to mitigate the risk of ‘not solving the right problem’. It also encourages consistent communication with the client and allows us to get feedback earlier rather than later. It also introduces the client to the solution in a step by step manner which aids in their training and understanding of the solution sooner rather than later.
Delivery & Support
Once the solution has been completed and the client has tested and is happy we then move the solution to our production server. For the client this simply means using a different URL to point to our production server rather than our testing server. Everything else is the same for them.
The delivery mechanism is the same regardless of the number of users. If there is one user or 20 users, all they need to do is type in the same URL into their web browser and login. The fact that our solutions are cloud based also means that they can often run our tools on any device connected to the internet (e.g. desktop, tablet, phone). The actual device does not need the memory or the CPU power to run the optimisation because that’s all taken care of on our cloud server.
If the user finds issues in the production environment that need to be addressed, or they request improvements to the functionality, we can deal with these as they arise. It’s also often easy for us to replicate and identify issues because the data and logs are on our server. Once we have fixed an issue, or implemented a new feature, we update the testing server and allow the clients to check that they are happy with the implementation. Once they are, the solution gets pushed to our production server and all users instantly have access to the new version.
Begin your optimisation journey with us today and let us prove how accessible mathematics delivered through simple software can drive real world results!