## Shared Prototypes

Justinmind Prototyper allows you to share your prototypes with other people through your account. Sharing a prototype with other users will let you work on a prototype as a team, editing and sharing your changes with everyone. It is the best way to handle big and complex projects while saving time and increasing your productivity.

Prototypes’ editing permissions can be also managed in a simple interface, so a prototype’s owner will always have control over who’s editing his prototype,

With this feature you can also keep track of your prototypes’ history. Every prototype’s change uploaded to the server will be stored allowing you to restore your prototype’s state at a particular moment in time when you need it.

Notice that this feature requires an account. Connection to this online service is essential in every share operation. However, one may be able to work offline on a shared prototype and share the changes once connection is restored.

There are a few concepts the user must be familiar with in order to fully understand how to work with a shared prototype.

#### Key concepts

Shared Prototype: This is the name given to a prototype when it is already uploaded to the account and shared for edition. When a prototype is shared, it has some specific operations like ‘Commit changes’, ‘Update’, ‘Lock’ etc. which need Internet connection. Every shared prototype has a list of users who have permission to edit it.

Prototype users: There are some Justinmind users (who already have a Justinmind account) that can edit the prototype. They are invited to edit a prototype by the prototype’s owner.

Prototype owner: The prototype owner is the user who has uploaded and shared the prototype. As a user of a prototype, he can also edit the prototype but he also has some extra privileges:

- Can invite or uninvite users to edit the prototype.

- Can rename the prototype.

- Can delete de prototype from the server.

The owner of a prototype can be changed by the owner of the account where it has been uploaded.

Lock/Unlock: Locking an element allows you to reserve it so you will be the only one with permission to edit it until you unlock it again. Elements can only be locked by one single user.

Commit: This operation uploads all your local changes made on a shared prototype to the server.

Update: This operation downloads any changes made in the current shared prototype by other users.

Discard changes: This operation deletes your local changes and gets a new copy of the shared prototype from the server.

### Working on a shared prototype

When working on a shared prototype there are 3 basic operations you must fully understand: lock, commit and update.

The main difference between a non-shared prototype and a shared prototype is that in the latter, prototype elements (screens, templates, masters, etc.) must be locked before being edited. Locking an element is a basic operation to avoid conflicts in prototype modifications. Every user working in a shared prototype has his own locked elements and it guarantees that no one else can modify them. Just remember to unlock them once edited so other users can modify them if necessary.

When modifying elements of a shared prototype, all the changes are stored locally in your computer. It is not until you perform the ‘Commit’ operation that all these changes are uploaded to the server so everyone else can see them.

You also need to Update your prototype regularly in order to get all the changes uploaded by other users and be sure that you have the last version everyone is working on. However, update operation will be requested to you automatically if changes are found in the server.

### More about shared prototypes

- Workspace. Menus and buttons.

- General operations: Share and open a prototype.

- Prototype operations: Specific shared prototype's operations.

- Management: Rename, change owner or delete a prototype.

- Work offline: How to continue with your work offline.

- Exceptions.