WhatsApp Campaign Manager Practical Exercise Evaluation

Nov 1, 2025 by SLV Team 56 views

Hey guys! Today, we're diving deep into the evaluation of a practical exercise focused on a WhatsApp Campaign Manager. This is a crucial discussion, especially if you're building marketing automation tools or just keen on understanding software project assessments. Let's break it down!

Discussion Category: RASOLOFONARIVO, campaign-manager

Additional Information:

Evaluation Date: November 1, 2025
Exercise: MVP of WhatsApp automated marketing campaigns module
Expected Duration: 4 hours
Final Score: 68/100

📊 Evaluation Summary

First off, let's glance at the overall evaluation summary. It gives us a bird's-eye view of how the project performed across different criteria.

Criteria	Weight	Score Obtained	Grade
Architecture & Code Quality	30%	22/30	73%
Functionalities	25%	18/25	72%
Asynchronous Management	15%	11/15	73%
Tests	15%	6/15	40%
Documentation	10%	7/10	70%
Bonus	5%	4/5	80%

1. Architecture & Code Quality (22/30) - 73%

Architecture and code quality are super important for any project, guys. They determine how maintainable, scalable, and readable your code is. In this case, we scored 73%, so let's see where we shined and where we could've done better. This section delves into how well the codebase is structured, the coding practices followed, and the overall design of the application. A strong architecture ensures that the application is not only functional but also easy to maintain and scale in the future. Code quality is assessed based on adherence to coding standards, readability, and the use of best practices.

✅ Positive Points

Code Structure (8/10)

The Laravel and Vue.js structure is well-organized, separating the backend and frontend effectively. This separation is crucial for maintaining a clean and manageable codebase. It allows developers to work on different parts of the application independently, reducing the risk of conflicts and making debugging easier. Plus, it adheres to modern web development principles, making it easier to scale and update the application in the future.
The project respects naming conventions (PascalCase for components, camelCase for methods), which is fantastic. Following naming conventions makes the code more readable and understandable. It helps developers quickly identify the purpose and scope of different elements in the code, leading to fewer errors and faster development times. It's like having a consistent language throughout the codebase.
Clear separation of responsibilities (Controllers, Models, Jobs, Services) is evident. Separating concerns is a fundamental principle in software engineering. It means each part of your application has a specific job and doesn't meddle with others. This makes the code easier to test, modify, and extend. For example, Controllers handle the application's logic, Models interact with the database, Jobs manage asynchronous tasks, and Services encapsulate business logic.
The use of the Composition API for Vue 3, as requested, is a big win. The Composition API is a powerful feature in Vue 3 that allows for more flexible and reusable code. It enables developers to organize code based on logical concerns rather than component options. This leads to cleaner, more maintainable components and better code reuse, which is essential for building complex applications.

Files Concerned:

backend/app/Models/Campaign.php:1-29
backend/app/Models/Customer.php:1-28
backend/app/Models/CampaignMessage.php:1-29
frontend/src/components/CampaignForm.vue:61-133
frontend/src/components/CampaignList.vue:30-52

Eloquent Relationships (4/4)

Relationships between models are correctly defined, awesome! Eloquent, Laravel's ORM (Object-Relational Mapper), makes it easy to interact with databases. Defining relationships between models (like campaigns, customers, and messages) is crucial for data integrity and efficient querying. These relationships allow you to easily fetch related data, like all messages for a campaign or all campaigns for a customer, without writing complex SQL queries.
Appropriate use of belongsTo and hasMany relationships is observed. belongsTo and hasMany are two of the most common relationship types in Eloquent. belongsTo defines a relationship where one model belongs to another, while hasMany defines a relationship where one model has many instances of another model. Using these relationships correctly ensures that data is consistent and easy to manage.
Automatic casting of JSON tags in the Customer model using Attribute is slick. JSON (JavaScript Object Notation) is a common data format for web applications. Automatically casting JSON data into PHP arrays and back makes it easier to work with in the application. Using Eloquent's Attribute casting feature simplifies this process, making the code cleaner and less error-prone.

// backend/app/Models/Customer.php:21-27
public function tags(): Attribute
{
    return Attribute::make(
        get: fn ($value) => $value ? json_decode($value) : [],
        set: fn ($value) => is_array($value) ? json_encode($value) : $value,
    );
}

Transaction Management (2/2)

The project uses DB transactions for campaign creation, which is super professional. Database transactions are essential for maintaining data integrity. They ensure that a series of operations are treated as a single unit. If any operation fails, the entire transaction is rolled back, preventing partial updates and ensuring that the database remains in a consistent state. This is particularly important when creating campaigns, which may involve multiple operations across different tables.
Error handling with try/catch blocks is implemented, which is fantastic for robustness. Error handling is crucial for building reliable applications. Using try/catch blocks allows you to gracefully handle exceptions and prevent the application from crashing. This is especially important in database operations, where errors can occur due to various reasons, such as invalid data or network issues.

// backend/app/Http/Controllers/CampaignController.php:32-39
DB::beginTransaction();
try{
    $campaign = Campaign::create($data);
    DB::commit();
} catch (\Exception $e) {
    DB::rollBack();
    return response()->json(['error' => 'Erreur lors de la création de la campagne.'], 500);
}

❌ Negative Points

StoreCampaignRequest Not Used (-4 Points)

The StoreCampaignRequest.php file exists but isn't used correctly, which is a bummer. Form requests are a powerful feature in Laravel for validating incoming data. They provide a centralized way to define validation rules and handle authorization. Not using them correctly means you're missing out on a key feature that can simplify your code and improve security.
The authorize() method returns false (line 14), effectively disabling authorization checks. Authorization checks are crucial for securing your application. They ensure that only authorized users can perform certain actions. Disabling these checks can leave your application vulnerable to attacks.
No validation rules are defined (line 24). Validation rules are the heart of form requests. They define what data is allowed and what isn't. Without these rules, your application is susceptible to invalid data, which can lead to errors and security vulnerabilities.
Validation is done directly in the controller instead of using the FormRequest. This is a missed opportunity. Form requests are designed to keep validation logic out of controllers, making them cleaner and more focused. Doing validation in the controller clutters the code and makes it harder to maintain.

Impact: Lack of adherence to Laravel best practices for validation. Using FormRequests centralizes validation logic, making it easier to maintain and test. It also promotes cleaner controller code.

Conventions Partially Respected (-2 Points)

Variables named $r instead of $request in CampaignController (lines 17, 23). Consistency in naming is key to code readability. $request is the standard name for the request object in Laravel controllers. Using $r instead can confuse other developers and make the code harder to understand.
Lack of explanatory comments in some complex parts of the code. Comments are essential for explaining complex logic and making the code easier to understand. They're like roadmaps for your code, helping other developers (or your future self) navigate and modify it. Without comments, it can be hard to grasp the purpose and functionality of certain code sections.
No strict typing of parameters in several methods. Strict typing is a feature in PHP that allows you to specify the data type of method parameters and return values. This helps catch errors early and makes the code more predictable. Not using strict typing can lead to unexpected behavior and harder-to-debug code.

No Repository Pattern (-2 Points)

Business logic is directly in the controllers, which isn't ideal. The Repository Pattern is a design pattern that separates the data access logic from the business logic. This makes the code more modular, testable, and maintainable. Putting business logic directly in controllers makes them bloated and harder to test.
This makes it difficult to test and maintain in the long term. Testing controllers with complex business logic can be challenging. Without the Repository Pattern, you have to mock the database interactions directly, which can be cumbersome. Maintaining such code becomes difficult over time as the application grows and changes.

2. Functionalities (18/25) - 72%

Next up, functionalities! How well does our WhatsApp Campaign Manager actually do its job? Let's see what's implemented and what's missing. This section assesses the breadth and depth of the implemented features. It looks at whether the core functionalities are in place and how well they perform. Features are evaluated based on their completeness, accuracy, and adherence to the project requirements. Let's dive in!

✅ Implemented Features

Backend (13/17)

1. API Authentication (3/3)

✅ Laravel Sanctum is configured, which is excellent for API security. Sanctum provides a lightweight authentication system for SPAs (Single Page Applications) and mobile applications. It uses tokens instead of sessions, making it ideal for APIs. Configuring Sanctum is a crucial step for securing your application's API endpoints.
✅ Routes are protected with auth:sanctum middleware, ensuring only authenticated users can access them. Middleware acts as a gatekeeper for your application's routes. auth:sanctum middleware ensures that only requests with a valid Sanctum token can access protected routes. This prevents unauthorized access to sensitive data and functionality.
✅ A seeder for a test user (test@example.com) is included, making testing a breeze. Seeders are used to populate your database with initial data. Including a seeder for a test user makes it easy to test the authentication functionality without having to manually create a user. This saves time and effort during development and testing.
✅ AuthController with login/logout/register functionality is present, covering the basics. An AuthController typically handles user registration, login, and logout functionality. Having these features in place is essential for any application that requires user authentication. It provides a standardized way to manage user sessions and credentials.

2. Data Model (4/4)

✅ The customers table has all the required fields (phone, first_name, last_name, email, JSON tags). A well-defined database schema is crucial for data integrity and efficient querying. The customers table should contain all the necessary information about your customers, such as their phone number, name, email, and any tags or categories they belong to. Having all these fields in place ensures you can effectively manage and segment your customers.
✅ The campaigns table includes all the required fields (user_id, name, message, status, scheduled_at). Similarly, the campaigns table should have all the information about your marketing campaigns, such as the user who created the campaign, its name, message content, status (e.g., draft, sending, completed), and scheduled send time. This table allows you to track and manage your campaigns effectively.
✅ The campaign_messages table has all the required fields (campaign_id, customer_id, status, sent_at, delivered_at). This table is essential for tracking individual messages sent as part of a campaign. It links each message to a specific campaign and customer, along with its status (e.g., pending, sent, delivered, failed) and timestamps for when it was sent and delivered. This detailed tracking allows you to analyze the performance of your campaigns.
✅ Migrations are correctly defined, ensuring database schema changes are managed effectively. Migrations are like version control for your database schema. They allow you to define database table structures and changes in code, making it easy to track and apply schema updates. This is crucial for maintaining consistency across different environments (e.g., development, staging, production).

3. REST API (4/6)

✅ GET /api/campaigns - Lists campaigns with pagination, which is great for handling large datasets. Pagination is essential for APIs that return large lists of data. It breaks the data into smaller chunks, making it easier to manage and improving performance. The GET /api/campaigns endpoint should support pagination to allow clients to fetch campaigns in manageable chunks.
✅ POST /api/campaigns - Creates a campaign, as expected. This endpoint is used to create new campaigns in the system. It should accept the necessary data for a campaign (e.g., name, message, target audience) and create a new record in the campaigns table.
✅ GET /api/campaigns/{id} - Shows details of a specific campaign. This endpoint retrieves detailed information about a specific campaign, identified by its ID. It's used to display campaign details to users, such as its status, message, and target audience.
✅ GET /api/customers - Lists customers, allowing for easy management of contacts. Like the campaigns list, this endpoint should support pagination for large customer datasets. It allows clients to fetch customer information, which is essential for managing and segmenting your audience.
✅ POST /api/webhooks/whatsapp - A functional WhatsApp webhook endpoint is set up, fantastic! Webhooks are used to receive real-time updates from external services, like WhatsApp. This endpoint should be configured to receive messages and delivery statuses from WhatsApp, allowing your application to track message delivery and handle incoming messages.
⚠️ POST /api/campaigns/{id}/send - Route defined but not used (-2 points). This is a critical miss. This endpoint should be responsible for triggering the asynchronous sending of a campaign. Not using it means campaigns are being sent immediately upon creation, which isn't flexible or scalable.

Identified Issue: The Job is dispatched directly in the store() method instead of having a separate route for launching the send (backend/app/Http/Controllers/CampaignController.php:41). This tightly couples campaign creation and sending, making it harder to manage and test.

4. WhatsApp Webhook (2/2)

✅ A functional endpoint with validation is implemented, great for security and reliability. Validating incoming webhook data is crucial for security. This ensures that only legitimate messages are processed and prevents malicious data from being injected into your application.
✅ Updates message status based on webhook events, crucial for tracking campaign performance. When a message is sent via WhatsApp, the webhook receives updates about its status (e.g., sent, delivered, read). Updating the message status in your database allows you to track the performance of your campaigns and identify any issues.
✅ Appropriate logging is in place, which is essential for debugging and monitoring. Logging is critical for debugging and monitoring applications. It allows you to track events and errors, making it easier to identify and fix issues. Logging webhook events is particularly important, as it helps you understand the flow of messages and troubleshoot any delivery problems.

Frontend (5/8)

1. Campaign Creation Interface (3/5)

✅ A form with name and message inputs is present, the basics for campaign creation. A user-friendly form for creating campaigns is essential. It should allow users to enter the campaign name, message content, and any other relevant information.
✅ Customer selection by tags is implemented, allowing for targeted campaigns. Tag-based customer segmentation is a powerful feature for targeted marketing. It allows you to group customers based on their interests, demographics, or other criteria, and send them personalized messages.
✅ Client-side validation is in place, improving user experience. Client-side validation provides immediate feedback to users, preventing them from submitting invalid data. This improves the user experience and reduces the load on the server.
✅ An API call is made to create the campaign, connecting the frontend to the backend. This ensures that the data entered in the form is sent to the backend for processing and storage.
⚠️ Basic message preview but no real simulation (-1 point). A message preview is a useful feature that allows users to see how their message will look before sending it. However, a basic preview may not accurately reflect how the message will render on different devices and platforms. A real simulation would provide a more accurate representation.
❌ No handling of scheduled_at for scheduled campaigns (-1 point). This is a significant omission, as scheduling is a core feature of a campaign manager. The frontend should allow users to specify when a campaign should be sent and store this information in the scheduled_at field.

2. Campaign Dashboard (2/3)

✅ A list of campaigns with statuses is displayed, providing an overview of active and past campaigns. This allows users to quickly see the status of their campaigns and identify any that require attention.
✅ Simple statistics are shown (CampaignStats.vue), giving a basic overview of campaign performance. Campaign statistics provide insights into the effectiveness of your campaigns. Simple statistics, such as the number of messages sent and delivered, can help users understand how well their campaigns are performing.
✅ Automatic refresh every 30 seconds (real-time bonus!). This provides users with up-to-date information about their campaigns. Real-time updates are particularly useful for tracking the progress of ongoing campaigns.
❌ Incomplete statistics (no details of sent/delivered/failed per campaign) (-1 point). More detailed statistics, such as the number of messages sent, delivered, and failed for each campaign, would provide a more comprehensive overview of campaign performance. This level of detail is essential for optimizing campaigns and identifying areas for improvement.

3. Asynchronous Management (11/15) - 73%

Asynchronous management is where things get interesting, guys. It's all about handling tasks in the background so the app stays snappy. Let's see how this project handles queuing and background processes. This section evaluates how well the application handles tasks asynchronously. Asynchronous processing is crucial for improving application performance and user experience. It allows long-running tasks, such as sending campaign messages, to be processed in the background, preventing the main application thread from being blocked.

✅ Positive Points (11 points)

Job Correctly Structured (5/5)

✅ SendCampaignJob implements ShouldQueue, which is the first step to making things asynchronous. Implementing the ShouldQueue interface tells Laravel that this job should be processed in the background using a queue.
✅ Appropriate traits are used (Dispatchable, InteractsWithQueue, Queueable, SerializesModels), leveraging Laravel's queue system. These traits provide the necessary functionality for dispatching, handling, and serializing jobs. They simplify the process of working with queues and ensure that jobs are processed correctly.
✅ The Job is dispatched asynchronously, ensuring tasks run in the background. Dispatching a job asynchronously means it's added to a queue and processed by a worker in the background. This prevents the main application thread from being blocked, ensuring a smooth user experience.

Realistic Simulation (4/5)

✅ campaign_messages are created for each customer, setting the stage for tracking individual message statuses. Creating a campaign_message record for each customer allows you to track the status of each individual message sent as part of the campaign. This is crucial for understanding the performance of your campaign and identifying any issues.
✅ WhatsApp sending is simulated via Log::info(), a good way to avoid actually sending messages during testing. Logging the messages instead of sending them is a common practice during development and testing. It allows you to verify that the messages are being generated correctly without incurring costs or spamming users.
✅ A random delay of 1-3 seconds between messages is introduced, mimicking real-world sending limitations. This simulates the rate limits and delays that are typically imposed by messaging platforms like WhatsApp. It helps ensure that your application doesn't exceed these limits and get throttled.
✅ Campaign status is updated (draft → sending → completed), providing a clear progress indication. Updating the campaign status allows users to track the progress of their campaigns. This is particularly important for long-running campaigns, where it can take some time for all messages to be sent.
⚠️ Status