GenericFrame is a software prototyping tool. It enables you to create interactive prototypes without any technical skills needed. GenericFrame comes in two editions: Online and Desktop.

Online Edition

GenericFrame Online Edition needs no download, installation or setup. You have access to your projects anywhere at any time. The Online Edition comes in a free version and a Pro version. For your convenience you can activate the Pro version only for the months you actually need it. See pricing options for more details.

Desktop Edition

GenericFrame Desktop Edition gives you the flexibility to use the software even if you are not online. You can save your projects directly to your hard drive. The Desktop Edition comes in free and Pro version as well. See pricing options for more details.


GenericFrame is useful for medium and large software projects. For complex applications a high fidelity prototype can be used to demonstrate even the most complex business logic, screen flow or process. With GenericFrame you can verify requirements in early project stages via visual prototypes (we call it the "visual specification"). This is very important because users usually verify process and requirements only after they see and test the real software or a prototype very close to the real system.


When working on complex projects it is hard to verify all detailed requirements and exceptions. It is even harder to communicate this details and exceptions with users. Quite often these exceptions and missing details appear on a later stage when users start using the software. Solving this problem costs additional money and time. With GenericFrame you can build a prototype and actually demonstrate the future software system to the user. It is not only a static screen presentation. The user can get a training and try the system for him self. After understanding how the software will work. The user is confident that the software will fulfill its goal and can move on to thinking about all the details. Which are extremely important to be "discovered" in the beginning of every software project.

Thoughts on...

On a higher-level the users focus on main business processes and often ignore "small" details. But for a software engineer the "small details" are as important as the main functionality. This fact often makes software estimation very difficult. This is why in the last years the iterative and agile methodologies have gained more and more popularity. But these methods have their challenges - they make the budgeting of software projects even harder due to unknown number of iterations needed. Also they do not solve the problem completely, because every single iteration shows a small bit of the software and not the whole system. In this case the problematic "small details" may remain hidden resulting in costly changes later in the software project.

Higher Fidelity

These issues can't be spotted via low-fidelity prototypes or text specifications, which show the main layout concept and do not simulate interactive functionality. Writing the wrong requirements means wrong estimation, costly changes and finally failed projects. On the other side a high fidelity prototype simulates the screens flow, all the screen elements like buttons, forms, popups etc. the way they will work and behave in the real application.

Verify it before you build it

GenericFrame helps verifying that the future software really solves the main problem and is not too complex to be used by the users. Sometimes when the application is more complex and the users are not tech savvy, making some pieces of the software dynamic or pseudo dynamic can really help. Complex pieces of the software are made dynamic and functionality is simulated with basic developing skills using GenericFrame. Programming the dynamic parts can be done even by developers with little experience because they don't need to meet high scalability, security and technology standards. With GenericFrame it is possible to develop dynamic parts in any web technology (HTTP).

Reuse your prototypes

Dynamic prototypes can later be reused for developing business applications using any common platform (Java, .NET, PHP, Ruby). The visual editor and the prototyping like development style make changing details easy and smooth. Many of these changes don't require any programming skills. Making changes in either layout or backend code is done easy and loosely coupled. With GenericFrame software can be developed in multiple phases (cycles), through numerous iterations without defining all the details from the very beginning. This is a simple and effective way of developing, because it follows the natural evolution of the clients thoughts and requirements.

GenericFrame is the best tool when you need to demonstrate your ideas in the early stages of a project. Use it to create high-level visual prototypes quickly and without writing a single line of code. Building a prototype is easy and simple.
  • add components (Text, Input, DataGrid...)
  • organize the layout in containers for horizontal and vertical layouts, tile layout
  • nesting containers
  • style components (edit properties of the components like font, color, size, data)
  • create multiple-view prototypes
  • add links between views for navigation
  • import / export projects & templates

A visual prototype coming along with your sales proposal will increase the understanding of the customer about the offering, thus increasing the chance to promote your idea or even close the deal.

You can test your ideas with users and find significant issues, saving you time and money by verifying the value creation in the very beginning.
Once your idea has proven it is worth the effort, you may want to create a detailed prototype (for example including all screens, all buttons and components, and navigation).

This way you will be able to:
  • verify the requirements
  • demonstrate proof-of-concept
  • test and train the users
  • test different scenarios and workflow
  • extend the technical specification with a clickable prototype
  • create more precise estimations
  • communicate features, requirements and workflows much easier

Even the best idea may fail because of poor execution (lack of analysis of the details and communication problems). Communication of even a simple software system may result in a multiple and larger technical documents which are not easily understandable for non-developers. By using GenericFrame prototypes you are able to:
  • Demonstrate (not explain) how detailed processes will be transformed into screens and whether all details are defined correctly. Often even the most professional and detailed specification is not enough for non-technical users to get the "big picture". The user level of understanding about the details remains low and incomplete. Users see a very detailed and well structured document and think: "It looks so professional, , it must be right". Thus, the best way to communicate the idea is by presenting a prototype. Even better let the users try for themselves - from the first step to the last one.
  • Test and optimize the effect of UI design on customer satisfaction - sometimes new systems promise to solve problems, but bring a new type of complexity in users lives. It is best to make sure up front that the future system will not be too complex for the users. Encouraging involvement of users in early stage makes them co-creators and minimizes the risk of a negative attitude or refusal to adopt changes.

GenericFrame allows you to start the design process with the client right off, based on the high-level prototypes created during the initial (sales) phase and grab their attention from the start. It helps establish clear communication and sets the right expectations.

Everyone who is involved in the project will actually be able to experience and see in action what the new system is and how it will perform.
Sometimes a static prototype is just not enough. Users need to see real data and working functions to be able to fully verify what they really want.
The challenge is that different users can handle different level of abstraction. A very experienced user would understand a high-level prototype showing just the concept and leaving a big room for interpretation.

Most users will need to see the buttons labels and screen flow. They will ask what exactly would happen if they click "Preview Offers". Some users (with basic computer skills) will need to see their real data on the screen, so they can associate the prototype with a real situation. They may complain that last weeks orders are not displayed and that it is "not working".
In such cases it is best to make a real working prototype, showing real data and simulating the real system.
The question is "won't it take the same time and investment to build a working prototype as building the whole system". The answer is NO - with GenericFrame you can build a working prototype faster with a very tiny budget.
Creating a simulation (a dynamic prototype) is much easier and less complex than with any other web-technology.

GenericFrame lets you complete an idea's full life cycle - from the first scratch to a dynamic prototype where needed.
Developers can use the prototypes from the previous two stages (or create new ones from scratch) to build a dynamic prototype or a web-based app within days using GenericFrame only.
Our system will integrate seamlessly at any stage of your project. You can easily connect GenericFrame to any popular backend - PHP, Java, Ajax, RonR, .Net. Add new functionality to build high fidelity prototypes and applications so you can start marketing your product even if you haven't built it yet.