This integration leverages the natural language processing capabilities of ChatGPT to automatically generate a database schema based on the user’s description of the app. Flatlogic’s powerful web app generator then takes over, building a fully-functioning CRUD app based on the schema in record time. Whether you’re a developer looking to streamline your workflow or a non-technical user looking to build your own app, this integration has something to offer you.

With ChatGPT and Flatlogic, you can create a fully-featured CRM/ERP web app, CMS software, project management tool, or admin panel in minutes, without having to write a single line of code. The possibilities are endless, and the resulting apps are production-ready, with a modern design and smooth user experience.

The process is very simple: go to our main page, click “Generate web app”, register for an account, and on the 3rd step, where you define a database schema, add a description by clicking on the “Generate with AI” button. You need to type the application’s description in the text area and hit “Send”. The application’s schema will be ready in around 15 seconds. You may either hit deploy immediately or review the structure to make manual adjustments.

For example here is the app (built with Vue / Node.JS / Postgresql / Tailwind) https://erp-12205-lnm5nd2pia-uc.a.run.app/#/ that was generated based on the following description:

“ERP system with leads, inventory management, healthcare management system and events tracking”

Please note that this feature is currently in an experimental phase, and we welcome all feedback and comments as we continue to refine and improve it. If you have any ideas or suggestions, we encourage you to reach out to us through our forum or social media channels.

Just head to our main page and click “Generate Web App” to get started, and be part of a revolutionary new way to develop apps. We look forward to refining and improving the integration to make your app development experience even more enjoyable!

The post ChatGPT + Flatlogic: Generate Fully-Functioning Web Apps Based on Description appeared first on Flatlogic Blog.

Creating software without planning is a recipe for disaster. Without proper planning, the software may be rushed, inefficient, and lacking the features needed. Furthermore, the software may be challenging to maintain and upgrade, as it was not designed with scalability or extensibility.

Creating software “as-is” vs. planning

Planning is an essential part of creating any software, as it allows the developers to understand the scope of the project, identify the best technologies to use, and create a timeline to ensure the project is completed on time. Just as with everything in life, having a plan is better than not having one.

One of many approaches that can be helpful in navigating this process is the Software Development Life Cycle (SDLC). This framework provides a structured approach to software development, guiding the process from conception to deployment. So how would you know where to begin it?

Then how would you ensure that you define the problem correctly so that your software can handle it correctly? Perhaps, on the other hand, what if you already get the software’s code base but don’t know what to do with it? These questions are the most powerful reason for the implementation of something like SDLC.  

What is SDLC?

SDLC is a framework that outlines the steps necessary to create an effective and efficient software system. SDLC solutions can help organizations address various problems, including 

• Poorly planned projects that end up taking longer than expected or going over budget. 
• Unorganized development processes lead to delays and unnecessary mistakes. 
• Unclear communication between teams or departments results in misunderstandings and mistakes. 
• Lack of visibility into project progress, leading to unplanned delays. 
• Insufficient testing and quality assurance processes lead to poor quality outcomes.

The SDLC consists of six phases: planning, analyzing, design, development, testing, and maintenance. 

SDLC Phases

Planning

The scope and objectives of the project are determined during the planning phase. It is the foundation stage that establishes the scope and objectives of the project. During this phase, the project team will define the project scope, set deadlines, and identify the resources needed to complete the project. The team will also create a project plan outlining the various tasks that need to be completed and the sequence in which they need to be completed. Risk management plans are also put in place during this phase to help identify potential risks that may arise. It is important to ensure that the project objectives are achievable and that the team has the skills and resources necessary to complete the project on time and within budget. The planning phase is vital to the success of the project and sets the tone for the rest of the SDLC. 

The team should also create a project budget and timeline to ensure that the project is completed on time and within budget. The team should also create a quality assurance plan to ensure that the software meets the user requirements and is bug-free. Furthermore, the team should create a communication plan to ensure that all stakeholders are kept informed of the progress of the project. The team should also create a risk management plan to identify and mitigate any potential risks during the project. Finally, the team should create a user feedback system to ensure that any issues are identified and addressed quickly. This phase is important to ensure that the project is properly planned and managed to ensure its success.

Analysis

The SDLC Analysis Phase is the second part of the software development life cycle. In this phase, the project team will analyze the business requirements to understand what needs to be done to create the software solution. The team will document the user requirements, identify the system functions and features, and create a detailed design specification. The project team will also review the feasibility of the project and develop a timeline for completion. In addition, they will identify potential risks and create a risk management plan to mitigate them. The team will also create a cost analysis to determine the estimated cost of the project. This phase is key to the success of the project, as it provides the team with the necessary information to move forward with the project. It is important to ensure that the analysis phase is properly managed to ensure the project is successful.

The team will also consider various technologies that can be used to develop the software solution. They will analyze the strengths and weaknesses of the different technologies and determine which one is best suited to the project. The team will also analyze the market to identify any potential competitors and assess the current trends in the industry. Finally, the team will create a user interface design to ensure the software is user-friendly. During this phase, it is important to ensure that the team can identify areas of improvement and make the necessary changes to the design. By properly managing the analysis phase, the team will be able to create a successful software solution.

Design

The SDLC Design Phase is the third part of the software development life cycle. This phase is where the team begins to create the software. During this phase, the team will create the software architecture, design the user interface, and code the software. The team will also review the design and make any necessary changes. The design should include all of the user requirements, system functions, and features that were identified in the analysis phase. The team should also create a test plan to ensure that the software meets the user requirements and is bug-free. The design phase is critical to ensure that the software is user-friendly and meets all of the project requirements. It is important to ensure that the design is properly managed to ensure the success of the project. 

Besides design, the team will also create a database that will store all of the data related to the software. The team will also create a data flow diagram that outlines the different processes that will take place within the software. The team will also create a system security plan to ensure that the software is secure from outside threats. Finally, the team will create a deployment plan to ensure that the software is properly deployed and maintained. This phase is important to ensure that the software is properly developed and the project is completed on time and within budget. It is important to ensure that the design phase is properly managed to ensure the success of the project.

Development

The SDLC Development Phase is the fourth part of the software development life cycle. During this phase, the team will create the software. The team will write the code and create the necessary files and components to complete the project. The team will also create a testing plan to ensure that the software is bug-free. During this phase, the project team should also create a version control system to ensure that the code is properly managed. This phase is key to the success of the project, as it ensures that the software is developed properly. It is important to ensure that the development phase is properly managed to ensure the success of the project. 

The team should also select the appropriate software stack for the project. The software stack is the combination of programming languages, frameworks, and libraries that are used to build the software. It is important to select the appropriate stack to ensure that the software is properly developed and can meet the user’s requirements. The team should also consider the scalability of the stack to ensure that the software can grow and evolve as needed. This phase is important to ensure that the software is properly developed and the project is completed on time and within budget.

In addition to the development, the team will also create the necessary documentation for the software. This includes user manuals, installation guides, and system diagrams. The team should also create a training plan for users to ensure that they understand how to use the software. Furthermore, the team should create a bug-tracking system to ensure that any issues are identified and resolved quickly. Finally, the team should create an implementation plan to ensure that the software is properly deployed and maintained. This phase is important to ensure that the software is properly developed and the project is completed on time and within budget.

Actually, partnering with a custom software development company can provide a tailored SDLC approach, ensuring your project benefits from industry expertise, advanced technologies, and customized solutions that align with your specific business goals. This collaboration can significantly enhance the efficiency, scalability, and success of your software development projects.

Testing

The testing phase is used to verify the functionality of the system and ensure that it meets the specified requirements. During this phase, the team will test the software to ensure that it meets the user requirements and is bug-free. The team will create a test plan to identify the various tests that need to be completed and the sequence in which they should be completed. The team will also create a test environment to simulate the actual environment in which the software will be used. This phase is key to the success of the project, as it ensures that the software is tested thoroughly and meets all of the project requirements. It is important to ensure that the testing phase is properly managed to ensure the success of the project. 

Apart from testing, the team will also perform security testing to ensure that the software is secure from outside threats. The team will also perform performance testing to ensure that the software can handle the expected load. The team should also create a documentation plan to ensure that all of the necessary documentation is created and maintained. Finally, the team should create a bug-tracking system to ensure that any issues are identified and resolved quickly. This phase is important to ensure that the software is properly tested and the project is completed on time and within budget.

Maintenance

Once the system is tested and verified, it is ready for the maintenance phase. During this phase, the team will monitor the software and make any necessary changes to ensure that it continues to meet the user requirements. The team will also create a maintenance plan to ensure that any changes or updates to the software are properly implemented. The team should also create a post-implementation review to evaluate the success of the project and identify areas of improvement. This phase is key to the success of the project, as it ensures that the software is maintained properly and can evolve as needed. It is important to ensure that the maintenance phase is properly managed to ensure the success of the project. 

Besides maintenance, the team should also create a backup plan to ensure that the software and its data are protected in case of a disaster. The team should also monitor the performance of the software to ensure that it can handle the expected load. The team should also create a user feedback system to ensure that any issues are identified and addressed quickly. Finally, the team should create a change management system to ensure that any changes or updates to the software are properly documented and communicated to all stakeholders. This phase is important to ensure that the software is properly maintained and the project is successful. 

SDLC Models

The SDLC Models are a set of methods used to create software applications. There are several different types of models, including the Waterfall Model, the Agile Model, the DevOps Model, the Spiral Model, the Prototype Model, and the Iterative Model. 

• The Waterfall Model is a traditional method that follows a linear approach, with each phase of the SDLC being completed in sequential order. 
• The Agile Model is a more modern approach that focuses on rapid development, short sprints, and frequent feedback. 
• The DevOps Model is a hybrid of the Waterfall and Agile models that combines the best of both approaches. 
• The Spiral Model is a risk-focused approach that allows for rapid iteration. 
• The Prototype Model is an iterative approach that focuses on creating a prototype and testing it before proceeding with the development. 
• Finally, the Iterative Model is an incremental approach that focuses on making small, incremental changes to the software. 

Each model has its benefits and drawbacks, and it is important to choose the right model for the project. It is important to ensure that the project team is familiar with the selected model before beginning the project. This phase is important to ensure that the software is properly developed and the project is completed on time and within budget. The team should also consider the scalability of the model to ensure that the software can grow and evolve as needed. Furthermore, the team should create process documentation to ensure that the process is properly documented and can be followed by all members of the team. This documentation should include the steps of the model, the tools and techniques used, and any best practices that the team should follow. This documentation should be updated regularly to ensure that the process remains up-to-date and that the team is aware of any changes or updates.

Usage of SDLC

The SDLC is an iterative process, meaning that it is continually evolving and adapting to changes in the user’s requirements and technology. As new technologies and user needs emerge, the system must be modified to meet the new requirements. This requires that the SDLC be revisited and the steps outlined above repeated. By following the phases of the SDLC, software developers can create reliable and effective software systems that meet the user’s needs. The SDLC is an invaluable tool for any software developer and is essential for successful software development.

The Systems Development Life Cycle is used by software developers, software engineers, IT professionals, project managers, and business analysts. The SDLC is used to ensure that the system meets the user’s requirements and is built to last. It provides a framework for the successful development and maintenance of software systems and helps ensure that the system is built according to best practices and industry standards. 

Benefits of Software Development Life Cycle 

SDLC is a process used by information technology professionals to develop and maintain software systems. It is an essential process for the successful development and maintenance of software systems, and it offers numerous benefits. 

• SDLC helps to ensure that the system meets the user’s requirements and is built to last. It provides a framework for the successful development and maintenance of software systems and helps ensure that the system is built according to best practices and industry standards.
• SDLC helps to facilitate better communication between the developers and the stakeholders. It helps to ensure that the stakeholders have a clear understanding of the system’s requirements and that the developers have a clear understanding of the stakeholders’ expectations. 
• SDLC helps to identify potential risks associated with the project. By identifying and addressing potential risks early on, the project is more likely to be successful. 
• SDLC helps to reduce the cost and time of software development. By following the steps of the SDLC, software developers can create reliable and effective software systems in a shorter amount of time and at a lower cost.

Why choose  Flatlogic Platform as an SDLC solution?

Flatlogic Platform – is a platform that provides developers with the tools they need to quickly and efficiently build business software using the SDLC. Flatlogic Platform does offer the potential to speed up development by 20% or more compared to traditional manual software development processes. The platform’s automated tools, streamlined workflow, and comprehensive analytics all help to reduce the amount of time and effort required to complete projects. This can result in a notable improvement in development speed and efficiency.

Benefits of Choosing Flatlogic Platform 

1. Automated and streamlined workflow: Flatlogic Platform automates the software development lifecycle, from project planning to deployment. This streamlines the process and eliminates any manual steps, ensuring projects are completed on time and within budget. 
2. Easy-to-use interface: Flatlogic Platform has an intuitive, user-friendly interface that enables teams to quickly set up projects, create tasks, and manage timelines. This makes it easy for developers to stay organized and efficient throughout the project. 
3. Comprehensive analytics: The platform provides comprehensive analytics, allowing teams to track and analyze project progress and performance. This helps teams identify and address potential issues before they become problems, improving the overall quality of the end product. 
4. Secure and reliable: Flatlogic Platform is secure and reliable, ensuring data is stored safely and accessible only to authorized personnel. This helps protect sensitive customer information and ensures projects are completed efficiently.

The post 6 Phases of the Software Development Life Cycle appeared first on Flatlogic Blog.

What can you do with the free plan for the CRUD tool

You can expect the same features and functionality whether you choose our Paid access or Free option. But obviously with some limitations:

• Create up to 10 applications on different technology stacks: React, Vue, Angular, Node.js, Laravel, PostgreSQL, MySQL
• Create a full-fledged CRUD application (up to 3 database entities) with code written using best practices
• Download or push source code to Github an unlimited number of times
• Preview the code before downloading/pushing it on Github
• Get updates on libraries used in your app stack
• Host instantly your application demo and see the latest deployment logs

Free vs Paid access to the CRUD tool: Choose what you need

Since launching Flatlogic, we see constant growth in the creation of CRUD applications. But we understand that not all of our users need the full functionality of the CRUD tool. We also understand that in the modern world of developer tools, before investing huge resources in mastering new tools, you want to get some value here and now for free – with this motivation we introducing a free plan for creating CRUD applications.

Thus the free plan fits your needs. If you:

• Want quickly prototype the CRUD app
• Want to test or get familiar with new technologies before investing much time in them
• See the best practice on how to organize modern CRUD apps using best practices
• Prefer to use starter kits/boilerplates while starting CRUD web applications

And while our Professional plan has always offered a more enhanced way to create CRUD applications, it also required additional steps to understand your needs before getting access.

Now, you can sign up for a free account for a CRUD tool, create applications in minutes, and understand without any hassle whether Flatlogic fits your needs or not.

Create a CRUD app for free!

The post Creating full-stack web applications based on database schema for free! appeared first on Flatlogic Blog.

If you have ever worked with databases, then for sure you’ve worked with CRUD – even if you didn’t know it. CRUD operations are often used with SQL. Since SQL is very popular in the developer community, developers need to understand how CRUD operations work.

The CRUD paradigm is beneficial in business software development, as it aids developers in constructing comprehensive applications by providing a clear framework for creating, reading, updating, and deleting data.

Let’s see how this works with a simple abstract object in any application: we’ll use something like pseudocode to describe this object. We will provide a system for registering students in a college. In this system there will be a “student” object that looks like this (carefully, pseudocode!):

“Student”: {
  "id": <Integer>,
  “First_name”: <String>,
  “Last_name”: <String>,
  “Course”: <String>
}

To manage this system, we must perform certain manipulations with the student object. So, let’s move on to the next section where we will describe each CRUD operation in more detail.

Most applications on the internet are CRUD applications. For instance, let’s take Facebook as one of the common examples – it’s just a CRUD application where users can create, delete, change information about themselves, and read information about other people. CRUD apps are used daily by various businesses and organizations to maintain their day-to-day workflows.

What are CRUD and CRUD operations examples?

The CRUD concept, foundational in database management, has evolved beyond its original scope, now underpinning the development of modern APIs, significantly impacting the architecture of business software for enhanced data handling and application functionality. Most modern web and mobile applications contain some form of CRUD functionality. In addition, most programmers have to deal with CRUD at some point. So, a CRUD application would utilize forms to retrieve and return data from a database.

A relational database consists of tables with rows and columns. In a relational database, each row in a table is called a record, and each column in the table represents a specific attribute or field. Users can call four CRUD operations to perform different action types on selected data in the database. This can be done through code or GUI. Now, let’s take a look at each function separately.

CREATE – this feature will add a new student to the app/database by some trigger, for example, by pressing the “Add” button in the application, which will call the corresponding function. The program calling the function would supply the values ​​for “first_name”, “last_name”, and “course”. After the function is called, a new student record will appear in the database.

READ – this function allows you to see if there is a record about a specific student in the database. This function does not change the information about the student in any way but only allows you to get information about him. You can also see a certain attribute.

UPDATE is a function that changes information about a student. Let’s write his name. After the function is applied, the corresponding record in the database table will be changed.

DELETE – of course, everything should be clear here. This function either completely removes the object or removes its selected attribute.

By definition, CRUD is more of a cycle than an architectural concept. There are several CRUD loops in any web application. For example, in an online store, a customer can CREATE an account, UPDATE account information, and DELETE items from the cart. At the same time, a store admin using the same web application can CREATE shipping records, READ them as needed, and UPDATE supply lists.

CRUD Operations in REST Context

Let’s now take a look at the concept of CRUD in the context of using our favorite web applications. Most often, REST architecture is used to execute CRUD operations in web applications. REST is just a concept, a set of rules. It uses HTTP protocols like GET, PUT, and POST to link resources to actions within a client-server relationship. If we apply these rules to the application, then we are already talking about RESTFul.

So, for example, each letter in CRUD can also be mapped to an HTTP protocol method:

Thus CRUD is a cycle that can be mapped to REST, by design. In a REST environment, CRUD often corresponds to the HTTP methods POST, GET, PUT, and DELETE, respectively.

Parts of the CRUD app

Database

The database is where your data is stored. A database management system is used to manage the database. There are several types of database management systems, which are subdivided depending on how they store data: relational (SQL) and document (NoSQL). In this article, we talk about relational databases. SQL databases consist of tables. Tables consist of records. Records consist of fields. Fields consist of data.

User Interface or Front-end

The front-end, or User Interface, helps people interact with the application and database.

Back-end or APIs

Finally, the back-end informs your database of what functions to perform. These functions can be modeled in different ways, but they are still designed to perform four basic CRUD operations.

Creating CRUD applications traditional way

To develop a basic CRUD application from scratch, you will need a fairly good knowledge of javascript or front-end frameworks, one of the programming languages for the back-end, and knowledge of databases. You will also want to know one of the ORMs.

Let’s take a quick look at the steps you will have to go through to write a React + Node.js + PostgreSQL CRUD application.

Prerequisites

• Install React;
• Install Node.js;
• Install PostgreSQL.

Front-end part

• Use one of the React starter apps and learn it. For example, it may be created react app;
• Install all required modules (react-router, redux, etc.);
• Create Initial pages of your application;
• Create components that will help perform CRUD functions – buttons, forms, etc.;
• Connect the front-end part to the back-end;
• Setup form validation;
• Develop react pagination (optional);
• Develop react tables (optional);
• Setup fetching the data from created database;
• Create entire application styles;
• Develop UI/UX of the application (optional);
• You should do the client part responsive;
• Write tests (optional).

Back-end and database part

• Install Node Dependencies;
• Setting up PostgreSQL Database;
• Define Sequelize Schema;
• Create Routes Using ExpressJS (develop REST API).

Hosting

It is one of the hardest parts.

• Host the application;
• Set up CI/CD.

Almost all of the steps described above apply to other technologies, be it Vue or Angular, Laravel or Python, PostgreSQL, or MySQL.

Guides on how to incorporate CRUD operations in an App

We have also selected for you some of the valuable guides on how to create a custom CRUD app:

• CRUD app on Mongo DB and Express;
• React CRUD app using React context API;
• React + Node.js+ MongoDB CRUD app.

Thus, to build even a basic CRUD application, you will need knowledge of several technologies and will have to spend a lot of time studying and developing repetitive work – not to mention new requests for the development of additional features.

In the next section, we will look at an alternative way to develop a CRUD application that will save you a lot of time, not holding you back in the possibilities of customization and ownership of the source code.

Create a CRUD app with Flatlogic

In our example, we will build a small-time tracking application with several entities. The application will have a screen with users, projects, and records that will be linked to each other. These entities can be managed using CRUD operations.

Goals

• You should be able to build any CRUD application like a time tracking app after this tutorial using Flatlogic Generator;
• You should be able to understand the basic principles of the CRUD concept and database architecture;
• You should be able to create your entities with custom relationships and parameters.

1. Planning the application

Application development with Flatlogic Generator consists of several stages. The first is to sort out what kind of application you will make. After that, plan what entities the database will consist of and what this application will be used for.

We mentioned above that we will be developing a time-tracking application. Our application will consist of three entities (tables in the database):

Users 

This table will contain users of our application with different roles. Flatlogic Generator creates this table by default and does not prompt to delete it.

Records 

This table will store the time spent records associated with projects and users. We will look at the more detailed contents of this table in the next steps.

Projects

This table will store data about projects. We will also consider filling this table with columns in more detail in the next steps.

2. Register an account in Flatlogic Generator

So, for better interaction with Flatlogic Generator, firstly we advise you to create an account on the Flatlogic website before you develop an application.

To create an account on the Flatlogic website, simply click ‘Sign in’ in the header (see screenshot below).

Next, you will be redirected to the account creation page, where you will have 2 options – create an account using email or do it using GitHub integration.

After that, simply confirm the email and begin work with a Flatlogic Generator website. For detailed info on how to interact with your account please refer to the documentation.

3. Choose the stack and project name of the CRUD app

This step will allow you to choose your project stack and project name. The stack consists of three parts:

• Frontend;
• Backend;
• Database.

In each part you will have the following options to choose from:

• The front end has React, Angular, and Vue frameworks;
• Backend for now has only two options – Node.js and Laravel. We are planning to add Java, Python, and .NET options;
• There are two options for databases: MySQL and PostgreSQL. We are planning to add MongoDB shortly.

Thus, you have more than 20 options to choose from to create your web application

4. Choose the design

Considering the design, there are five options now: Material, Classic, Transparent, and two of our internal Flatlogic design systems. Please note that some stacks have fewer design options, for example, Angular has only three design options.

5. Define the database schema

To create, manage, and store the data related to the time-tracking app, we will use the Flatlogic Generator schema editor. Flatlogic generator allows you to create content types for the entities in your app. It exposes entities via generated API, which you can use to populate the front end.

The basic essence of the Scheme Editor is that it consists of tables and columns – in your work, you will deal with them.

If you choose to build an application from scratch, then you will see a button to add a table as well as a ready-made default table for Users (since we believe a user exists in any application).

By clicking on the ready-made Users tab, you will see in front of you all the columns created in the table with their properties. In our exemplary time tracking application, the Users entity stays default – we will not add new columns to it.

Working with tables, you have 2 options – add a new table or delete it. Now let’s take a look at each of these steps separately.

When working with columns, you have 3 options – add or remove a column, or change the properties of the column.

Adding Records and Projects tables

As mentioned above, our application should have Records and Projects tables.

So, to add a table, you need to press the ‘Add Table‘ button (see screenshot below).

After clicking the button, a new table will be added and you will be prompted to select a name for this table. Please choose the name in lowercase. In our case, we need to add two Records Projects tables.

Adding column

To create a column, click on the table in which you want to create a column and then click on the ‘Add column’ button.

When you click on the column, you can edit it. Edit column window with the following parameters will open on the right side (see the screenshot):

Name – here you specify the name of the column that you will see in your database. Please, use a camel case for column names.

Title – title of the column that you will see in your live application. Here you can use capital letters and any names, as this does not affect the generation and operation of the application.

Type – in this menu you can select the data type of the column.

The following types are offered to choose from:

• String – when you select this type, you have a unique Multiline option that adds multiple lines;
• Int;
• Decimal;
• Date;
• Boolean – when choosing this type, you need to set the value to True or False;
• Images;
• DateTime.
• Relation_one;
• Relation_many;
• Enum.

Unique – enables or disables the column uniqueness option;

Show in the list – option allows to show the column as a list;

Show in form – allows you to show the column in the form.

So let’s add the following columns according to their tables.

To the Records the table we add the following columns:

Task – this column will contain the names of the completed tasks

Hours –  a column with information on time spent on the task

User – a column with data about the user who created the job record. Please note that the type here is relation_one and a link to the users table

Submitted – this column will contain information about the status of the job

Project – a column with information about the project to which the task belongs. The column will also be linked to the projects table

In the Projects table we add the following columns (see the screenshot below):

Name – in this column, we will store the name of the project. The column must be created with the following parameters

Rate – a column with information about the hourly rate at which the project is being executed

Start_date – the column with information is the start date of the project

End_date – a column with the date of the end of the project

This completes our database schema. Let’s move on to the last step of creating the CRUD application.

6. Create a CRUD app

So, after you have defined your database schema, you will be redirected to the final step in the development wizard. All you need in this step is to check your tech stack and design – and then push the ‘Create Project‘ button.

After that, the system will transfer you to the screen with your created projects. At the same time, your application code will already be generated.

By clicking on the project name, you will be taken to the settings page with additional information about the project, where you can familiarize yourself with the following functions.

7. Working with CRUD project/application

Overview of project

After you click on the project name you will be taken to the overview of the project page, where you will see information about the project, as well as the various functions you can apply to it.

Download the code to customize

For example, you can download the full source code of a Flatlogic Generator project to continue developing in your favorite IDE. To do this, click on the Download button and get a subscription to one of the paid plans (which can be canceled at any time).

See the live demo

Before downloading the code, you can also watch the live demo of your project. To do this, click on the Deploy button on the overview tab opposite the Live URL line.

Now, the project begins to build. In a few minutes, you will receive a demo of a real working application.

After the application has been created, we can see the result. For example, here are screenshots from the demo of our Time-tracking app, which we created with the Records and Projects entities. In these screenshots, you can see that the application complies with the CRUD concept since we can create new records, modify, delete, and view them.

Creating a new record:

See generated API

Along with generating code, Flatlogic Generator creates an API for the generated application. For example, here is a link to the created API for the time-tracking app we created earlier: API for the Time-tracking app in Swagger.

Push code to the Github repository

You can push the code of the created application into the GitHub repository, which will be created specifically for the generated application. At the same time, editing the project database schema, Flatlogic Generator will push the new code into the previously created repository.

To connect to Github – click the Push to Github button.

See the code preview

Before subscribing to a project or downloading it, you can see the structure of the project code and the code itself. To do this, click on the Code Preview tab.

Edit the schema of the CRUD application

You can change the database schema of your application an infinite number of times. Click on the Schema tab to go to the schema editor and add/remove/modify entities for your project.

CRUD application settings

In the Settings tab you can do the following:

• Change the name of the project;
• Add a new subscription;
• Download the source code;
• Push the code to GitHub;
• Activate trial;
• Delete Project.

You can also watch our A to Z tutorial on YouTube to understand how to make your CRUD app step by step:

Recap: CRUD Operations with Flatlogic Platform

Thus, we created a CRUD time-tracking application based on the Flatlogic Generator and examined the main functions of this app development platform. 

Feel free to try and join Flatlogic Generator! Register your free account and get started today.

If you’d like additional help when building your product, our thriving community forum is a great place to source actionable advice and resources. Or, you can send me your request to eugene@flatlogic.com. All creators are encouraged to ask questions within the community to help empower their journey.

CRUD Operations Explained

We’ve covered what stands behind each letter in CRUD. These four operations are equivalent to the SQL statements of Insert, Select, Update, and Delete, and to the HTTP methods of Put, Get, Delete (Put represents both Create and Update here). Now let’s pay some attention to each of the CRUD operations.

C: Create

The “Create” operation adds new records to the table and the database it’s related to. The fields where the records will be stored can be specified in the command. Alternatively, if the fields and columns are unspecified, the database’s internal mechanisms will govern that. Apart from creating, or inserting records in one field at a time, modern SQL allows for more advanced forms. One of them is the Multirow Insert. It lets us create multiple entries with a single statement. The difference in operating speed for a single entry is negligible but might grow significantly when your server has to process millions of entries. Copying rows from other tables combines the Create/Insert operation with Read/Select. It allows for copying and (if necessary) adjusting entries from other tables without implementing two separate commands.

R: Read

Read or Select operation is often credited as the most popular of CRUD operations. But perhaps “extract” would be the most accurate term for it. This operation Extracts data from one or more fields within the database. It occurs whenever we reference a piece of data on the website or perform an action that requires referencing it. Every interaction with a web platform involves interacting with something stored within the database.

U: Update

The two remaining statements are known under the same names both within the CRUD concept and in SQL. As the name implies, Update changes the data within the affected fields. Compared to Read/Select and Create/Insert, Update typically requires more data manipulation privileges. Furthermore, database fields can and almost always will have internal constraints on the data stored. For example, a field can accept only a certain type of value, or only accept values that aren’t empty or have a fixed selection of acceptable values.

D: Delete

Delete is also known by the same name in both concepts. Normally, conditions are set for deleting entries. Without set conditions, all available records are removed. A Delete-type command must contain those conditions to specify the content was deleting. For example, in a table containing car models, we can delete rows where the column “Color” equals “red” and “Year produced” is between 1992 and 1995. Some database management systems, like the highly popular MySQL, allow us to delete rows of entries from more than one table at a time.

Conclusion

In this article, we learned about the concept of CRUD, explained how to apply CRUD operations to web development, and put it in a REST context. We also looked at two ways to develop a basic CRUD application, the traditional way and the faster way with the Flatlogic Generator.

If you notice any errors in the article or want to supplement it – please contact me. Feedback is always welcome!

The post What is CRUD? CRUD Operations Explained appeared first on Flatlogic Blog.