Key Lessons for Building No-code Applications in AEC.
As both a startup founder and an AEC technology consultant aiding clients in the Architecture, Engineering, and Construction (AEC) sector, my journey with no-code and low-code tools has been rich with challenges, breakthroughs, and learning curves. In this dual role, I’ve navigated the complexities of introducing these innovative technologies to traditional AEC teams while simultaneously experiencing their transformative impact firsthand in building my own products and applications.
Through this article, I aim to share some hard-earned lessons I wish I’d known when I started building products with these tools, hoping to pave a smoother path for those embarking on their journey with no-code and low-code tools in the AEC industry.
If you want a brief introduction to no-code tools and their potential impact on AEC, make sure to read my previous article below.
Lesson 1: Focus on Data Modeling First
Data is the lifeblood of your application. The way you structure and organize your data can make or break your application. In the beginning, it’s essential to think deeply about how your data is structured and organized, and how it will flow through the app. A good starting point is to develop a high-level conceptual data model. This involves identifying the key entities or “things” your app needs to interact with — and understanding how they are interrelated. Then, you add another layer: the logical data model, detailing the specific attributes of each entity and their relationships. Finally, the physical data model comes into play, determining how this data will be stored and accessed in a database. Neglecting this foundational step often leads to a cumbersome back-and-forth between frontend and backend development, trying to retrofit data into the app’s design and vice versa.
Key Takeaways:
- Data as the Foundation: Prioritize understanding and structuring your data right from the start. It’s crucial for the functioning of your app.
- Efficient Data Structuring: Investing time in organizing data efficiently from the outset can significantly enhance user experience and app performance.
- Data Modeling Approach: Adopt a tiered approach to data modeling — start with a high-level conceptual model, refine it into a logical model, and finally, define the physical model. This structured approach ensures a harmonious alignment between your app’s frontend design and backend logic.
Lesson 2: Function Before Form
On my journey of building no-code and low-code applications as a tech consultant and startup founder, I’ve learned the critical importance of prioritizing function over form. It’s a common misconception that user experience (UX) and user interface (UI) are all about aesthetics. While a visually appealing design is undoubtedly vital for brand communication and user engagement, it should not come at the expense of the app’s core functionalities and usability.
Initially, your focus should be on laying down a robust foundation: ensuring that the user experience is seamless, the core features are fully functional, the layout is intuitive, and the navigation is straightforward and consistent. Getting these elements right sets the stage for a successful application. As your app matures, you then have the leeway to refine and enhance the aesthetics. This approach of evolving the design in tandem with the app’s functionality not only streamlines the development process but also ensures that the final product is both efficient and visually cohesive.
Key Takeaways
- Core Functionality is Key: Prioritize the app’s primary functions and user experience over perfecting its aesthetics initially.
- Building a Solid Foundation: Focus on developing a strong foundation with consistent user experience, essential features, and intuitive layout and navigation.
- Iterative Design Process: Adopt an iterative approach to your app’s design. Start with basic functionality and as the app evolves, gradually refine the aesthetics to ensure that they complement and enhance the app’s functionality.
Lesson 3: Performance and Scalability
It’s a common pitfall to assume that if an app works well in its initial stages, it will automatically scale up to meet higher demands. However, these platforms, while user-friendly and efficient, come with inherent limitations, particularly in terms of performance and scalability. For example, a platform like Bubble may comfortably handle up to 100,000 users, which is more than adequate for most Minimum Viable Products (MVPs) and internal tools. Yet, if your vision extends to a global scale with a massive user base, you might eventually need to shift toward full-scale custom development. A key part of managing this transition is leveraging the metrics and dashboards these platforms provide. These tools are indispensable for monitoring performance, latency, and workload, helping you understand whether your product is prepared to handle your anticipated usage. It’s also normal to encounter inefficiencies in your initial build. Regularly consulting these metrics allows you to identify and address these issues, ensuring your app not only works but is also primed for scaling up.
Key Takeaways
- Understanding Limitations: Be aware of the inherent limitations of no-code/low-code platforms, especially regarding scalability and performance.
- Monitoring and Metrics: Make effective use of the platform’s metrics and dashboards to monitor and enhance your app’s performance.
- Scaling Strategies: Recognize when your app’s growth and scale might necessitate a transition to custom development solutions for better scalability and performance.
Lesson 4: Planning & Organization
If you are building non-trivial applications it’s crucial to recognize that you’re not just piecing together a single element; you’re simultaneously juggling frontend design, backend architecture, data engineering, automation, and potentially, third-party API integration. This complexity requires planning and organization. It’s important to break down the development process into logical phases and specific tasks. A structured approach helps in efficiently navigating through the project lifecycle.
Additionally, one of the lessons I’ve learned is the importance of systematic naming and organization of components within the application. An organized workspace is invaluable, not only for your efficiency but also for any external collaborators who might join the project at different stages. Keeping your application environment clean and methodically organized mitigates the risk of errors and confusion, thereby ensuring a smoother development process.
Key Takeaways
- Project Management: Approach your app development with a project manager’s mindset and hold yourself accountable.
- Structured Approach: Implement a well-thought-out plan, dividing the project into distinct phases and tasks for better efficiency and clarity.
- Regular Housekeeping: Maintain an orderly and well-structured working environment within your chosen platform and name EVERYTHING.
Lesson 5: Learn from Others
All No-code and low-code platforms have vibrant and supportive communities of app builders that surround them. These communities are treasure troves of knowledge, experience, and collaborative spirit and actively engaging with these communities is immensely beneficial. They offer a platform to learn how others have tackled similar challenges, providing insights and solutions that might not be immediately apparent.
These forums are also great for discovering insider tips and tricks that only come with hands-on experience. They provide an opportunity to seek help when you hit a roadblock and to share your learnings and successes and this reciprocal exchange of knowledge only accelerates your learning.
Key Takeaways
- Community Engagement: Actively participate in the communities around no-code and low-code platforms. They are invaluable sources of knowledge, support, and inspiration.
- Sharing and Collaborating: Engage in these communities not just as a learner but also as a contributor. Sharing your experiences and solutions helps in nurturing a collaborative environment and can be instrumental in overcoming your challenges as well as assisting others.
Build Fast, Build Well
No-code platforms make it easier to build products and tools than traditional software development, but that doesn’t mean it’s easy. Each platform has its strengths and weaknesses, but the lessons I’ve shared apply to no-code product development in general. Armed with these lessons, AEC professionals can dive in head first and transform their own companies with tools and products tailored to their business processes and workflows without the cost, effort, and time that comes with traditional software development.
If you’re interested in integrating no-code tools into your AEC workflows and processes, feel free to reach out.
