diff --git a/site/blog/2024-05-31-podling-teaclave-report-june-2024.md b/site/blog/2024-05-31-podling-teaclave-report-june-2024.md
new file mode 100644
index 0000000..ce28e36
--- /dev/null
+++ b/site/blog/2024-05-31-podling-teaclave-report-june-2024.md
@@ -0,0 +1,91 @@
+---
+
+title: Podling Teaclave Report - June 2024
+date: 2024-05-31
+author: Yuan Zhuang
+
+---
+
+## Teaclave
+
+### Three most important unfinished issues to address before graduating:
+
+  - Improve project structure and documentation
+  - Grow the community (attracting more committers, contributors, users)
+  - Publish Apache releases (resolving logistics on Apache release)
+  
+### Are there any issues that the IPMC or ASF Board need to be aware of?
+  
+  None.
+  
+### How has the community developed since the last report?
+  
+  Since the last report, we have organized three monthly virtual
+  meetups. For each meetup, we have write-ups published on the Teaclave
+  blog <https://teaclave.apache.org/blog/>.
+  - Teaclave Meetup #13:
+    <https://teaclave.apache.org/blog/2022-06-29-teaclave-meetup-13/>
+  - Teaclave Meetup #14:
+    <https://teaclave.apache.org/blog/2022-12-14-teaclave-meetup-14/>
+  - Teaclave Meetup #15:
+    <https://teaclave.apache.org/blog/2022-12-21-teaclave-meetup-15/>
+
+
+  Additionally, we introduced a new project Teaclave Java TEE SDK to 
+  our community:  
+  <https://teaclave.apache.org/blog/2022-10-18-accepting-java-enclave-proposal/>
+  
+### How has the project developed since the last report?
+  
+  Here are the summaries of recent progress:  
+
+#### Teaclave Faas Platform:
+  - New release 0.6.0:
+    <https://github.com/apache/incubator-teaclave/releases/tag/v0.6.0>
+  - Merged PRs:
+    <https://github.com/apache/incubator-teaclave/pulls?q=is%3Apr+is%3Aclosed+merged%3A2022-05-01..2024-05-31+base%3Amaster>
+  
+#### Teaclave TrustZone SDK
+  - New 'no-std' branch (set as recommended):
+    <https://lists.apache.org/thread/f3l82o89hb0w43n27nw77oqcpo829qjd>
+  - Merged PRs:
+    <https://github.com/apache/incubator-teaclave-trustzone-sdk/pulls?q=is%3Apr+is%3Aclosed+merged%3A2022-05-01..2024-05-31+base%3Amaster+>
+  
+#### Teaclave SGX SDK
+  - Preparing release v2.0.0:
+    <https://github.com/apache/incubator-teaclave-sgx-sdk/tree/v2.0.0-preview>
+  - Merged PRs:
+    <https://github.com/apache/incubator-teaclave-sgx-sdk/pulls?q=is%3Apr+is%3Aclosed+merged%3A2022-05-01..2024-05-31+base%3Amaster+>
+
+#### [NEW] Teaclave Java TEE SDK
+  - The first release v0.1.0:
+    https://github.com/apache/incubator-teaclave-java-tee-sdk/releases/tag/v0.1.0
+  
+
+### How would you assess the podling's maturity?
+
+  - [ ] Initial setup
+  - [ ] Working towards first release
+  - [x] Community building
+  - [ ] Nearing graduation
+  - [ ] Other:
+  
+### Date of last release:
+  
+  2023-06-26: Apache Teaclave (incubating) FaaS Platfrom 0.6.0
+  
+### When were the last committers or PPMC members elected?
+
+  2023-05-04: He Sun (Apache ID: hsun), PPMC
+  
+### Have your mentors been helpful and responsive?
+  
+  Yes, our mentors work responsively to help us with electing new
+  mentors, developing new features, fixing bugs, and expanding the
+  community.
+  
+### Is the PPMC managing the podling's brand / trademarks?
+  
+  We don't find any 3rd parties incorrectly using the podling's name and
+  brand.  The VP, Brand has approved the project name.
+  (PODLINGNAMESEARCH-175)
