Planning Your Embedded Application

Every embedded application starts with a handful of underlying core decisions that affect the entire lifecycle of the product. From choosing between microservices and monolithic architectures to ensuring robust security measures, these decisions play a pivotal role in the application's functionality and maintainability. This blog explores some key considerations to guide developers through the planning stages of software development for embedded systems.

Microservices versus monolithic architectures

When designing your application, one main decision is to go monolithic or microservices. Microservices break an application into smaller, manageable pieces that can be independently developed, tested, and maintained. This architecture allows for easier updates and unit testing, and it scales well. It’s ideal for projects where components can operate independently without frequent intercommunication.

However, microservices are not suitable for all projects. They require creating a solid infrastructure and introduce complexity that smaller teams or projects with tightly coupled components might struggle to manage. If you’ve got a simpler application or smaller team, it’s probably a better choice to have a good old monolithic application, where tasks are tightly integrated and run predominantly within a single process.

Multi-user considerations

The ability to handle multiple users is a requirement you absolutely need to be aware of at the beginning of a project. Retrofitting a single-user application to support multiple users can be complex and costly. It involves implementing authentication mechanisms, user-specific data management, and possibly extensive modifications to the database and application logic. It can also introduce strange user constraints and workflows, as well as unforeseen limitations. Planning for multi-user capabilities upfront saves significant development time and complexity issues later.

The role of containers

Containers offer a compelling approach to deploying and managing applications, particularly in a microservices architecture. Because they encapsulate an application and its dependencies into a single executable environment, they make it easier to maintain consistency across development, testing, and production environments. Containers can enhance cybersecurity, streamline development processes, and facilitate continuous integration and delivery. While they introduce some overhead, the benefits of using containers often outweigh the costs.

Security concerns

The need for security is ever-present and growing. Considerations include whether the OS is secure, how to keep the software up to date, how vulnerabilities are handled, and the architecture's overall resilience against attacks. Tools like Yocto have features to help developers assess and address common vulnerabilities and exposures (CVEs) in Linux-based systems.

It's also vital to implement security best practices such as minimizing the use of root privileges, employing read-only file systems, and isolating components within secure containers. For devices that do not require full internet connectivity, consider limiting network access to essential services only to enhance security.

Conclusion

The decisions made during the planning phase of an embedded application have long-lasting impacts on its performance, security, and maintainability. By carefully considering the architecture, user requirements, deployment strategies, and security measures, developers can build robust embedded systems that meet current needs and are adaptable to future demands. This blog is a condensed version of the application section in our whitepaper Embedded Linux: Choosing Your Software Stack, which has more details on each of these topics.