vs. Microsoft .NET – a key component of the App Cloud – is the foundation for Salesforce applications like the Salesforce Sales Cloud. Salesforce has opened its technology foundation to all customers so that the tools which were used to create Salesforce applications are available to you. You can use the same tools to create your own applications. Think of as a complete general purpose application development framework – just like Java or .NET.

Customers have created applications on the platform across a wide breath of business requirements.

Comparing MVC model in & .NET


The application development environment can be understood better if we examine it from the perspective of a typical MVC framework. It also helps to examine this in relation to a traditional framework like .NET and compare how each layer – Model, View, Controller – stacks up.

For each of the three layers – model, view, controller – in there are two sets of development tool – declarative (point & click) and programmatic. Each of these tools are listed against the name of the layer in the diagram. For example, the data layer has objects in

Declarative is easier to build and maintain. For every part of application, ask yourself – can this be done with declarative instead of using the programmatic elements – for example: the Process Builder tool instead of Triggers, Validation rules instead of Apex. You will find that you need to code very little.

Remember the metedata driven approach means that you deal with abstractions of the traditional elements. For example, objects instead of RDBMS tables, UI components instead of HTML/CSS – and of course, no hardware or software.

Framework support for app development in – .NET &

Following information about the .NET scaffolding for the project is provided by Shane Long – expert .NET developer and architect:

.NET Framework

When starting a MVC project in .net, Visual Studio creates a scaffolding of the project (or a project structure). So you have directories for the views, models and controllers. So a model is a representation of the DB as a CRUD interface. Usually this is automatically created as a sync to the database tables. When you change the structure, the user can sync the model file and the new fields/tables are updated to the model. You can also manipulate the model at this level if you want tables abstracted to the application – many developers usually just leave this up to the controller level.

The Controller converts user responses to model-friendly queries. These are ‘special’ classes that reside in the controllers folder.
The View is the most interesting departure from forms-based .net applications. MVC views allow for greater use of markup in the page. Framework

In – there is no ‘scaffolding’ that needs to take place because that’s inherent in the force design.

The integrated nature of platform simplifies app dev such that even business analysts can do fairly complex tasks like ERD design, reports and workflow creation. These tools also help in very fast app dev.


The most amazing thing is that makes the process of developing extremely complex applications to be so easy and enjoyable. For many many applications you will find that it is almost 80% faster to build an application in compared to other platforms like Java & .Net.

One big reason is of course is the declarative framework – the point ‘n click tools make things so much faster; for example you have easy to use tools like the workflow process builder, schema builder, lightning connect and more.

However another even bigger reason for faster development in is the integrated nature of the platform. You don’t have to do any of the dev work which is painful – create mapping to the database, create security & single-sign on plumbing, build APIs, rely on external reporting tools or build user access control layers. When you create the objects, the UI – data entry forms, master-details forms etc. – is automatically generated without you needing to write a single line of code. This default UI – page layout – is good for 90% of the use cases, not to say that there are a huge number of pre-built application components and UI components to enhance your app – so you do even less coding. It’s really the fastest path from business requirements gathering to going live.

And finally of course you have absolutely no infrastructure worries – dev & test servers (called sandboxes) are automatically provisioned for you, your app can scale as users grow without you having to buy new servers, no need for performance tuning, data model optimization and indexing – all that is largely taken care of behind the scenes for you.

Let’s examine some of the salient multi-tenant cloud features of Multi-tenancy Architecture

At the heart of is a metadata driven architecture that enables multi-tenant
applications. Objects, (tables in RDBMS lingo), fields, stored procedures, and database triggers are
all abstract constructs that exist merely as metadata in’s Universal Data Dictionary (UDD).

Metadata based

Your application components (such as objects), aren’t modeled directly in the underlying relational database.

For example, when you define a new object does not create an actual table in a database. Instead, simply stores metadata that the platform engine can use to generate the virtual application components (objects or code etc) at runtime.

When you write Apex classes or triggers, compiles Apex code and stores it as metadata in the UDD. When you interact with your data in a application, the platform’s runtime engine materializes the data using metadata stored separately in’s Universal Data Dictionary (UDD). This way, each tenant’s data is kept secure in the shared database. Tenants can customize schema in real time without affecting other tenants’ data, and the application’s code base can be patched or upgraded without breaking tenant-specific customizations.

Transparent Upgrades

The unit tests you create are also stored in the UDD. Salesforce reruns the unit tests for every application with each development release of to proactively learn whether new system features and enhancements break any existing applications. The overall result is that platform can deliver three major releases every year while preserving all the customizations and code you have written. This ensures that the platform – and your application – is always current with technology – and remains capable of fully leveraging all the innovation happening all around the world.

Eliminating Runtime Errors

The metadata driven architecture also reduces runtime errors. Since the platform is aware of all metadata and maintains corresponding object dependency information for classes, it automatically validates all embedded SOQL and SOSL statements within a class to prevent code that would otherwise fail at runtime. At the same time uses this object dependency information to prevent changes to metadata that would otherwise break dependent code.

Polyglot Persistence – Global Search, Multi-Device Support, Multi-Language Support, Single API

Another innovative aspect of platform is how transparently integrates several different data persistence technologies – RDBMS transaction engine, In Memory Database (IMDB), Queues and Full text, Multi-lingual search engine – so that you don’t have to worry about the complexity of trying to manage these systems; and you only have to code to a single API. As an example, the applications you create work on all devices and you don’t have to worry about form factors and such. application environment includes both point and click tools as well as programmatic elements.

Your Project: A Three Step Process

You could approach app development project, as a 3 step process.

You would first examine your project requirements to see which are those parts which are best suited for point and click tools. For example, creating database objects, defining workflow rules and approval processes and user access control permissions are best done through point and click. The point and click tools – through the web based GUI interface also make it easy to visualize your application design.

In the next step, for those parts of your project which are difficult to accomplish through point and click tools, check out pre-built app modules on AppExchange – the repository of free and paid apps from Salesforce and ISVs. For example, you would find many ETL connectors which make it very easy to integrate App Cloud with applications like Oracle Fusion and Microsoft Dynamics.

And finally, you have the ability to use the programmatic elements of – Apex, Visual Force – to code your business functionality exactly as you need. For example with Winter ’16 release of Salesforce, you can get pre-built Lightning Components from AppExchange as well as create your own components for a modern UI.

In Conclusion

In summary I would say that both App Cloud & .NET are great technologies. There are many ways in which helps to make things easy for you – on the other hand there are many ways both .NET and can together form an integrated solution for your business.

Resources for .NET Developers – Hands-on Trailhead Tutorials

  Apex & .NET Basics

  Database & .NET Basics :