Our architecture

Where the magic happens

This is the part of the website where we talk about all the technical awesomeness that underlies the Peach platform. We've built a powerful engine that handles the most difficult parts of building restaurant applications, enabling any developer familiar with modern web development tools (JavaScript, HTML5/CSS, AngularJS) to quickly build powerful, integrated apps. If you're on this page, you're probably as into this stuff as we are (and we love it almost as much as we love helping run restaurants better!), so let's dive into the details:

Cloud Data Engine

The center of all the action, the Peach cloud data engine holds all of the application data objects. It provides two core pieces of functionality that underlie all the data that your restaurant management applications use:

Authentication and Authorization: Each application defines the data objects to be used and creates permission groups to control the reading, creating, updating and deleting of objects. Permissions are even detailed enough to control the reading and writing of individual object fields. The system uses these permissions to control authorization, and the OAuth 2.0 protocol for authentication of every user/request.

REST API Access: Every object is accessible via a REST API and can return JSON or XML responses. The API is highly structured and standardized. All objects have several parameter options available to filter the results, allowing for a great amount of flexibility. This API-first approach ensures that your API will always expose all the data in your application, allowing easy export or integration to any other system that you might use.

In addition to the underlying data structures, the platform provides a number of useful ways for developers to work with their data in the background:

Bulk Data Operations: Applications often need to create, update or delete dozens (or even hundreds) of objects at one time. Peach provides methods to perform these bulk operations in both atomic (everything fails or everything succeeds) and non-atomic methods (data than can be saved is saved, errors are reported for failures).

Triggers: Peach provides application developers with an opportunity to run server-side JavaScript code for every API method request. This can be used to perform additional security validation, to write the submitted data to additional objects in Peach, or even interact with external systems via their API's. Send or receive data from your account on Salesforce.com, from one of your other vendors, or even from your own legacy systems.

Tasks: Application tasks that need to be run on a schedule (which could be hourly, daily, weekly, and/or ad-hoc). A Task is simply a JavaScript function which – much like a trigger – can interact, validate, and manipulate any data object in Peach, or access external systems.

Analytics Engine

What's the point of having all that data if you can't use it to make decisions? No data engine would be complete without an analytics engine to sit on top of it, to turn the data into information. The Peach Analytics engine was built with a focus on flexibility, performance, and usability. We have developed the "Peachworks Analytical Query Language" (PAQL) to allow app developers to easily access their data request.

Defining the Metrics and Dimensions: Because all of the application objects are already defined in the data engine, we leverage that information to identify the dimensions and metrics – and construct the relationships between the two for the data - without any developer work. Having this information built-in provides a definite deployment advantage over dedicated data warehousing systems, and enables easier ad hoc reporting by end users.

Building the Query:Our report builder uses a clean and simple user interface to walk someone through the process of creating a report. First they pick their metrics, then their dimensions, then they apply any filters to the metrics and/or dimensions.

Visualizing the Data: The data can be visualized in a pivot table or any number of charts or graphs. This visualization can be exported, placed on a user's dashboard, or shared with other apps, such as the PeachWorks Team application.

Alerts and notifications

The Peach alerts and notifications system allows users to be notified with important information, or even an actionable task. All applications feed into the same alerts queue, so the users have just one place to look for all of their important information.

User Personalization: Every user has the option to personalize their user profile, to change the ways they would like to be notified for each type of alert. First they can enable or disable each alert. Then each enabled alert has the option to be delivered to the user inside Peach, by email, and/or by text message.

Informational vs. Actionable Alerts: Alerts come in two flavors – informational and actionable. Informational alerts are messages that appear in a user's alert queue until they are read. Actionable alerts require a user to "take action" on the alert. The alert may go out to several people, and only one person will be required to take action on it (and the others will be notified that someone else has acted upon it).

Designing alerts: Alerts are sent out based on a request from a JavaScript function that is either run periodically by a Task or is set to watch for new objects or a changes to existing objects. The function, like any other function, can also look at other data objects or objects from external systems to makes its decision, providing maximum flexibility and power for developers.

Presentation Engine

As we discussed earlier, it's all about the interface - connecting people to their data. Peach has made building the user interface for an application easy. Our presentation engine is built on top of a JavaScript framework called AngularJS. Peach handles all of the server-side functionality, leaving developers to focus solely on building the user interface pages in their application. Each pages automatically shows up in the navigation for the application and consists of two parts:

The Controller: Written in JavaScript, the controller's basic function is to send and receive data for the application via the API and handle any front-end business logic. The controller uses a Peach API module to make the API calls for the developer. The API module handles the HTTP method calls, OAuth 2.0 token management, API versioning, and the account IDs transparently.

The Template: Written in HTML5, the template provides the application view to the user. The template is aware of the user's permissions and can customize the view accordingly. The template is also aware of the user's device size, and will alter the view dynamically. The presentation engine provides many shortcuts and macros to make building forms, tables, and grids painless. We have also defined all of the CSS to make your pages look and feel like everything else in the platform.

Mobile

We live in a mobile world. Everyone has a device and we believe they should use it. So, we've made it incredibly easy for your development team to build mobile restaurant management apps:

Multi-Channel: Build one application, and you can deploy apps across iOS, Android, and the web.

Ready-to-Use Components: We provide access to Angular Material (https://material.angularjs.org), as well as stylized UI widgets to enable you to easily provide the same look and feel in your apps as the rest of the Peach platform. All of these components are designed to be responsive and suitable for use on mobile devices, so you don't have to worry about touch zones or readability.

Instant-Deployment: Apps built using the Presentation Engine will run immediately in the PeachWorks mobile app, so you don't have to deal with getting your app updates into the Apple App Store or Google Play.

DIY: And if you don't want to use our app, you can also use the Peach platform as a backend for your own apps, accessing any and all of your data through our API.

Extensibility

A tremendous benefit of the modular approach to application development in Peach is that extending existing restaurant management applications becomes possible. There are a wide variety of approaches that you could take to extend and enhance existing applications. Here are some of the more common ones:

Renovation: Like the basic functionality and data structure available, but have a different preferred interface for some part of an application? It's easy to simply hide a portion of an app's UI and replace it with your own to get exactly the feel and functionality you want.

Addition: Like everything that an app is and does, but you need to add something additional like a proprietary workflow or data source? No problem. You can just build a "mini-app" to handle your particular need and tie it to the core app, resulting in a single, seamless view for your users.

Greenfield: Starting from the ground up, you can build any application you want, just the way you want it. And you automatically get all the benefits of the platform - integration to your POS or other apps, a mobile version of your app automatically generated, an API wrapper to expose all of your data objects for other integrations, our great reporting engine, stability, security, and more! And your users will see it all in the same window and with the same interface as all of your other applications, dramatically reducing their learning curve.