diff --git a/release-notes/CREDITS b/release-notes/CREDITS
index ea0c5c7..f32a8c9 100644
--- a/release-notes/CREDITS
+++ b/release-notes/CREDITS
@@ -217,9 +217,14 @@
    [1.3.1]
 
 Mike Pilone
+  * Suggested [JACKSON-201]: Allow serialization of "empty beans" (classes
+    without getters), if SerializationConfig.Feature.FAIL_ON_EMPTY_BEANS is
+    disabled; or if class has recognized Jackson annotation
+   [1.4.0]
   * Reported [JACKSON-202]: Non-public fields not deserialized properly
     with JAXB annotations
    [1.3.1]
+  
 
 Stephen Friedrich
   * Reported additional issues with [JACKSON-203]
diff --git a/release-notes/VERSION b/release-notes/VERSION
index ec510ba..c250a56 100644
--- a/release-notes/VERSION
+++ b/release-notes/VERSION
@@ -26,6 +26,10 @@
   * [JACKSON-192] Added basic delegate implementations (JsonParserDelegate,
     JsonGeneratorDelegate) to make it easier to override core parser and
     generate behavior
+  * [JACKSON-201] Allow serialization of "empty beans" (classes without
+    getters), if SerializationConfig.Feature.FAIL_ON_EMPTY_BEANS is
+    disabled; or if class has recognized Jackson annotation
+   (suggested by Mike P)
 
   Other:
 
diff --git a/src/mapper/java/org/codehaus/jackson/map/SerializationConfig.java b/src/mapper/java/org/codehaus/jackson/map/SerializationConfig.java
index 954e8fa..637a361 100644
--- a/src/mapper/java/org/codehaus/jackson/map/SerializationConfig.java
+++ b/src/mapper/java/org/codehaus/jackson/map/SerializationConfig.java
@@ -151,6 +151,23 @@
          */
         ,WRAP_ROOT_VALUE(false)
 
+        /**
+         * Feature that determines what happens when no accessors are
+         * found for a type (and there are no annotations to indicate
+         * it is meant to be serialized). If enabled (default), an
+         * exception is thrown to indicate these as non-serializable
+         * types; if disabled, they are serialized as empty Objects,
+         * i.e. without any properties.
+         *<p>
+         * Note that empty types that this feature has only effect on
+         * those "empty" beans that do not have any recognized annotations
+         * (like <code>@JsonSerialize</code>): ones that do have annotations
+         * do not result in an exception being thrown.
+         *
+         * @since 1.4
+         */
+         ,FAIL_ON_EMPTY_BEANS(true)
+
         // // // Features for datatype-specific serialization
 
         /**
diff --git a/src/mapper/java/org/codehaus/jackson/map/introspect/AnnotatedClass.java b/src/mapper/java/org/codehaus/jackson/map/introspect/AnnotatedClass.java
index 944c2bd..76fbcc1 100644
--- a/src/mapper/java/org/codehaus/jackson/map/introspect/AnnotatedClass.java
+++ b/src/mapper/java/org/codehaus/jackson/map/introspect/AnnotatedClass.java
@@ -172,6 +172,8 @@
     ///////////////////////////////////////////////////////
      */
 
+    public boolean hasAnnotations() { return _classAnnotations.size() > 0; }
+
     public AnnotatedConstructor getDefaultConstructor() { return _defaultConstructor; }
 
     public List<AnnotatedConstructor> getConstructors()
diff --git a/src/mapper/java/org/codehaus/jackson/map/introspect/BasicBeanDescription.java b/src/mapper/java/org/codehaus/jackson/map/introspect/BasicBeanDescription.java
index b8f9f4c..2f7c055 100644
--- a/src/mapper/java/org/codehaus/jackson/map/introspect/BasicBeanDescription.java
+++ b/src/mapper/java/org/codehaus/jackson/map/introspect/BasicBeanDescription.java
@@ -49,6 +49,16 @@
 
     public AnnotatedClass getClassInfo() { return _classInfo; }
 
+    public Class<?> classDescribed() { return _classInfo.getAnnotated(); }
+
+    /**
+     * Method for checking whether class being described has any
+     * annotations recognized by registered annotation introspector.
+     */
+    public boolean hasKnownClassAnnotations() {
+        return _classInfo.hasAnnotations();
+    }
+
     public AnnotatedMethod findMethod(String name, Class<?>[] paramTypes)
     {
         return _classInfo.findMethod(name, paramTypes);
diff --git a/src/mapper/java/org/codehaus/jackson/map/ser/BeanSerializer.java b/src/mapper/java/org/codehaus/jackson/map/ser/BeanSerializer.java
index 91ad16c..3ede7b7 100644
--- a/src/mapper/java/org/codehaus/jackson/map/ser/BeanSerializer.java
+++ b/src/mapper/java/org/codehaus/jackson/map/ser/BeanSerializer.java
@@ -25,16 +25,14 @@
     extends SerializerBase<Object>
     implements ResolvableSerializer, SchemaAware
 {
+    final static BeanPropertyWriter[] NO_PROPS = new BeanPropertyWriter[0];
+
     final protected String _className;
 
     final protected BeanPropertyWriter[] _props;
 
     public BeanSerializer(Class<?> type, BeanPropertyWriter[] props)
     {
-        // sanity check
-        if (props.length == 0) {
-            throw new IllegalArgumentException("Can not create BeanSerializer for type that has no properties");
-        }
         _props = props;
         // let's store this for debugging
         _className = type.getName();
@@ -45,6 +43,15 @@
         this(type, props.toArray(new BeanPropertyWriter[props.size()]));
     }
 
+    /**
+     * Method for constructing dummy bean deserializer; one that
+     * never outputs any properties
+     */
+    public static BeanSerializer createDummy(Class<?> forType)
+    {
+        return new BeanSerializer(forType, NO_PROPS);
+    }
+
     public void serialize(Object bean, JsonGenerator jgen, SerializerProvider provider)
         throws IOException, JsonGenerationException
     {
diff --git a/src/mapper/java/org/codehaus/jackson/map/ser/BeanSerializerFactory.java b/src/mapper/java/org/codehaus/jackson/map/ser/BeanSerializerFactory.java
index 96c63c7..32e512f 100644
--- a/src/mapper/java/org/codehaus/jackson/map/ser/BeanSerializerFactory.java
+++ b/src/mapper/java/org/codehaus/jackson/map/ser/BeanSerializerFactory.java
@@ -142,7 +142,7 @@
             ser = findSerializerFromAnnotation(config, valueMethod);
             return new JsonValueSerializer(valueMethod.getAnnotated(), ser);
         }
-        return constructBeanSerializer(type, config, beanDesc);
+        return constructBeanSerializer(config, beanDesc);
     }
 
     /*
@@ -164,20 +164,27 @@
         return (ClassUtil.canBeABeanType(type) == null) && !ClassUtil.isProxyType(type);
     }
 
-    protected JsonSerializer<Object> constructBeanSerializer(Class<?> type, SerializationConfig config,
+    protected JsonSerializer<Object> constructBeanSerializer(SerializationConfig config,
                                                              BasicBeanDescription beanDesc)
     {
         // First: any detectable (auto-detect, annotations) properties to serialize?
         List<BeanPropertyWriter> props = findBeanProperties(config, beanDesc);
         if (props == null || props.size() == 0) {
             // No properties, no serializer
+            /* 27-Nov-2009, tatu: Except that as per [JACKSON-201], we are
+             *   ok with that as long as it has a recognized class annotation
+             *  (which may come from a mix-in too)
+             */
+            if (beanDesc.hasKnownClassAnnotations()) {
+                return BeanSerializer.createDummy(beanDesc.classDescribed());
+            }
             return null;
         }
         // Any properties to suppress?
         props = filterBeanProperties(config, beanDesc, props);
         // And finally: do they need to be sorted in some special way?
         props = sortBeanProperties(config, beanDesc, props);
-        return new BeanSerializer(type, props);
+        return new BeanSerializer(beanDesc.classDescribed(), props);
     }
 
     /**
diff --git a/src/mapper/java/org/codehaus/jackson/map/ser/StdSerializerProvider.java b/src/mapper/java/org/codehaus/jackson/map/ser/StdSerializerProvider.java
index 5f8b6cf..5cdcbe2 100644
--- a/src/mapper/java/org/codehaus/jackson/map/ser/StdSerializerProvider.java
+++ b/src/mapper/java/org/codehaus/jackson/map/ser/StdSerializerProvider.java
@@ -48,12 +48,15 @@
     {
         @Override
         public void serialize(Object value, JsonGenerator jgen, SerializerProvider provider)
-            throws JsonMappingException
+            throws IOException, JsonMappingException
         {
-            /* 18-Feb-2009, tatu: Let's suggest the most likely reason
-             *   for failure to find a serializer
-             */
-            throw new JsonMappingException("No serializer found for class "+value.getClass().getName()+" (and no bean properties discovered to create bean serializer)");
+            // 27-Nov-2009, tatu: As per [JACKSON-201] may or may not fail...
+            if (provider.isEnabled(SerializationConfig.Feature.FAIL_ON_EMPTY_BEANS)) {
+                throw new JsonMappingException("No serializer found for class "+value.getClass().getName()+" and no properties discovered to create BeanSerializer (to avoid exception, disable SerializationConfig.Feature.FAIL_ON_EMPTY_BEANS) )");
+            }
+            // But if it's fine, we'll just output empty JSON Object:
+            jgen.writeStartObject();
+            jgen.writeEndObject();
         }
     };
 
diff --git a/src/test/org/codehaus/jackson/map/ser/TestEmptyClass.java b/src/test/org/codehaus/jackson/map/ser/TestEmptyClass.java
new file mode 100644
index 0000000..437f1c1
--- /dev/null
+++ b/src/test/org/codehaus/jackson/map/ser/TestEmptyClass.java
@@ -0,0 +1,49 @@
+package org.codehaus.jackson.map.ser;
+
+import org.codehaus.jackson.map.*;
+import org.codehaus.jackson.map.annotate.*;
+
+public class TestEmptyClass
+    extends BaseMapTest
+{
+    static class Empty { }
+
+    @JsonSerialize
+    static class EmptyWithAnno { }
+
+    /**
+     * Test to check that [JACKSON-201] works if there is a recognized
+     * annotation (which indicates type is serializable)
+     */
+    public void testEmptyWithAnnotations() throws Exception
+    {
+        ObjectMapper mapper = new ObjectMapper();
+        // First: without annotations, should complain
+        try {
+            serializeAsString(mapper, new Empty());
+        } catch (JsonMappingException e) {
+            verifyException(e, "No serializer found for class");
+        }
+
+        // But not if there is a recognized annotation
+        assertEquals("{}", serializeAsString(mapper, new EmptyWithAnno()));
+
+        // Including class annotation through mix-ins
+        mapper = new ObjectMapper();
+        mapper.getSerializationConfig().addMixInAnnotations(Empty.class, EmptyWithAnno.class);
+        assertEquals("{}", serializeAsString(mapper, new Empty()));
+    }
+
+    /**
+     * Alternative it is possible to use a feature to allow
+     * serializing empty classes, too
+     */
+    public void testEmptyWithFeature() throws Exception
+    {
+        ObjectMapper mapper = new ObjectMapper();
+        // should be enabled by default
+        assertTrue(mapper.getSerializationConfig().isEnabled(SerializationConfig.Feature.FAIL_ON_EMPTY_BEANS));
+        mapper.configure(SerializationConfig.Feature.FAIL_ON_EMPTY_BEANS, false);
+        assertEquals("{}", serializeAsString(mapper, new Empty()));
+    }
+}