Providing Professional And Creative Software
zenHackers are dedicated to writing beautiful, high-quality software using the latest reliable technologies. We
incorporate the following principles into every software solution that we provide:
System Correctness and Reliability
Our top priority in developing any software solution is that the system MUST function 100% correctly and that
the system is 100% reliable.
Optimized for Speed and Efficiency
All our software solutions are optimized for speed and efficiency. We still believe that even though
hardware is cheap, source code still needs to be optimized.
Professional, Clean, and Organized
We take care to create professional software that is well-organized and clean. Every aspect of the software
solution is carefully designed to make sure that the entire system is structurally sound and that no unnecessary
features / code resides in the system. This results in a software solution that is very easy to maintain
and expand. We don't just pile feature on top of feature; we carefully design each feature to integrate into the
system as smooth and cleanly as possible, redesigning existing features where necessary. This results in very
stable software solutions that are of high-quality.
Beautiful, Smart, and Creative
We believe that a software solution must be beautiful, from a user-perspective, but also from a developer-perspecitve.
We take care to write code that very easy to understand (code that is easy to understand is beautiful code). We create
software solutions that are smart, that utilizes all your business rules to empower and enable your business. We do not
create solutions that restrict their users, but rather empowers them. Now you can start working smarter. We use the input
from all our members to create solutions that are creative, using technology in creative ways to give you the edge in
We also value the fun-factor of our solutions. This means that we design our software solutions to be fun and
intuitive to use. We strongly believe that if it is not fun to use a software solution, it is not a good solution.
All our software solutions are designed to run as long as possible. We make sure to think about the life of our
solutions after development has been completed. We design all our software solutions so that they can run for as
long as possible without an upgrade / maintenance, minimizing cost and risk to our clients.
Our Development Model Reduces Risk
Because we know that developing a custom software solution for your business is a big risk for any company,
we have created a development model to minimize the risk for our clients.
We believe that the client must be in control of certain aspects of a software development project,
specifically the financial side. With our development model, the client enjoys the following benefits:
the client can decide the priority of the features that must be implemented at each stage of development.
This lets us write the most important parts of the system first. Getting to a usable product faster.
the client can pause/stop the development after any phase is complete. This has many benefits, but the primary
benefit is that the client can manage cost. If a phase is complete, the client can wait until he has enough
money to continue with the next phase. Also the client only pays for the work done in each phase, so there
is no large sum of money that needs to be paid at once, the client pays in small increments for the work
done so far. If the client feels that the system doesn't need any further phases to be completed, he/she
is free to stop the development of the project, only incurring the cost of the work done so far.
the client gets to see parts of the system very early, allowing him to approve the work done so far
and test the functionality as soon as possible. This lets us catch errors in the design / functionality
very early in development and allows us to fix them before going on to the rest of the system.
the client can change his mind about implemented features / functionliaty after each phase. Our development
model supports change, because some client environments are subject to regular change, our development model
is structured to embrace change. This means that if some business process changed while we were incorporating
it into the system, we can simply change it after the phase is complete. The client is not met with the
inability to change his system.
the client has direct access to the development team. This means that the client will be working directly
with the people doing the work. There is no complicated communication channel that allows for a message
or idea to get lost in the translation.
Our Development Model Protects Our Clients
But our development model does not only give the power to the client, it also protects our clients throughout the development
process, keeping your investment safe.
Before starting the development, we can provide the client with a paper/mock-screen prototype so that we can show
the client what his system will look like and how it will work BEFORE starting any development work. This helps us
finalize ideas and features before starting any development work. At this stage of development, it is very easy and cheap
to make big changes to the system as no code will need to be modified, only screen-shots.
We use a custom-built project management system to keep track of the changes that should be made during a phase
and to track bugs reported by our clients. The project management system allows us to provide detailed information
to the client of what development was done during a phase, what bugs were fixed, etc.
We use a revision control system (Bazaar/Git) for ALL our projects. This means it is easy to track changes made to
the source code. We can move backward to any point in time and retrieve the source code for that time. We can also
manage changes to source code securely, allowing multiple people to make changes to the source code safely, without
losing any source code or support files.
We have multiple copies of the entire project on multiple PCs, so if any of our PCs are stolen or fails, we have
up-to-date copies on other machines. We also create regular backups of the project that we burn to DVD. Upon
the completion of a phase, the entire project source code with full revision history and support files are handed
to the client so the client has a copy of the full source code for his project.
We recognize that sometimes a client will have his own competent staff that may want to make changes to the system
themselves. No problem. We incorporate detailed inline source code documentation, as well as external documentation
about the system. Our code is written in such a way that it is easy to understand and change. We also provide support
for clients modifying their own system. This means the client's developers can contact our development team to get
any information needed to make a change to the system safely.
We also recognize that people are going to be using the system. To even further reduce the risk, after a phase is complete
we can provide training to the people using the system, providing competent people that have an in-depth knowledge of the
system to train your employees.