+353 (0) 1482 6918
Our Software
Development
Methodology
Not all software consultancies are created equal.
Our goal at Ardanis is to use agile processes, evolutionary architecture and automation to help organisations produce software they can build their futures on.
Going beyond code
We don’t just code software. The company was founded by five like-minded computer scientists and engineers, passionate about innovating the entire software development process.
With nearly 80 years’ combined experience in development, our founders have witnessed enough poorly executed ventures and been involved in numerous hugely successful projects to have formed a clear vision of how projects should be run. We have a rigorous methodology for simplifying software development.
Agile
Agile methodologies (Scrum, Kanban, XP, etc.) are at the heart of our framework. We favour cross-functional product delivery teams, retrospectives and iterative development to ensure teams are efficient and produce high-quality software that brings competitive advantage.
Evolutionary Architecture
We’ve built everything – from the tiniest microservice to global enterprise systems. We promote modular, loosely coupled designs. To avoid the risk of overengineering, we favour designs that evolve as your company grows, in the cloud or on-premise.
Automation
Manual processes are error-prone and can use up valuable resources in terms of man-hours and oversight. Smart automation of your testing and deployment processes means your development team can spend more time on what really matters, building better products.
Are you looking for a technology solution using the latest innovations?
Delivering Successful software development projects
Our range of consultancy, outsourcing and resourcing services are tailored to your exact requirements. Whatever the project, we use tried and tested methodologies and lightweight, iterative processes to take you through the development cycle.
Our software development process
We use lightweight processes and well-known patterns which can evolve over time. We prefer to optimise for simplicity, speed, flexibility and evolution. Once these have been achieved, efficiency and cost saving will follow. Building high-quality software is a multi-dimensional discipline with many different factors to consider, which is why we always draw from best practice.
Our six dimensions methodology is the result of our lean and iterative development experience. Scrum or Kanban teams can use it as it can be implemented at the sprint or feature level.
Discover
Understanding the client’s business and needs is key to a successful collaboration. We use organisational structure and cultural values to reduce the friction between teams and build a high-trust environment.
Questions We Ask
- What are the end user’s needs?
- Where is the business going?
- Do we have clear, concise and easy to communicate requirements, allowing us to build structured delivery roadmaps?
Key Strategies
- Define the high-level mission of the organisation. Trust people to do what is right.
- Encourage team autonomy and continuous improvement.
- Favour cross-functional teams that combine business and technology.
- Organise teams around business or product lines.
- Traditional business domains (sales, marketing, etc.) become cross-cutting concerns.
- Technical functions (architecture, QA, Ops, etc.) become cross-cutting concerns.
- Use communities of practice to manage these cross-cutting concerns.
Define
The ability to clearly define your customers’ needs and the direction of your business is critical. We help define requirements which are clear and concise and build structured delivery roadmaps.
Questions We Ask
- What are the end user’s needs?
- Where is the business going?
- Do we have clear, concise and easy to communicate requirements, allowing us to build structured delivery roadmaps?
Key Strategies
- Use prototypes and experiments to validate ideas.
- Team autonomy can be enhanced by OKR.
- Use inception planning, story mapping, and release planning to improve coordination and collaboration between teams.
- Use epics and user stories to decompose and structure team backlogs.
- Use BDD and Given/When/Then to define and deliver requirements.
- Use a common ubiquitous language to describe features, requirements, and technical capabilities.
- Use structured group decision-making techniques when estimating.
Design
UI design should always consider your customers’ behaviour and needs to solve their problems. We design software systems that are loosely coupled and easy to change. We standardise technology choices to control complexity.
Questions We Ask
- How do end users behave and what do they need?
- How can UI design solve their problems?
- What technologies will help us to control complexity?
Key Strategies
- Use design thinking and customer journey engineering to improve UI design.
- Understand the different types of coupling that can occur in a software system.
- Software designs should be modular with clear separation between teams, domains, and concerns.
- Target architecture establishes guidelines, implementation is left to teams.
- Monoliths and micro-services have the same design considerations.
- Embrace plurality. A single DB technology, language, or architectural style may not fit all use cases.
- Avoid path dependencies or an over-reliance on technologies and rigid processes.
- Security needs to be part of the design.
Develop
Software craftsmanship, patterns and testing are at the core of our development philosophy. Our code is clean and easy to understand. We continually test as we develop, always keeping it simple.
Questions We Ask
- Which development patterns and testing processes will work best on this project?
- Is the code clean and easy to understand?
- Is documentation sufficiently in-depth?
- Are we keeping it simple?
Key Strategies
- Encourage software craftsmanship and continuous improvement at the team and individual level.
- Use extreme programming techniques to encourage high-quality software development.
- Use Scrum and/or Kanban but focus on objectives and results rather than the process.
- Teams should be able to define their own processes, but they should also be flexible.
- Use TDD and BDD to improve the quality of deliverables.
Deliver
Automation of manual processes can greatly simplify how software is built and deployed. We build pipelines which deliver software to your customer quickly, enabling your organisation to experiment and learn rapidly.
Questions We Ask
- Do we have a pipeline that will deliver the software quickly?
- Have we automated processes where we can?
- Is the client involved in experimenting and learning with us?
Key Strategies
- Use Continuous Integration and Continuous Deployment/Delivery.
- Define tests in terms of scope (unit, component/module, service, system) and type (functional, integration, acceptance, performance, and stress).
- Automate as much testing as possible.
- Speed up delivery by decoupling manual and exploratory testing from the production deployment pipeline.
- Avoid or reduce reliance on end-to-end or system-wide testing. Test services in isolation, use contract testing, and decouple deployment from release.
- Automate deployment all the way up to production.
- Teams should be able to deploy their software independently.
- Use infrastructure as code (IaC) to automate infrastructure provisioning.
Improve
Once a feature or change is deployed to production, its impact is measured and understood. We include monitoring and analytics as part of the feature, with insights driving future requirements.
Questions We Ask
- What should we measure for meaningful insights?
- Is there a process for measuring and understanding the impact of features or changes?
- Is monitoring and analytics in place?
Key Strategies
- Consider metrics and monitoring at the beginning of a project, not the end.
- Aggregate logs for useful data as well as errors.
- Monitor infrastructure as well as applications.
- Teams should be responsible for monitoring the software (and infrastructure) they own.
- Define and capture business metrics, especially for key customer journeys.
- Incorporate health-checks into all services.
- Create data dashboards (a picture is worth a thousand words).
- Definition of Done defines how to verify a feature is working as intended.