Top MuleSoft Projects for a Beginner Portfolio

The increase in the need for connectivity in enterprise ecosystems has turned MuleSoft into the most desirable platform for integration and API management in current IT architecture. As a new person in the field of integration development, a developer switching to middleware development or an academic hoping to get into enterprise jobs, the theoretical knowledge alone may not be enough to make an impression on potential employers in technical interviews. It can be confirmed that the newly recruited software architects were knowledgeable about architectural aspects and good at dealing with APIs, exceptions, and messaging. The attendance in the mulesoft developer training will definitely help to fill up this gap.

With several scoped and realistic MuleSoft projects in your pocket, you would find it easy to bridge the gap between theory and enterprise engineering. It would add to your portfolio and it would be evident that you can do much more than simply drag-and-drop in Anypoint Studio.

The following article is a comprehensive guide to MuleSoft portfolio projects for beginners.

The Architectural Foundation: Introduction to API-Led Connectivity

Prior to moving on to the implementation of any project, all new comers should know the difference between the architect at MuleSoft developer and the regular integration engineer as well as the differences between those two which are API-Led Connectivity. In MuleSoft, there are three architectural layers that differ from each other and are reusable:

Firstly, the System APIs layer is the top level access layer. The System APIs layer is situated just above the core systems of record like databases, legacy ERPs, mainframes, or cloud software platforms. It abstracts the schema of the underlying system, abstracts the protocol changes for the downstream consumers and creates standard data models for the whole enterprise.

Secondly, the Process APIs layer is situated and called also the business logic layer. Process APIs attempt to integrate, aggregate, filter and orchestrate the information obtained through one or more System APIs. For example, when one wants to make an order, he or she should obtain information about the customer, verify inventory, estimate the shipping cost, and warehouse the product.

Moreover, Experience APIs have unique endpoints specific to each individual client where a mobile app, an internal portal of a call center, and an external partner from the business to business point of view, each one of them consuming customer profile data, but the payload, security, and bandwidth optimization would differ between clients. The Experience APIs make changes to the data in accordance with the format with which it needs to be consumed from the respective digital channel.

But what is really very important here is that you should have covered all the three layers in your portfolio project structure. In case you face any problem in structuring RAML specification or making the three-layered architecture for your API, you must consider joining mulesoft developer course online.

Project 1: Multi-source Customer 360 Aggregator

Business Problem

These days, organizations find themselves struggling with fragmented data of their customers from legacy applications, relational databases containing billing data and customer relationship management system software as a service. The support team has to login to multiple portals to view the account information.

Architecture Solution

In this particular project, the main focus is on building customer profile aggregator solution providing endpoint consumption experience that would consume account id, retrieve data from multiple downstream sources, fragment profiles and give consolidated customer profiles.

MuleSoft Concepts Discussed

• RAML specification development via Anypoint Design Center.

• Scatter-Gather method for collecting the data in one go.

• Data transformation and normalization via DataWeave.

• Connectors for communicating with databases, HTTP requests, and RESTful services.

• Error handling when partial operations do not succeed.

Strategy of Implementation

First of all, we should create an API in RAML. The corresponding types should be used to represent the parameters of the request, and the correct JSON schemas for data pieces and output data should be designed.

Next, we should simulate the backend systems in Anypoint Studio. The first one could be a database where all the contacts will be stored, while the second one is a third party billing system giving us information about the payments and lifetime value.

Using the Scatter-Gather component, we collect the data from both endpoints simultaneously. Since latency often poses a problem in the enterprise-level environment, this technique helps us increase the response speed.

The success of the whole project rests solely upon you due to the DataWeave transformation layer, which will require mapping of field names, converting of dates, handling of nulls, and aggregation of contact information into JSON response.

If you need to create enterprise-ready project, then it should have partial failure handling mechanism in its project design, so that even in case of timeout or billing service failure, the aggregator returns customer contact information with a status message saying that billing information is not available.

Project 2: Asynchronous e-commerce order processing pipeline

The business problem

Processing of too many transactions synchronously is harmful for the application, since in case of a failure at payment gateway or warehouse management system, the customers would have to wait infinitely, leaving the cart and creating duplicate orders.

Architecture Solution

Develop an order processing application by utilizing a design pattern wherein the web-order request is validated, and enqueued in the enterprise messaging queue instantly. The workers will pick up the message from the queue, process the order requests through invoking mock inventory and shipment service, manage failures and messages which have failed are published to the Dead Letter Queue (DLQ).

MuleSoft Concepts Applied

• Asynchronous Decoupling with the help of Anypoint MQ / ActiveMQ (JMS)

• Routing using Choice Routers & Content Based Routing

• Dead Letter Queue & Poison Message Handling

• Transaction, State Management & Idempotence

• Error Handling using the Application

Approach for Implementation

First step is to develop an Order Ingestion API. Once the order is received, the order payload should be validated to check whether all required fields such as product Ids, customer Ids are valid or not. Rather than processing the order request in synchronous manner, the order payload should be enqueued and send HTTP Accepted response to the calling application.

Now, we can proceed with creating a concrete consumer flow, which will be triggered by the queue listener. In the consumer flow, we get the message from the queue, log the transaction ID and analyze orders via Choice Router. Orders, which have to be processed as express orders, will be directed to appropriate fulfillment flow, while other orders will go to standard queue for processing.

The ability to handle errors is an essential component of the consumer flow. In case of any kind of temporary errors like loss of connection with the fulfillment endpoint, you can create a policy for message redelivery with exponential backoff technique. And in case the message received contains errors in its body, then direct the message to Dead-Letter Queue.

Project 3: Batch File Synchronization and Data Cleansing

The Business Problem

Despite the development towards API integration and its real-time nature, there are still many businesses like finance, logistics, insurance, and retail, which use the technology of batch scheduling and transfer of flat files. Inventory updates, price sheets and payroll files are uploaded on a daily basis into file servers in CSV or delimited text formats.

Architecture Solution

Design a batch processing architecture where the solution would have a periodic polling of SFTP or file system, read large delimiters, clean and validate data record by record, perform data transformation, and do a bulk upsert operation in the relational database, separating out the invalid data to be included in the error report.

MuleSoft Principles

• Use the principles of MuleSoft Batch Processer (Batch job, Batch Steps, and Batch Aggregator components).

• Use Polling watermark using SFTP and file connectors.

• Perform Data cleansing and conversion (CSV, JSON, and SQL records) and validation.

• Manage memory limitations using streaming.

• Use Notification and processing statistics for automation.

Blueprint Architecture

Set the Scheduler or SFTP Listener component to periodically poll the incoming directory with the inventory files in a non-blocking way, which can run on tens of thousands of rows in memory.

Deliver the payload to the Batch Job component. Structure the batch process into the following stages:

• Validation Stage: Verify that the records have passed the validation process. The process should validate that the price is numeric and is a positive number; that the product codes match the regular expressions requirements; and that the description is present where it is required. Send invalid records to the error list.

• Transformation Stage: Enhance the validated records using DataWeave, update the tax calculation formula, transform the currency code to a standard format, and create records in a format suitable for insertion in a database.

• Aggregation Stage: Use Batch Aggregator to logically group the records into batches (for example, hundreds of records per batch); insert and update records in the database in a batch mode without creating thousands of database transactions.

On completion of the batch process, calculate the number of records and writes and notify.

Project 4: Enterprise Webhook Ingestion and Notification Engine

The Business Problem

Modern architecture implies the transfer of the messages through the push notifications channel not only by the notification system but also by the payment gateways, code repos, CRM updates, shipping service, and many others. The integration of those external webhooks requires handling the issues of high availability, message authenticity, and dynamic routing to the internal message channels such as enterprise chat channels and customer SMS channel.

Architectural Solution

Deploy the lightweight Webhook Dispatcher service that receives the events from the external services, validates senders of those events, transforms them into the internal notifications, and routes these notifications to the target message channels.

Core MuleSoft Concepts to be Covered

• Webhook and validation of HMAC SHA256 signatures.

• Routing and headers manipulation.

• Consuming REST API from the external services using token-based authentication.

• Property management and credentials encryption.

• Fast payload transformation.

Implementation Plan

The core functionality of your solution should be the public webhook endpoint. Since the webhook endpoint will be accessible over the open internet, the security is your primary issue. You should receive the digital signature from the sender, calculate the HMAC hash of the incoming payload, and compare them.

After the payload validation process, it is necessary to give priority to the event type in the payload. Utilize the Choice router to determine the type of event:

• If the critical alert events happen (for example, failures in the credit card charge or system critical alerts), convert the payload according to the enterprise chat notification format and conduct an HTTP request to the enterprise communication webhook.

• As far as business events are concerned (for example, successful account upgrades), utilize the payload in order to update the internal audit database with the data.

• It is important to provide a prompt response to the webhook sender to avoid duplicating the payload, but your internal notifications can be conducted without any trouble.

Project 5: External B2B Partner Onboarding Portal API

The Business Problem

While onboarding external corporate partners, suppliers or distributors, enterprises must not allow any external systems to connect to their internal services directly. It is necessary to establish a reliable API gateway layer that will identify the client, monitor their activities, restrict aggressive clients and validate business payloads by compliance contracts.

The Architectural Solution

Establish the Experience API layer for external B2B partners.

Concept of MuleSoft Involved in This Task

• Use of RAML with the use of reusable traits, resource types, and libraries.

• Enforcement of API manager policies that includes Rate limiting, spike control, and client ID enforcement.

• Authentication via OAuth2 with token validation and Basic authentication.

• Custom error formatter based on the enterprise problem specification format.

• Functional testing and unit testing using Munit.

Blueprint Implementation

Creation of a blueprint of RAML based on RESTful approach. Use of traits in RAML design in order to maintain consistency in the use of query parameters such as limit/offset as well as HTTP header such as credential and identifier of the clients.

Using Anypoint Studio in designing flow architecture using APIkit router. Creation of a flow of mock routing and querying catalog details and stock of the partners.

Unique Selling Point (USP) of this portfolio item is governance and resilience. Policy design in your application in order to enforce the client credentials and rate limitation. In case of any unauthorized partner accessing the application, show a standard error message.

In addition to that, make MUnit test cases for the project. Create test cases that validate that a valid request leads to a proper response, no header leads to validation error, and a downstream mock error leads to the correct HTTP status codes.

Leveling Up With Your Portfolio: Best Practices For Making Recruiters Take Notice

Completing the projects mentioned above will enable you to acquire some good technical skills. Nevertheless, it is the way you present the projects that makes the difference between your portfolio being good or not.

Project Naming and Organization

Projects in an integration should be created in a way that allows another developer to maintain it within a large development team environment. Do not use flow1 as names of your flows or HTTP_Request_Configuration as names of the default connectors. Instead, use naming schemes like:

• Name them based on the domain and the functionality of the process like post-orders-process-flow and get-customer-by-id-system-flow.

• Configure the settings by putting them into individual XML files in the following order: global configurations, error handlers, and functional flows.

• Dataweave transformations need to be put into separate files that have the dwl file name extension.

Global Exception Handling

Beginner level projects use default exception handling techniques that include printing the Java stack trace in unformatted way on the client side. Professional projects utilize exception handling techniques consistently. Develop your own Global Error Handler that will handle exceptions in professional way as follows:

• Handle the schema validation exceptions and translate them into client-side exceptions.

• Handle connectivity exceptions and translate them into gateway timeout exceptions.

• Create the general handler function that will handle unexpected exceptions and convert them into proper exceptions with correlation id.

• Architectural Descriptions Diagrams and Walkthrough Document

When preparing your solution for deployment on GitHub:

• Write a comprehensive README that includes the description of the business logic and architecture decisions.

• Write a walkthrough document describing the processing of the request and response.

• Describe how to configure your project in terms of environment variable settings and testing procedures.

Support All Projects with MUnit Tests

Nothing could be better than having automated tests in your application to prove production readiness. The development team at MuleSoft always supports those developers who can create proper tests for their applications through Munit. For all your projects:

• Write unit tests for happy paths and error cases.

• Use the Munit processor to mock database connections and HTTP requests.

• Ensure maximum coverage of your scripts and decision making process.

Portfolio Project Check List

Once all the five projects below are completed by you, then you would have formed a portfolio that can be considered as an encompassing portfolio with respect to Enterprise Integration:

• Multi-Source Aggregator: Includes RAML API Creation, Parallel Routing, and DataWeave Schema.

• Order Processing Pipeline: Focuses on Asynchronous Message Processing, Queues, Dead Letter Routing, and Resilience.

• Batch File Synchronization: Includes Big Data, Streaming Processing, Validation, and Batch Processing.

• Webhook Notification Engine: Includes Security Validation, Event-Driven Messaging Processing, and Fan-Out Processing.

• B2B Partner Portal: Includes API Governance, Rate-Limiting, Client Validation, and Munit Testing.

This will play an important role in helping you convert your theoretical knowledge into practical understanding about MuleSoft. In order to make sure that you increase your project experience in the industry with credible credentials through your portfolio, getting mulesoft certification training with OnlineITGuru along with your portfolio will play an important role for you.