diff --git a/docs/CHANGELOG.md b/docs/CHANGELOG.md
index 605f32ebc..e07da51c3 100644
--- a/docs/CHANGELOG.md
+++ b/docs/CHANGELOG.md
@@ -9,6 +9,7 @@ to [Common Changelog](https://common-changelog.org)
 
 ### Changed
 
+- Display form validation errors next to the corresponding fields. ([#83](https://github.com/metagenlab/zDB/pull/83)) (Niklaus Johner)
 - Filter VF hits by SeqID and coverage and keep one hit per locus. ([#77](https://github.com/metagenlab/zDB/pull/77)) (Niklaus Johner)
 - Improve layout for various views, making better use of available space. ([#70](https://github.com/metagenlab/zDB/pull/70)) (Niklaus Johner)
 - Configure repository to publish the docs to [readthedocs](https://zdb.readthedocs.io)
diff --git a/webapp/assets/css/style_FILE_zDB.css b/webapp/assets/css/style_FILE_zDB.css
index 48d9d7fff..fb5fd61f1 100644
--- a/webapp/assets/css/style_FILE_zDB.css
+++ b/webapp/assets/css/style_FILE_zDB.css
@@ -976,10 +976,9 @@ background: #81F7F3;
 }
 
 #id_blast_input {
-    width: 300px;
-    height: 200px;
-    word-wrap: break-word;
+    width: 100%;
 }
+
 #id_motif_input {
     width: 300px;
     height: 20px;
diff --git a/webapp/assets/js/genomic_region.js b/webapp/assets/js/genomic_region.js
index 04471b98b..5bf45cede 100644
--- a/webapp/assets/js/genomic_region.js
+++ b/webapp/assets/js/genomic_region.js
@@ -10,7 +10,7 @@
 //   	strand: either +1 or -1
 //   	locus_tag
 //   highlight: a list of locus tag to highlight in red
-function createGenomicRegion(div, div_width, svg_id, regions, connections, highlight, window_size, ident_range) {
+function createGenomicRegion(div, div_width, svg_id, regions, connections, highlight, ident_range) {
 	const text_field_size = 40;
 	const margin = { top:5, right: 5, bottom:5, left:5 };
 	const max_arrow_size = 350;
diff --git a/webapp/chlamdb/forms.py b/webapp/chlamdb/forms.py
index 2fcabb28c..fdd0d8d1e 100644
--- a/webapp/chlamdb/forms.py
+++ b/webapp/chlamdb/forms.py
@@ -1,9 +1,16 @@
 # -*- coding: utf-8 -*-
+from collections import namedtuple
+from io import StringIO
+
+from Bio import SeqIO
+from Bio.Seq import Seq
+from Bio.SeqRecord import SeqRecord
 from crispy_forms.helper import FormHelper
 from crispy_forms.layout import Column, Fieldset, Layout, Row, Submit
 from django import forms
 from django.core.exceptions import ValidationError
-from django.core.validators import MaxLengthValidator
+from django.core.validators import MaxLengthValidator, MinLengthValidator
+from views.utils import EntryIdParser
 
 
 def get_accessions(db, all=False, plasmid=False):
@@ -53,8 +60,11 @@ class PlotForm(forms.Form):
         accession = forms.CharField(max_length=100,
                                     required=True,
                                     label=f"locus_tag (e.g. {locus})")
-        region_size = forms.CharField(max_length=5,
-                                      label="Region size (bp)", initial=8000, required=False)
+        region_size = forms.IntegerField(min_value=5000,
+                                         max_value=100000,
+                                         label="Region size (bp)",
+                                         initial=8000,
+                                         required=True)
         genomes = forms.MultipleChoiceField(choices=accession_choices,
                                             widget=forms.SelectMultiple(attrs={
                                                 'size': '1',
@@ -90,8 +100,18 @@ def __init__(self, *args, **kwargs):
                     css_class="col-lg-8 col-md-8 col-sm-12")
                 )
             )
-
-        def get_accession(self):
+            self.db = db
+
+        def clean_accession(self):
+            accession = self.cleaned_data["accession"]
+            prot_info = db.get_proteins_info(
+                ids=[accession], search_on="locus_tag", as_df=True)
+            if prot_info.empty:
+                raise ValidationError("Accession not found", code="invalid")
+            # Accession is now the sequence id
+            return int(prot_info.index[0])
+
+        def get_seqid(self):
             return self.cleaned_data["accession"]
 
         def get_all_homologs(self):
@@ -111,7 +131,7 @@ def get_genomes(self):
     return PlotForm
 
 
-def make_metabo_from(db, add_box=False, type_choices=None):
+def make_metabo_from(db, type_choices=None):
 
     accession_choices, rev_index = get_accessions(db)
 
@@ -124,13 +144,9 @@ class MetaboForm(forms.Form):
                        "data-live-search": "true",
                        "multiple data-actions-box": "true"}
                 ),
-            required=False
+            required=True
         )
 
-        if add_box:
-            input_box = forms.CharField(
-                widget=forms.Textarea(attrs={'cols': 10, 'rows': 10}))
-
         if type_choices:
             comp_type = forms.ChoiceField(
                 choices=type_choices,
@@ -144,8 +160,6 @@ def __init__(self, *args, **kwargs):
             self.helper.label_class = 'col-lg-1 col-md-6 col-sm-6'
             self.helper.field_class = 'col-lg-4 col-md-6 col-sm-6'
             rows = [Row('targets')]
-            if add_box:
-                rows.append(Row('input_box'))
             if type_choices:
                 rows.append(Row('comp_type'))
 
@@ -173,7 +187,7 @@ def get_choices(self):
 
 
 def make_venn_from(db, plasmid=False, label="Orthologs", limit=None,
-                   action=""):
+                   limit_type="upper", action=""):
 
     accession_choices, rev_index = get_accessions(db, plasmid=plasmid)
 
@@ -183,13 +197,20 @@ class VennForm(forms.Form):
                  "data-actions-box": "true"}
         help_text = ""
         targets_validators = []
-        if limit is not None:
+        if limit is not None and limit_type == "upper":
             attrs["data-max-options"] = f"{limit}"
             help_text = f"Select a maximum of {limit} genomes"
             targets_validators.append(
                 MaxLengthValidator(
                     limit,
-                    message=f"Select a maximum of {limit} genomes")
+                    message=f"Please select at most {limit} genomes")
+            )
+        elif limit is not None and limit_type == "lower":
+            help_text = f"Select a minimum of {limit} genomes"
+            targets_validators.append(
+                MinLengthValidator(
+                    limit,
+                    message=f"Please select at least {limit} genomes")
             )
 
         targets = forms.MultipleChoiceField(
@@ -377,6 +398,22 @@ def __init__(self, *args, **kwargs):
             )
 
             super(ExtractForm, self).__init__(*args, **kwargs)
+
+        def clean(self):
+            cleaned_data = super(ExtractForm, self).clean()
+            self.included_taxids, self.included_plasmids = self.get_include_choices()
+            self.excluded_taxids, self.excluded_plasmids = self.get_exclude_choices()
+            self.n_missing = self.get_n_missing()
+            self.n_included = len(self.included_taxids)
+            if self.included_plasmids is not None:
+                self.n_included += len(self.included_plasmids)
+            if self.n_missing >= self.n_included:
+                err = ValidationError(
+                    "This must be smaller than the number of included genomes.",
+                    code="invalid")
+                self.add_error("frequency", err)
+            return cleaned_data
+
     return ExtractForm
 
 
@@ -453,24 +490,82 @@ class BlastForm(forms.Form):
                                        "data-live-search": "true"})
             )
 
+        input_help = "This can be either an amino-acid or a nucleotide "\
+                     "sequence, or a set (one or more) of fasta sequences."
         blast_input = forms.CharField(
-            widget=forms.Textarea(attrs={'cols': 50, 'rows': 5}))
+            widget=forms.Textarea(attrs={"placeholder": input_help, "rows": 10}))
 
         def __init__(self, *args, **kwargs):
             super().__init__(*args, **kwargs)
             self.helper = FormHelper()
             self.helper.form_method = 'post'
-            self.helper.label_class = 'col-lg-4 col-md-6 col-sm-6'
-            self.helper.field_class = 'col-lg-6 col-md-6 col-sm-6'
             self.helper.layout = Layout(
                 Fieldset(
-                    Row("BLAST"),
-                    Row('target'),
-                    Row('blast_input'),
-                    css_class="col-lg-5 col-md-6 col-sm-6")
+                    "",
+                    Row(
+                        Column("blast", css_class='col-lg-4 col-md-4 col-sm-12'),
+                        Column("max_number_of_hits", css_class='col-lg-4 col-md-4 col-sm-12'),
+                        Column('target', css_class='col-lg-4 col-md-4 col-sm-12'),
+                    ),
+                    Row(Column('blast_input', css_class='col-lg-12 col-md-12 col-sm-12')),
+                    Submit('submit', 'Submit',
+                           style="padding-left:15px; margin-top:1em; margin-bottom:15px "),
+                    css_class="col-lg-10 col-md-10 col-sm-12")
             )
             super(BlastForm, self).__init__(*args, **kwargs)
 
+        def _get_records(self):
+            input_sequence = self.cleaned_data['blast_input']
+
+            if '>' in input_sequence:
+                self.no_query_name = False
+                try:
+                    records = [i for i in SeqIO.parse(
+                        StringIO(input_sequence), 'fasta')]
+                    for record in records:
+                        if len(record.seq) == 0:
+                            raise ValidationError(
+                                "Empty sequence in input", code="invalid")
+
+                except Exception:
+                    raise ValidationError(
+                        "Error while parsing the fasta query", code="invalid")
+            else:
+                self.no_query_name = True
+                input_sequence = "".join(input_sequence.split()).upper()
+                records = [SeqRecord(Seq(input_sequence))]
+            return records
+
+        def _check_sequence_contents(self, records):
+            dna = set("ATGCNRYKMSWBDHV")
+            prot = set('ACDEFGHIKLMNPQRSTVWYXZJOU')
+            sequence_set = set()
+            for rec in records:
+                sequence_set = sequence_set.union(set(rec.seq.upper()))
+            check_seq_DNA = sequence_set - dna
+            check_seq_prot = sequence_set - prot
+
+            blast_type = self.cleaned_data["blast"]
+            if check_seq_prot and blast_type in ["blastp", "tblastn"]:
+                plural = len(check_seq_prot) > 1
+                wrong_chars = ", ".join(check_seq_prot)
+                errmsg = (f"Unexpected character{'s' if plural else ''}"
+                          f" in amino-acid query: {wrong_chars}")
+                raise ValidationError(errmsg, code="invalid")
+
+            elif check_seq_DNA and blast_type in ["blastn", "blastn_ffn",
+                                                  "blast_fna", "blastx"]:
+                wrong_chars = ", ".join(check_seq_DNA)
+                plural = len(check_seq_DNA) > 1
+                errmsg = (f"Unexpected character{'s' if plural else ''}"
+                          f" in nucleotide query: {wrong_chars}")
+                raise ValidationError(errmsg, code="invalid")
+
+        def clean_blast_input(self):
+            self.records = self._get_records()
+            self._check_sequence_contents(self.records)
+            return self.cleaned_data['blast_input']
+
         def get_target(self):
             target = self.cleaned_data["target"]
             if target == "all":
@@ -485,6 +580,7 @@ def get_groups(db):
 
 
 def make_gwas_form(biodb):
+    import pandas as pd
 
     group_choices = get_groups(biodb)
 
@@ -540,18 +636,50 @@ def __init__(self, *args, **kwargs):
                                  "margin-bottom:15px "),
                     css_class="col-lg-5 col-md-6 col-sm-6")
             )
+            self.db = biodb
             super(GwasForm, self).__init__(*args, **kwargs)
 
         def clean(self):
             cleaned_data = super(GwasForm, self).clean()
-            self.phenotype_file_or_groups()
+            self.phenotype = self.get_phenotype()
             return cleaned_data
 
-        def phenotype_file_or_groups(self):
+        def get_phenotype(self):
             has_groups = bool(self.cleaned_data["groups"])
             has_file = bool(self.cleaned_data["phenotype_file"])
             if (has_groups and has_file) or not (has_groups or has_file):
-                raise ValidationError('You have to provide either "Groups" or "Phenotype file" but not both.')
+                msg = 'You have to provide either "Groups" or '\
+                      '"Phenotype file" but not both.'
+                raise ValidationError(msg, code="invalid")
+
+            genomes = self.db.get_genomes_description()
+            if self.cleaned_data["phenotype_file"]:
+                phenotype = pd.read_csv(self.cleaned_data["phenotype_file"],
+                                        header=None, names=["taxids", "trait"])
+                phenotype["trait"] = phenotype["trait"].astype(bool)
+                if all(phenotype.taxids.isin(genomes.index)):
+                    return phenotype
+                elif all(phenotype.taxids.isin(genomes.description)):
+                    mapping = {genome.description: taxid
+                               for taxid, genome in genomes.iterrows()}
+                    phenotype.taxids = phenotype.taxids.apply(lambda x: mapping[x])
+                else:
+                    err = ValidationError(
+                        "File could not be parsed and matched to genomes.",
+                        code="invalid")
+                    self.add_error("phenotype_file", err)
+                return phenotype
+            else:
+                taxids_with_phenotype = set(self.db.get_taxids_for_groups(
+                    self.cleaned_data["groups"]))
+                if not set(genomes.index).difference(taxids_with_phenotype):
+                    err = ValidationError(
+                        "Your selection is invalid as it contains all genomes.",
+                        code="invalid")
+                    self.add_error("groups", err)
+                phenotype = [[taxid, 1 if taxid in taxids_with_phenotype else 0]
+                             for taxid in genomes.index]
+                return pd.DataFrame(phenotype, columns=["taxids", "trait"])
 
     return GwasForm
 
@@ -567,8 +695,11 @@ class CustomPlotsForm(forms.Form):
         widget=forms.Textarea(attrs={'cols': 50, 'rows': 5}),
         required=True, label="Entry IDs", help_text=help_text)
 
-    def __init__(self, *args, **kwargs):
+    Entry = namedtuple("Entry", "id label type")
+
+    def __init__(self, db, *args, **kwargs):
         super().__init__(*args, **kwargs)
+        self.db = db
         self.helper = FormHelper()
 
         self.helper.form_method = 'post'
@@ -577,7 +708,7 @@ def __init__(self, *args, **kwargs):
             Column(
                 Row(Column(
                         "entries",
-                        css_class='form-group col-lg-6 col-md-6 col-sm-12'),
+                        css_class='form-group col-lg-12 col-md-12 col-sm-12'),
                     ),
                 Row(Submit('submit', 'Make plot'),
                     css_class='form-group col-lg-12 col-md-12 col-sm-12'),
@@ -585,14 +716,20 @@ def __init__(self, *args, **kwargs):
             )
         )
 
-    def get_entries(self):
+    def clean_entries(self):
         raw_entries = self.cleaned_data["entries"].split(",")
+        parser = EntryIdParser(self.db)
         entries = []
-        entry2label = {}
         for entry in raw_entries:
             entry = entry.strip()
             if ":" in entry:
                 entry, label = entry.split(":", 1)
-                entry2label[entry] = label
-            entries.append(entry)
-        return entries, entry2label
+            else:
+                label = entry
+            try:
+                object_type, entry_id = parser.id_to_object_type(entry)
+            except Exception:
+                raise ValidationError(f'Invalid identifier "{entry}".',
+                                      code="invalid")
+            entries.append(self.Entry(entry_id, label, object_type))
+        return entries
diff --git a/webapp/lib/db_utils.py b/webapp/lib/db_utils.py
index 6c084ad20..d890f1395 100644
--- a/webapp/lib/db_utils.py
+++ b/webapp/lib/db_utils.py
@@ -2631,6 +2631,28 @@ def get_number_of_ko_entries(self):
         query = "SELECT COUNT(*) FROM (SELECT DISTINCT ko_id FROM ko_hits)"
         return self.server.adaptor.execute_and_fetchall(query)[0][0]
 
+    def check_entry_existence(self, entry_id, entry_col, table):
+        query = f'SELECT 1 FROM {table} WHERE {entry_col}="{entry_id}" LIMIT 1'
+        return bool(self.server.adaptor.execute_one(query))
+
+    def check_og_entry_id(self, entry_id):
+        return self.check_entry_existence(entry_id, "orthogroup", "og_hits")
+
+    def check_ko_entry_id(self, entry_id):
+        return self.check_entry_existence(entry_id, "ko_id", "ko_def")
+
+    def check_cog_entry_id(self, entry_id):
+        return self.check_entry_existence(entry_id, "cog_id", "cog_names")
+
+    def check_pfam_entry_id(self, entry_id):
+        return self.check_entry_existence(entry_id, "pfam_id", "pfam_table")
+
+    def check_vf_entry_id(self, entry_id):
+        return self.check_entry_existence(entry_id, "vf_gene_id", "vf_defs")
+
+    def check_amr_entry_id(self, entry_id):
+        return self.check_entry_existence(entry_id, "gene", "amr_hits")
+
     def gen_placeholder_string(self, args):
         return ",".join(self.placeholder for _ in args)
 
diff --git a/webapp/templates/chlamdb/blast.html b/webapp/templates/chlamdb/blast.html
index be3bcb439..08991c4f6 100644
--- a/webapp/templates/chlamdb/blast.html
+++ b/webapp/templates/chlamdb/blast.html
@@ -144,6 +144,8 @@
 <script type="text/javascript" src="{% static 'js/blaster.min.js' %}"></script>
 
 {% include "chlamdb/header.html" %}
+{% load crispy_forms_tags %}
+
 </head>
 
 <body>
@@ -151,133 +153,114 @@
   <div class="container-fluid" id="main_container">
     <div class="row">
       <div id="wrapper">
-          <div id="page-content-wrapper">
+        <div id="page-content-wrapper">
+          <div class="col-lg-12">
             <div class="row">
-                <div class="col-lg-12">
-                  {% include "chlamdb/menu.html" %}
-
-                  <p class="page-title"><b>Blast a sequence of interest against the genomes of the database </b><a href="https://zdb.readthedocs.io/en/latest/tutorial/website.html#homology-search-blast" id="show-option" target="_blank"><i class="fab fa-info-circle " style="size: 5em;" ></i></a></p>
-                  <hr class="lines-home">
-         
-                  <div class="panel panel-success">
-                      <div class="panel-heading" style="width:100%">
-                          <h3 class="panel-title">Help</h3>
-                      </div>
-                      <table class="table">
-                          <tr><td>ffn </td><td> CDS nucleotide sequences</td></tr>
-                          <tr><td>fna</td><td>genome sequence(s) </td></tr>
-                          <tr><td>faa</td><td>protein sequences </td></tr>
-                          <tr><td>blastn</td><td>dna sequence vs dna sequences database</td></tr>
-                          <tr><td>blastp</td><td>protein sequence vs protein sequences database</td></tr>
-                          <tr><td>blastx</td><td>translated dna sequence vs protein sequences database </td></tr>
-                          <tr><td>tblastn</td><td>protein sequence vs translated nucleotide sequences database</td></tr>
-                      </table>
-        </div>
-
-
-
-      <div class="alert alert-info fade in" style="width:80%;  margin: 10px 10px 10px 10px">
-        <a href="#" class="close" data-dismiss="alert">&times;</a>
-        <strong>Note!</strong>  The blast input can be either an amino-acid or a nucleotide sequence, or a set (one or more) of fasta sequences.
-      </div>
+              {% include "chlamdb/menu.html" %}
 
-                  <form action="{% url "blast" %}" method="post">{% csrf_token %}
-                    {{ form.as_p }}
-                    <input type="submit" value="Submit" />
-                  </form>
+              <p class="page-title">
+                <b>Blast a sequence of interest against the genomes of the database </b>
+                <a href="https://zdb.readthedocs.io/en/latest/tutorial/website.html#homology-search-blast" id="show-option" target="_blank"><i class="fab fa-info-circle " style="size: 5em;" ></i></a>
+              </p>
+              <hr class="lines-home">
 
-
-                  {% if wrong_format %}
-            <div class="panel panel-danger" style="width:80%; top: 200px; margin: 10px 10px 10px 10px">
-              <div class="panel-heading" style="width:100%">
-                <h3 class="panel-title">{{ error_title }}</h3>
+              <div class="panel panel-success">
+                <div class="panel-heading" style="width:100%">
+                    <h3 class="panel-title">Help</h3>
+                </div>
+                <table class="table">
+                  <tr><td>ffn </td><td> CDS nucleotide sequences</td></tr>
+                  <tr><td>fna</td><td>genome sequence(s) </td></tr>
+                  <tr><td>faa</td><td>protein sequences </td></tr>
+                  <tr><td>blastn</td><td>dna sequence vs dna sequences database</td></tr>
+                  <tr><td>blastp</td><td>protein sequence vs protein sequences database</td></tr>
+                  <tr><td>blastx</td><td>translated dna sequence vs protein sequences database </td></tr>
+                  <tr><td>tblastn</td><td>protein sequence vs translated nucleotide sequences database</td></tr>
+                </table>
               </div>
-              {{ error_message }}
+
+              {% block content %}
+                {% csrf_token %}
+                {% crispy form %}
+              {% endblock %}
             </div>
+            {% if envoi %}
+              <div class="row" style="background-color: rgba(245, 245, 245, 0.986)">
+                <div class="panel panel-success" style="margin:1em;">
+                  <div class="panel-heading" style="width:100%">
+                    <h5 class="panel-title">Help to interpret the results</h5>
+                  </div>
+                  <p style="margin: 10px 10px 10px 10px">
+                    The blast search generates two output pages according to the search parameters set up in the analysis:
+                    <br><b>Details</b>: this page showa the graphical overview of blast hits identified on the genome(s) of interest colored according to the max score or E-value. Each hit is listed in the following table. It reportes the alignment scores and the contigs or locus tags of the match (Note that the locus tag is clickable and redirects you to a comphensive locus tag overview).
+
+                    {% if phylo_distrib %}
+                      <br><b>Phylogenetic distribution</b>: Heatmap of the amino-acid/nucleotide identity of the best hit for each taxa.
+                    {% endif %}
+                  </p>
+                </div>
+                <div class="col-lg-12">
+                  {% if phylo_distrib %}
+                    <nav>
+                      <ul id="tabs_blast" class="nav nav-tabs">
+                        <li class="active">
+                          <a href="#blast_details" data-toggle="tab">
+                            Details
+                          </a>
+                        </li>
+                        <li>
+                          <a href="#phylo_distrib" data-toggle="tab">
+                            Phylogenetic distribution
+                          </a>
+                        </li>
+                      </ul>
+                    </nav>
                   {% endif %}
 
+                  <div class="tab-content">
+                    <div class="tab-pane active" id="blast_details">
+
+                      {% if js_out %}
+                        <div id='snippetDiv'></div>
+                        <div id="blast-multiple-alignments"></div>
+                        <div id="blast-alignments-table"></div>
+                        <div id="blast-single-alignment"></div>
+                      {% endif %}
 
-                  {% if envoi %}
-        <br>
-          <div class="row" style="padding-top:1em ;background-color: rgba(245, 245, 245, 0.986)" >
-                    <div class="panel panel-success" style="margin:1em;">
-                        <div class="panel-heading" style="width:100%">
-                            <h5 class="panel-title">Help to interpret the results</h5>
+                      {% if blast_result %}
+                        <h3>Result</h3>
+                        <div id="blast_res">
+                          {% autoescape off %}{{blast_result}}{% endautoescape %}
                         </div>
-                        <p style="margin: 10px 10px 10px 10px">
-                            The blast search generates two output pages according to the search parameters set up in the analysis:
-                            <br><b>Details</b>: this page showa the graphical overview of blast hits identified on the genome(s) of interest colored according to the max score or E-value. Each hit is listed in the following table. It reportes the alignment scores and the contigs or locus tags of the match (Note that the locus tag is clickable and redirects you to a comphensive locus tag overview).
-              {% if phylo_distrib %}
-              <br><b>Phylogenetic distribution</b>: Heatmap of the amino-acid/nucleotide identity of the best hit for each taxa.
-              {% endif %}
-                        </p>
+                      {% elif blast_no_hits %}
+                        <h3>No hits</h3>
+                      {% elif blast_err %}
+                        <h3>Error</h3>
+                        <pre id="blast_result">
+                          {% autoescape off %}{{blast_err}}{% endautoescape %}
+                        </pre>
+                      {% endif %}
                     </div>
-                    </div>
-                </div>
-             {% if phylo_distrib %}
-             <br>
-              <nav>
-              <ul id="tabs_blast" class="nav nav-tabs">
-                <li class="active">
-                  <a href="#blast_details" data-toggle="tab">
-                    Details
-                  </a>
-                </li>
-                <li>
-                  <a href="#phylo_distrib" data-toggle="tab">
-                    Phylogenetic distribution
-                  </a>
-                </li>
-              </ul>
-            </nav>
-            {% endif %}
-
-
-            <div class="tab-content">
-              <div class="tab-pane active" id="blast_details">
-
-                {% if js_out %}
-                  <div id='snippetDiv'></div>
-                  <div id="blast-multiple-alignments"></div>
-                  <div id="blast-alignments-table"></div>
-                  <div id="blast-single-alignment"></div>
-                {% endif %}
-
-                {% if blast_result %}
-                  <h3>Result</h3>
-                   <div id="blast_res">
-                  {% autoescape off %}{{blast_result}}{% endautoescape %}</div>
-                {% elif blast_no_hits %}
-                  <h3>No hits</h3>
-                {% elif blast_err %}
-                  <h3>Error</h3>
-                  <pre id="blast_result">
-                   {% autoescape off %}{{blast_err}}{% endautoescape %}
-                  </pre>
-                {% endif %}
-              </div>
-
-              {% if phylo_distrib %}
-                <div class="tab-pane" id="phylo_distrib">
-
-                <br>
-                  <object type="image/svg+xml" data="{% static asset_path %}">
-                  </object>
 
-                  <a download="profile.svg" class="btn" href="{% static asset_path %}">
-                    <i class="fa fa-download"></i> Download SVG</a>
-                </div>
-              {% endif %}
-            </div>
+                    {% if phylo_distrib %}
+                      <div class="tab-pane" id="phylo_distrib">
+                        <br>
+                        <object type="image/svg+xml" data="{% static asset_path %}"></object>
 
-
-                  {% endif %}
-                  
+                        <a download="profile.svg" class="btn" href="{% static asset_path %}">
+                          <i class="fa fa-download"></i> Download SVG
+                        </a>
+                      </div>
+                    {% endif %}
+                  </div>
                 </div>
               </div>
-            </div>
+            {% endif %}
           </div>
         </div>
+      </div>
+    </div>
+  </div>
 </body>
 
 <script>
diff --git a/webapp/templates/chlamdb/plot_region.html b/webapp/templates/chlamdb/plot_region.html
index 5e858db87..208be7158 100644
--- a/webapp/templates/chlamdb/plot_region.html
+++ b/webapp/templates/chlamdb/plot_region.html
@@ -109,14 +109,13 @@ <h5 class="panel-title">Genomic regions</h5>
 var regions = {{genomic_regions|safe}};
 var to_highlight = {{to_highlight|safe}};
 var connections = {{connections | safe}};
-var window_size = {{window_size}};
 var ident_range = [{{min_ident}}, {{max_ident}}];
 var genomic_region_rect = document.querySelector("#div_alignment_bounding")
     .getBoundingClientRect();
 var genomic_width = genomic_region_rect.right-genomic_region_rect.left;
 
 createGenomicRegion(d3.select("#div_alignment"), genomic_width*0.95, "genomic_region",
-    regions, connections, to_highlight, window_size, ident_range);
+    regions, connections, to_highlight, ident_range);
 
 document.querySelector("#download_svg_button").onclick = function() {
   var svg_elem = document.querySelector("#genomic_region");
diff --git a/webapp/views/custom_plots.py b/webapp/views/custom_plots.py
index 3a1d5a255..7a14a4092 100644
--- a/webapp/views/custom_plots.py
+++ b/webapp/views/custom_plots.py
@@ -6,10 +6,9 @@
 from lib.db_utils import DB
 from lib.ete_phylo import EteTree, SimpleColorColumn
 
-from views.errors import errors
 from views.mixins import ComparisonViewMixin
 from views.object_type_metadata import my_locals
-from views.utils import EntryIdIdentifier, ResultTab, TabularResultTab
+from views.utils import ResultTab, TabularResultTab
 
 
 class CusomPlotsView(View):
@@ -52,29 +51,25 @@ def get_context(self, **kwargs):
         return my_locals(context)
 
     def get(self, request, *args, **kwargs):
-        self.form = self.form_class()
+        self.form = self.form_class(self.db)
         return render(request, self.template, self.get_context())
 
     def post(self, request, *args, **kwargs):
-        self.form = self.form_class(request.POST)
+        self.form = self.form_class(self.db, request.POST)
         if not self.form.is_valid():
-            self.form = self.form_class()
-            return render(request, self.template,
-                          self.get_context(**errors["invalid_form"]))
+            return render(request, self.template, self.get_context())
 
-        entries, entry2label = self.form.get_entries()
+        entries = self.form.cleaned_data["entries"]
 
         # We make 1 query for each entry, although we could of course make
         # a single query for each object type, but I don't expect any
         # performance issues here, so I'd rather keep it simple (and maintain
         # the order of the entries as defined by the user).
-        entry_id_identifier = EntryIdIdentifier()
         counts = []
         for entry in entries:
-            object_type, entry_id = entry_id_identifier.id_to_object_type(entry)
-            mixin = ComparisonViewMixin.type2mixin[object_type]
-            hits = mixin().get_hit_counts([entry_id], search_on=object_type)
-            hits = hits.rename({entry_id: entry2label.get(entry, entry)})
+            mixin = ComparisonViewMixin.type2mixin[entry.type]
+            hits = mixin().get_hit_counts([entry.id], search_on=entry.type)
+            hits = hits.rename({entry.id: entry.label})
             counts.append(hits)
 
         genome_descriptions = self.db.get_genomes_description()
diff --git a/webapp/views/errors.py b/webapp/views/errors.py
index 388fb81c6..7449c9cf7 100644
--- a/webapp/views/errors.py
+++ b/webapp/views/errors.py
@@ -5,30 +5,14 @@
         "error_title": "Empty result set.",
         "error_message":  "No hits were found for the current selection."
     },
-    "invalid_form": {
-        "error": True,
-        "error_title": "Invalid input.",
-        "error_message":  "Form data is invalid."
-    },
-    "generic_error": {
-        "error": True,
-        "error_title": "Error.",
-        "error_message":  "Something went wrong."
-    },
     "no_module_info": {
         "error": True,
         "error_title": "No information.",
         "error_message":  "No information was found for this module."
     },
-    "wrong_n_missing": {
+    "unknown_accession": {
         "error": True,
-        "error_title": "Invalid form.",
-        "error_message":  "You cannot set a number of missing data bigger "\
-                          "than the number of included genomes"
+        "error_title": "Unknown accession.",
+        "error_message":  "Accepts protein ids, locus tags and orthogroup IDs."
     },
-    "too_many_targets": {
-        "error": True,
-        "error_title": "Invalid form.",
-        "error_message":  "Venn diagrams are limited to 6 genomes."
-    }
 }
diff --git a/webapp/views/gwas.py b/webapp/views/gwas.py
index 49d4a500e..bf5605ab2 100644
--- a/webapp/views/gwas.py
+++ b/webapp/views/gwas.py
@@ -4,7 +4,6 @@
 import pandas as pd
 from chlamdb.forms import make_gwas_form
 from django.conf import settings
-from django.core.exceptions import ValidationError
 from django.shortcuts import render
 from django.views import View
 from ete3 import Tree
@@ -75,10 +74,7 @@ def post(self, request, *args, **kwargs):
 
         qval_threshold = self.form.cleaned_data["bonferroni_cutoff"]
         max_genes = self.form.cleaned_data["max_number_of_hits"]
-        phenotype = self.get_phenotype()
-
-        if phenotype is None:
-            return render(request, self.template, self.get_context())
+        phenotype = self.form.phenotype
 
         results, hits = self.run_gwas(phenotype, qval_threshold, max_genes)
         if results is None:
@@ -139,38 +135,6 @@ def prepare_tree(self, phenotype, hits, results):
             e_tree.add_column(col_column)
         return e_tree
 
-    def get_phenotype(self):
-        genomes = self.db.get_genomes_description()
-        if self.form.cleaned_data["phenotype_file"]:
-            phenotype = pd.read_csv(self.form.cleaned_data["phenotype_file"],
-                                    header=None, names=["taxids", "trait"])
-            phenotype["trait"] = phenotype["trait"].astype(bool)
-            if all(phenotype.taxids.isin(genomes.index)):
-                return phenotype
-            elif all(phenotype.taxids.isin(genomes.description)):
-                mapping = {genome.description: taxid
-                           for taxid, genome in genomes.iterrows()}
-                phenotype.taxids = phenotype.taxids.apply(lambda x: mapping[x])
-            else:
-                err = ValidationError(
-                    "File could not be parsed and matched to genomes.",
-                    code="invalid")
-                self.form.add_error("phenotype_file", err)
-                return None
-            return phenotype
-        else:
-            taxids_with_phenotype = set(self.db.get_taxids_for_groups(
-                self.form.cleaned_data["groups"]))
-            if not set(genomes.index).difference(taxids_with_phenotype):
-                err = ValidationError(
-                    "Your selection is invalid as it contains all genomes.",
-                    code="invalid")
-                self.form.add_error("groups", err)
-                return None
-            phenotype = [[taxid, 1 if taxid in taxids_with_phenotype else 0]
-                         for taxid in genomes.index]
-            return pd.DataFrame(phenotype, columns=["taxids", "trait"])
-
     def run_gwas(self, phenotype, qval_threshold, max_genes):
         genomes_data = self.db.get_genomes_infos()
         all_taxids_str = [str(i) for i in genomes_data.index.to_list()]
diff --git a/webapp/views/hits_extraction.py b/webapp/views/hits_extraction.py
index 2929ed918..ef296518c 100644
--- a/webapp/views/hits_extraction.py
+++ b/webapp/views/hits_extraction.py
@@ -81,12 +81,12 @@ def get_context(self, **kwargs):
         if getattr(self, "show_results", False):
             context.update({
                 "show_results": True,
-                "n_missing": self.n_missing,
+                "n_missing": self.form.n_missing,
                 "n_hits": self.n_hits,
                 "table_headers": self.table_headers,
                 "table_data": self.table_data,
-                "included_taxids": self.included_taxids,
-                "excluded_taxids": self.excluded_taxids,
+                "included_taxids": self.form.included_taxids,
+                "excluded_taxids": self.form.excluded_taxids,
                 "selection": self.selection,
                 "result_tabs": self.result_tabs,
                 })
@@ -103,49 +103,36 @@ def _to_percent(count, tot):
     def post(self, request, *args, **kwargs):
         self.form = self.extract_form_class(request.POST)
         if not self.form.is_valid():
-            self.form = self.extract_form_class()
-            return render(request, self.template,
-                          self.get_context(**errors["invalid_form"]))
+            return render(request, self.template, self.get_context())
 
         # Extract form data
-        self.included_taxids, self.included_plasmids = self.form.get_include_choices()
-        self.excluded_taxids, self.excluded_plasmids = self.form.get_exclude_choices()
-        self.n_missing = self.form.get_n_missing()
         self.single_copy = "checkbox_single_copy" in request.POST
 
-        self.n_included = len(self.included_taxids)
-        if self.included_plasmids is not None:
-            self.n_included += len(self.included_plasmids)
+        self.min_fraq = int((self.form.n_included - self.form.n_missing) /
+                            self.form.n_included * 100)
 
-        if self.n_missing >= self.n_included:
-            context = self.get_context(**errors["wrong_n_missing"])
-            return render(request, self.template, context)
-
-        self.min_fraq = int((self.n_included - self.n_missing) /
-                            self.n_included * 100)
-
-        self.n_excluded = len(self.excluded_taxids)
-        if self.excluded_plasmids is not None:
-            self.n_excluded += len(self.excluded_plasmids)
+        self.n_excluded = len(self.form.excluded_taxids)
+        if self.form.excluded_plasmids is not None:
+            self.n_excluded += len(self.form.excluded_plasmids)
 
         # Count hits for selection
-        hit_counts = self.get_hit_counts(self.included_taxids,
-                                         plasmids=self.included_plasmids,
+        hit_counts = self.get_hit_counts(self.form.included_taxids,
+                                         plasmids=self.form.included_plasmids,
                                          search_on="taxid")
         if not self.single_copy:
             hit_counts["presence"] = self._to_percent(
-                hit_counts[hit_counts > 0].count(axis=1), self.n_included)
+                hit_counts[hit_counts > 0].count(axis=1), self.form.n_included)
             hit_counts["selection"] = hit_counts.presence >= self.min_fraq
         else:
             excluded_hits = hit_counts[hit_counts > 1].count(axis=1)
             hit_counts["presence"] = self._to_percent(
-                hit_counts[hit_counts == 1].count(axis=1), self.n_included)
+                hit_counts[hit_counts == 1].count(axis=1), self.form.n_included)
             hit_counts["selection"] = ((hit_counts.presence >= self.min_fraq)
                                        & (excluded_hits == 0))
 
         if self.n_excluded > 0:
             mat_exclude = self.get_hit_counts(
-                self.excluded_taxids, plasmids=self.excluded_plasmids,
+                self.form.excluded_taxids, plasmids=self.form.excluded_plasmids,
                 search_on="taxid")
             mat_exclude["presence"] = mat_exclude[mat_exclude > 0].count(axis=1)
             mat_exclude["exclude"] = mat_exclude.presence > 0
@@ -262,9 +249,9 @@ def get_table_details(db, annotations):
     def prepare_data(self, hit_counts, hit_counts_all):
         self.table_data = []
 
-        all_taxids = self.included_taxids
-        if self.included_plasmids is not None:
-            all_taxids += self.included_plasmids
+        all_taxids = self.form.included_taxids
+        if self.form.included_plasmids is not None:
+            all_taxids += self.form.included_plasmids
 
         annotations = self.db.get_genes_from_og(
             orthogroups=self.selection,
@@ -304,7 +291,7 @@ def prepare_data(self, hit_counts, hit_counts_all):
             self.table_data.append(entry)
 
         ref_genomes = self.db.get_genomes_description(
-        ).loc[self.included_taxids].reset_index()
+        ).loc[self.form.included_taxids].reset_index()
 
         details_header, details_data = self.get_table_details(self.db, annotations)
 
diff --git a/webapp/views/utils.py b/webapp/views/utils.py
index 475ad1592..e05ac231d 100644
--- a/webapp/views/utils.py
+++ b/webapp/views/utils.py
@@ -283,7 +283,7 @@ def __init__(self, tabid, title, template="chlamdb/result_table.html",
             tabid, title, template, show_badge=show_badge, badge=badge, **kwargs)
 
 
-class EntryIdIdentifier():
+class EntryIdParser():
 
     og_re = re.compile("group_([0-9]*)")
     cog_re = re.compile("COG([0-9]{4})")
@@ -291,27 +291,38 @@ class EntryIdIdentifier():
     ko_re = re.compile("K([0-9]{5})")
     vf_re = re.compile("VFG[0-9]{6}")
 
+    def __init__(self, db):
+        self.db = db
+
     def id_to_object_type(self, identifier):
         match = self.og_re.match(identifier)
-        if match:
-            return "orthogroup", int(match.groups()[0])
+        parsed_id = match and int(match.groups()[0])
+        if parsed_id and self.db.check_orthogroup_entry_id(parsed_id):
+            return "orthogroup", parsed_id
 
         match = self.cog_re.match(identifier)
-        if match:
-            return "cog", int(match.groups()[0])
+        parsed_id = match and int(match.groups()[0])
+        if parsed_id and self.db.check_cog_entry_id(parsed_id):
+            return "cog", parsed_id
 
         match = self.pfam_re.match(identifier)
-        if match:
-            return "pfam", int(match.groups()[0])
+        parsed_id = match and int(match.groups()[0])
+        if parsed_id and self.db.check_pfam_entry_id(parsed_id):
+            return "pfam", parsed_id
 
         match = self.ko_re.match(identifier)
-        if match:
-            return "ko", int(match.groups()[0])
+        parsed_id = match and int(match.groups()[0])
+        if parsed_id and self.db.check_ko_entry_id(parsed_id):
+            return "ko", parsed_id
 
         match = self.vf_re.match(identifier)
-        if match:
+        if match and self.db.check_vf_entry_id(identifier):
             return "vf", identifier
-        return "amr", identifier
+
+        if self.db.check_amr_entry_id(identifier):
+            return "amr", identifier
+
+        return None
 
 
 def locusx_genomic_region(db, seqid, window):
diff --git a/webapp/views/venn.py b/webapp/views/venn.py
index fcc45fddb..689296f46 100644
--- a/webapp/views/venn.py
+++ b/webapp/views/venn.py
@@ -51,15 +51,9 @@ def _to_percent(count, tot):
     def post(self, request, *args, **kwargs):
         self.form = self.form_class(request.POST)
         if not self.form.is_valid():
-            self.form = self.form_class()
-            return render(request, self.template,
-                          self.get_context(**errors["invalid_form"]))
+            return render(request, self.template, self.get_context())
 
         self.targets = self.form.get_taxids()
-        if len(self.targets) > 6:
-            self.form = self.form_class()
-            return render(request, self.template,
-                          self.get_context(**errors["too_many_targets"]))
         return self.render_venn(request)
 
     def render_venn(self, request):
diff --git a/webapp/views/views.py b/webapp/views/views.py
index 6a55b81f1..4fa8618ea 100644
--- a/webapp/views/views.py
+++ b/webapp/views/views.py
@@ -21,8 +21,6 @@
                                     NcbiblastpCommandline,
                                     NcbiblastxCommandline,
                                     NcbitblastnCommandline)
-from Bio.Seq import Seq
-from Bio.SeqRecord import SeqRecord
 from chlamdb.forms import (make_blast_form, make_circos_form, make_metabo_from,
                            make_module_overview_form,
                            make_pathway_overview_form, make_plot_form,
@@ -459,9 +457,8 @@ def KEGG_module_map(request, module_name):
     try:
         module_id = int(module_name[len("M"):])
     except Exception:
-        error = True
-        error_title = "Unknown accession"
-        error_message = "Accepts protein ids, locus tags and orthogroup IDs"
+        context = my_locals(locals())
+        context.update(errors["unknown_accession"])
         return render(request, 'chlamdb/KEGG_module_map.html',
                       my_locals(locals()))
 
@@ -858,7 +855,7 @@ def post(self, request, *args, **kwargs):
         self.form = self.form_class(request.POST)
         if not self.form.is_valid():
             return render(request, 'chlamdb/cog_barplot.html',
-                          self.get_context(**errors["invalid_form"]))
+                          self.get_context())
 
         target_bioentries = self.form.get_taxids()
 
@@ -937,6 +934,7 @@ class PanGenome(ComparisonViewMixin, View):
     @property
     def form_class(self):
         return make_venn_from(self.db, label=self.object_name_plural,
+                              limit=2, limit_type="lower",
                               action=f"/pan_genome/{self.object_type}")
 
     def get(self, request, *args, **kwargs):
@@ -947,10 +945,8 @@ def get(self, request, *args, **kwargs):
     def post(self, request, *args, **kwargs):
         self.form = self.form_class(request.POST)
         if not self.form.is_valid():
-            self.form = self.form_class()
             return render(request, 'chlamdb/pan_genome.html',
-                          self.get_context(**errors["invalid_form"],
-                                           form=self.form))
+                          self.get_context(form=self.form))
 
         taxids = self.form.get_taxids()
         df_hits = self.get_hit_counts(taxids, search_on="taxid")
@@ -1084,67 +1080,12 @@ def blast(request):
         return render(request, 'chlamdb/blast.html',
                       my_locals({"form": form, "page_title": page_title}))
 
-    input_sequence = form.cleaned_data['blast_input']
     number_blast_hits = form.cleaned_data['max_number_of_hits']
     blast_type = form.cleaned_data['blast']
     target = form.get_target()
-    no_query_name = False
-
-    if '>' in input_sequence:
-        try:
-            records = [i for i in SeqIO.parse(StringIO(input_sequence), 'fasta')]
-            for record in records:
-                if len(record.seq) == 0:
-                    context = {
-                        "error_message": "Empty sequence in input",
-                        "error_title": "Query format error", "envoi": True,
-                        "form": form, "wrong_format": True,
-                        "page_title": page_title}
-                    return render(request, 'chlamdb/blast.html',
-                                  my_locals(context))
-        except Exception:
-            context = {"error_message": "Error while parsing the fasta query",
-                       "error_title": "Query format error",
-                       "envoi": True, "form": form, "wrong_format": True,
-                       "page_title": page_title}
-            return render(request, 'chlamdb/blast.html', my_locals(context))
-    else:
-        no_query_name = True
-        input_sequence = "".join(input_sequence.split()).upper()
-        records = [SeqRecord(Seq(input_sequence))]
-
-    dna = set("ATGCNRYKMSWBDHV")
-    prot = set('ACDEFGHIKLMNPQRSTVWYXZJOU')
-    sequence_set = set()
-    for rec in records:
-        sequence_set = sequence_set.union(set(rec.seq.upper()))
-    check_seq_DNA = sequence_set - dna
-    check_seq_prot = sequence_set - prot
-
-    if check_seq_prot and blast_type in ["blastp", "tblastn"]:
-        wrong_chars = ", ".join(check_seq_prot)
-        if len(check_seq_prot) > 1:
-            errmsg = f"Unexpected characters in amino-acid query: {wrong_chars}"
-        else:
-            errmsg = f"Unexpected character in amino-acid query: {wrong_chars}"
-        context = {"error_message": errmsg, "error_title": "Query format error",
-                   "envoi": True, "form": form, "wrong_format": True,
-                   "page_title": page_title}
-        return render(request, 'chlamdb/blast.html', my_locals(context))
-    elif check_seq_DNA and blast_type in ["blastn", "blastn_ffn",
-                                          "blast_fna", "blastx"]:
-        wrong_chars = ", ".join(check_seq_DNA)
-        if len(check_seq_DNA) > 1:
-            errmsg = f"Unexpected characters in nucleotide query: {wrong_chars}"
-        else:
-            errmsg = f"Unexpected character in nucleotide query: {wrong_chars}"
-        context = {"error_message": errmsg, "wrong_format": True,
-                   "error_title": "Query format error", "envoi": True,
-                   "form": form, "page_title": page_title}
-        return render(request, 'chlamdb/blast.html', my_locals(context))
 
     query_file = NamedTemporaryFile(mode='w')
-    SeqIO.write(records, query_file, "fasta")
+    SeqIO.write(form.records, query_file, "fasta")
     query_file.flush()
 
     if target == 'all':
@@ -1180,7 +1121,7 @@ def blast(request):
     else:
         if target == "all":
             asset_path = gen_blast_heatmap(db, blast_stdout,
-                                           blast_type, no_query_name)
+                                           blast_type, form.no_query_name)
         rand_id = id_generator(6)
         blast_file_l = settings.BASE_DIR + '/assets/temp/%s.xml' % rand_id
         f = open(blast_file_l, 'w')
@@ -1216,7 +1157,6 @@ def coalesce_regions(genomic_regions, seqids):
 
 
 def plot_region(request):
-    max_region_size = 100000
     db = DB.load_db(settings.BIODB_DB_PATH, settings.BIODB_CONF)
     page_title = page2title["plot_region"]
     form_class = make_plot_form(db)
@@ -1228,23 +1168,12 @@ def plot_region(request):
 
     form = form_class(request.POST)
     if not form.is_valid():
-        # add error message
         return render(request, 'chlamdb/plot_region.html',
                       my_locals({"form": form, "page_title": page_title}))
 
-    accession = form.get_accession()
-    prot_info = db.get_proteins_info(
-        ids=[accession], search_on="locus_tag", as_df=True)
-    if prot_info.empty:
-        context = {"form": form,
-                   "errors": ["Accession not found"],
-                   "error": True,
-                   "page_title": page_title}
-        return render(request, 'chlamdb/plot_region.html', my_locals(context))
-
+    seqid = form.get_seqid()
     genomes = form.get_genomes()
     all_homologs = form.get_all_homologs()
-    seqid = int(prot_info.index[0])
     hsh_loc = db.get_gene_loc([seqid])
     ids = db.get_og_identity(ref_seqid=seqid)
     all_seqids = ids.index.unique().tolist()
@@ -1282,23 +1211,7 @@ def plot_region(request):
         }
         return render(request, 'chlamdb/plot_region.html', my_locals(context))
 
-    try:
-        region_size = form.get_region_size()
-        if region_size > max_region_size or region_size < 5000:
-            context = {
-                "form": form,
-                "error": True,
-                "errors": [f"Region size should be between 5000 and {max_region_size} bp"],
-                "page_title": page_title
-            }
-            return render(request, 'chlamdb/plot_region.html',
-                          my_locals(context))
-    except ValueError:
-        context = {"form": form,
-                   "error": True,
-                   "errors": ["Wrong format for region size"],
-                   "page_title": page_title}
-        return render(request, 'chlamdb/plot_region.html', my_locals(context))
+    region_size = form.get_region_size()
 
     locus_tags = db.get_proteins_info(
         seqids, to_return=["locus_tag"], as_df=True)
@@ -1375,7 +1288,6 @@ def plot_region(request):
 
     ctx = {"form": form,
            "genomic_regions": "[" + "\n,".join(all_regions) + "]",
-           "window_size": max_region_size,
            "to_highlight": to_highlight,
            "envoi": True,
            "connections": "[" + ",".join(connections) + "]",
@@ -1542,8 +1454,6 @@ def circos(request):
         form = circos_form_class()
 
     local_vars = my_locals(locals())
-    # local_vars["form"] = form
-
     return render(request, 'chlamdb/circos.html', local_vars)
 
 
@@ -1562,6 +1472,7 @@ class PlotHeatmap(ComparisonViewMixin, View):
     @property
     def form_class(self):
         return make_venn_from(self.db, label=self.object_name_plural,
+                              limit=2, limit_type="lower",
                               action=f"/plot_heatmap/{self.object_type}")
 
     def get(self, request, *args, **kwargs):
@@ -1573,27 +1484,15 @@ def post(self, request, *args, **kwargs):
         self.form = self.form_class(request.POST)
         if not self.form.is_valid():
             return render(request, 'chlamdb/plot_heatmap.html',
-                          self.get_context(form=self.form,
-                                           **errors["invalid_form"]))
+                          self.get_context(form=self.form))
 
         import plotly.graph_objects as go
         import scipy.cluster.hierarchy as shc
         from scipy.cluster import hierarchy
 
         taxon_ids = self.form.get_taxids()
-
-        if len(taxon_ids) <= 1:
-            error_message = "Please select at least two genomes"
-            error_title = "Wrong input"
-            ctx = self.get_context(error=True, error_title=error_title,
-                                   error_message=error_message,
-                                   form=self.form)
-            return render(request, 'chlamdb/plot_heatmap.html', ctx)
-
         mat = self.get_hit_counts(taxon_ids, search_on="taxid")
         if mat.empty:
-            error_message = "No hits were found for the current selection."
-            error_title = "No hits"
             ctx = self.get_context(**errors["no_hits"],
                                    form=self.form)
             return render(request, 'chlamdb/plot_heatmap.html', ctx)
@@ -1653,7 +1552,6 @@ def kegg_genomes(request):
 
     form = single_genome_form(request.POST)
     if not form.is_valid():
-        form = single_genome_form()
         return render(request, 'chlamdb/kegg_genomes.html',
                       my_locals(locals()))
 
@@ -1701,7 +1599,6 @@ def kegg_genomes_modules(request):
 
     form = single_genome_form(request.POST)
     if not form.is_valid():
-        form = single_genome_form()
         return render(request, 'chlamdb/kegg_genomes_modules.html',
                       my_locals(locals()))
 
@@ -1778,10 +1675,8 @@ def kegg_module_subcat(request):
 
     form = module_overview_form(request.POST)
     if not form.is_valid():
-        form = module_overview_form()
-        context = my_locals(locals())
-        context.update(errors["invalid_form"])
-        return render(request, 'chlamdb/module_subcat.html', context)
+        return render(request, 'chlamdb/module_subcat.html',
+                      my_locals(locals()))
 
     cat = form.cleaned_data["subcategory"]
     ko_count_subcat = db.get_ko_count_cat(subcategory=cat)
@@ -1851,10 +1746,8 @@ def kegg_module(request):
 
     form = module_overview_form(request.POST)
     if not form.is_valid():
-        context = my_locals(locals())
-        context.update(errors["invalid_form"])
-        form = module_overview_form()
-        return render(request, 'chlamdb/module_overview.html', context)
+        return render(request, 'chlamdb/module_overview.html',
+                      my_locals(locals()))
 
     cat = form.cleaned_data["category"]
     modules_infos = db.get_modules_info(ids=[cat], search_on="category")
@@ -1921,15 +1814,10 @@ def module_comparison(request):
 
     form = comp_metabo_form(request.POST)
     if not form.is_valid():
-        form = comp_metabo_form()
         return render(request, 'chlamdb/module_comp.html', my_locals(locals()))
 
     taxids = form.get_choices()
 
-    if len(taxids) == 0:
-        form = comp_metabo_form()
-        return render(request, 'chlamdb/module_comp.html', my_locals(locals()))
-
     module_hits = db.get_ko_count_cat(taxon_ids=taxids)
     tipo = type(taxids)
     grouped_count = module_hits.groupby(["taxon_id", "module_id"]).sum()