diff --git a/src/components/EventsInternal/EventsInternal.jsx b/src/components/EventsInternal/EventsInternal.jsx
new file mode 100644
index 0000000..c567a60
--- /dev/null
+++ b/src/components/EventsInternal/EventsInternal.jsx
@@ -0,0 +1,352 @@
+import React, { useEffect } from "react";
+import { Box, Text, Image } from "@chakra-ui/react";
+import { Avatar, AvatarBadge, AvatarGroup } from "@chakra-ui/react";
+import banner from "../../assets/images/articleInternalbanner.png";
+import Chip from "../Chip/Chip";
+import Footer from "../Footer/Footer";
+import { ChevronRightIcon } from "@chakra-ui/icons";
+import profile from "../../assets/images/profile.png";
+import x from "../../assets/images/x.png";
+import linked from "../../assets/images/linked.png";
+import github from "../../assets/images/github.png";
+import tele from "../../assets/images/tele.png";
+import reddit from "../../assets/images/reddit.png";
+import fb from "../../assets/images/fb.png";
+
+const EventsInternal = () => {
+  useEffect(() => {
+    window.scrollTo(0, 0);
+  }, []);
+  return (
+    <>
+      <Box
+        bg="#000000"
+        height={"auto"}
+        display={"flex"}
+        gap={7}
+        justifyContent={"center"}
+        alignItems={"center"}
+        flexDirection={"column"}
+        color="white"
+      >
+        <Box
+          bg="#000000"
+          minHeight={"60vh"}
+          width={"70vw"}
+          display={"flex"}
+          gap={5}
+          marginTop={10}
+          justifyContent={"end"}
+          alignItems={"center"}
+          flexDirection={"column"}
+          color="white"
+          sx={{
+            "@media (max-width: 600px)": {
+              minHeight: "inherit",
+              width: "100vw",
+              marginTop: "6rem",
+            },
+          }}
+        >
+          <Text
+            textAlign={"center"}
+            className="rubix-fw-600"
+            fontSize={"40px"}
+            fontFamily={"Mona Sans"}
+            color={"#fff"}
+            sx={{
+              "@media (max-width: 600px)": {
+                fontSize: "28px",
+                lineHeight: "45px",
+                padding: "0px 1rem",
+              },
+            }}
+          >
+            Enterprise blockchains on a Public Chain!
+          </Text>
+        </Box>
+        {/* ========[ Banner ]======= */}
+        <Box
+          height={"70vh"}
+          width={"85vw"}
+          backgroundImage={`url(${banner})`}
+          backgroundRepeat={"no-repeat"}
+          backgroundSize={"cover"}
+          position="relative"
+          sx={{
+            "@media (max-width: 600px)": {
+              height: "215px",
+              width: "100%",
+            },
+          }}
+        >
+          <Box
+            position="absolute"
+            top={0}
+            left={0}
+            width="100%"
+            height="100%"
+            backgroundColor="rgba(0, 0, 0, 0.5)"
+          />
+        </Box>
+
+        <Box
+          bg="#000000"
+          width={"85vw"}
+          height={"auto"}
+          display={"flex"}
+          pb={"60px"}
+          gap={5}
+          justifyContent={"center"}
+          alignItems={"center"}
+          flexDirection={"column"}
+          color="white"
+          position={"relative"}
+          sx={{
+            "@media (max-width: 600px)": {
+              display: "block",
+              top: "inherit",
+            },
+          }}
+        >
+          <Box
+            position={"absolute"}
+            top={0}
+            left={0}
+            display={"flex"}
+            flexDirection={"column"}
+            alignItems={"center"}
+            gap={2}
+            sx={{
+              "@media (max-width: 600px)": {
+                bottom: "0px",
+                top: "inherit",
+                display: "block",
+                width: "100%",
+                marginBottom: "20px",
+                marginTop: "20px",
+              },
+            }}
+          >
+            <Text
+              className="rubix-text-xsmall"
+              sx={{
+                "@media (max-width: 600px)": {
+                  marginBottom: "15px",
+                },
+              }}
+            >
+              Share
+            </Text>
+
+            <Text
+              sx={{
+                "@media (max-width: 600px)": {
+                  display: "flex",
+                  justifyContent: "space-between",
+                  width: "60%",
+                },
+              }}
+            >
+              <Image cursor={"pointer"} mb={4} w={6} h={6} src={tele} />
+              <Image cursor={"pointer"} mb={4} w={6} h={6} src={x} />
+              <Image cursor={"pointer"} mb={4} w={6} h={6} src={fb} />
+              <Image cursor={"pointer"} mb={4} w={6} h={6} src={linked} />
+            </Text>
+          </Box>
+          <Box
+            bg="#000000"
+            width={"68vw"}
+            height={"auto"}
+            display={"flex"}
+            flexDirection={"column"}
+            gap={5}
+            justifyContent={"start"}
+            color="white"
+            sx={{
+              "@media (max-width: 600px)": {
+                width: "100%",
+              },
+            }}
+          >
+            <Box display={"flex"} gap={5} justifyContent={"start"}>
+              <Chip title="INSIGHT" />
+              <Chip title="BLOCKSPACE" />
+            </Box>
+
+            <Box
+              pt={5}
+              pb={5}
+              sx={{
+                "@media (max-width: 600px)": {
+                  marginBottom: "3rem",
+                },
+              }}
+            >
+              {/* <Text pb={10} pt={5}>
+                <img
+                  width={"100%"}
+                  src="https://www.rubix.net/wp-content/uploads/blockchain.webp"
+                />
+              </Text> */}
+              <Text pb={5} className="rubix-text-small">
+                Web3 transformation is beginning to accelerate at an exponential
+                rate. Enterprises & app developers alike are keenly looking for
+                ways to migrate to Web3 protocols. Web3 is highly disruptive,
+                yet brings immense business growth opportunities for
+                enterprises. Enterprises & Web3 apps can also reduce operating &
+                IT costs significantly by adopting decentralized protocols.
+                While Web3 is highly relevant to DAOs (Decentralized Autonomous
+                Organizations), Apps & enterprises alike, the focus in this blog
+                is on how enterprises can build secure networks over the Rubix
+                public blockchain instead of building expensive & clunky private
+                / permissioned chains. Blockchain & Web3 offer significant
+                benefits for enterprises. Enterprises across sectors that adopt
+                Web3 will benefit immensely, while those who don’t might face
+                disruption from incumbents or new entrants. Benefits of Web3
+                adoption include (a) better settlement internally or
+                intra-industry (b) supply chain improvements ( c ) newer
+                markets/growth opportunities (d) lower IT infrastructure costs &
+                (e) Better ESG (environmental, social & governance) compliance.
+                Enterprise blockchain adoption though has faced significant
+                challenges so far. The challenges include (a) concerns about
+                data security/privacy (b) storing data at all public blockchain
+                nodes & ( c ) high transaction/infrastructure costs. Enterprises
+                so far preferred setting up private / permissioned chains for
+                both internal & intra-industry applications. Most of these
+                applications fail to scale for the reasons explained in this
+                para. The real benefits of blockchain accrue for enterprises on
+                a public chain. The benefits of a public chain are several, but
+                the most notable ones are (a) malleability — enterprises can
+                expand/contract chains based on projects without needing to
+                build custom blockchains for each use case & (b) open-source-
+                having a community of developers/trouble-shooters gets better
+                apps & reduces costs. While the benefits of a public chain are
+                immense, faster adoption requires solving the current
+                constraints. Public chains can offer a better way for
+                enterprises to adopt Web3, But is there a public chain that can
+                meet the needs of enterprises? In other words, can enterprises
+                launch their chains on a public chain? After a long search, I
+                came across a scalable open-sourced project called Rubix Chain
+                which has been maintained for over a year providing huge support
+                to anyone who wants a blockchain solution. I was very keen then
+                onwards to see what’s going on and how their platform has been
+                improving over time. The network was able to meet my
+                expectations & ticked all the boxes including (a) having an
+                option to choose validators such as custom validators or
+                randomly chosen validators & (b) better infrastructure control
+                which no other project has offered to date. Rubix Chain is a
+                highly scalable blockchain protocol, using which enterprises or
+                consortia can launch multiple proofchains with the same
+                infrastructure. Rubix has its own platform, git repos, wallet,
+                set-up system, support, etc. An open-source project having this
+                level of support even for enterprise users too should be
+                appreciated. Anyone who wants to set up their controlled network
+                can use Rubix Chain — the setup process is very easy & there is
+                good documentation. The entire network can be up & running in
+                hours, not days.
+              </Text>
+              {/* <Text pb={10} pt={5}>
+                <img
+                  style={{ backgroundColor: "#fff" }}
+                  width={"100%"}
+                  src="https://www.rubix.net/wp-content/uploads/independent-proofchains-of-tokens.png"
+                />
+              </Text> */}
+              <Text pb={5} className="rubix-text-small">
+                Rubix ProofChain is the chain of all transactions that are bound
+                by the user token called utility token (RBT). All ProofChains
+                with tokens committed in the genesis node were originated by the
+                genesis node itself and are stored and committed using the
+                protocol and its ownership is globally verifiable. All others
+                that are not pre-committed to the genesis node are mined by the
+                validators and the corresponding ProofChain of that token will
+                be starting with the validators node that has mined the token.
+                Let’s take a look at what’s happening inside the Rubix Chain and
+                understand why it’s the best enterprise solution. One major
+                issue enterprise users face is the data discrepancy between
+                different nodes or sub-networks. While in other public chains,
+                third parties or oracles are needed to sync subnets, sidechains
+                or parachains, in Rubix, different proofchains automatically
+                sync to represent one global state without the explicit need for
+                3rd party nodes or oracles.
+              </Text>
+              {/* <Text pb={10} pt={5}>
+                <img
+                  style={{ backgroundColor: "#fff" }}
+                  width={"100%"}
+                  src="https://www.rubix.net/wp-content/uploads/multiple-quorum-validating-transactions.png"
+                />
+              </Text> */}
+              <Text pb={5} className="rubix-text-small">
+                Another major advantage of the Rubix Chain is that even though
+                it is a public chain, the level of decentralization that the
+                network provides is flexible and customisable. Ideally,
+                blockchain should be decentralized but based on the use case the
+                Rubix Chain is adaptable in such a way that it can choose how
+                decentralized the network should be, the level of security,
+                which validator/quorum should be validating the transaction,
+                etc. There could be some users who just want to have limited
+                control over the data, while others want entire control whereas
+                some others require entire decentralization. All these can be
+                configured by just updating the quorum list with who validates
+                the transaction. This choice of quorum brings forth the next
+                major advantage, data control over the network, as this is one
+                such major situation most enterprise users need is the option to
+                validate the transaction within its nodes itself; this could be
+                due to some internal policy or limitation in data sharing; Rubix
+                provides the perfect solution for enterprises in adopting based
+                on their needs. Let us discuss how Rubix can help enterprises
+                meet their various requirements easily. For each Rubix
+                transaction, the initiator can define the type of transaction it
+                requires, based on the type the quorum will be picked. In Type 1
+                transaction quorums are picked from a broad set of global
+                validators, randomly, whereas Type 2 transactions will help
+                enterprises or consortia use a pre-determined cluster of
+                validators. Type 2 helps enterprises/consortia have better
+                control over their data. Type 2 does not mean losing the
+                benefits of a decentralized network (attributes such as
+                immutability & Sybil resistance) as all enterprise chains will
+                be part of a shared global state with a single public swarm key!
+                Transactions done using a Type 2 transaction are as secure,
+                immutable & globally verifiable as a Type 1 transaction, due to
+                the revolutionary Proof of Pledge consensus protocol (more on
+                this in the whitepaper found in the git repo. Malleability is
+                perhaps the biggest benefit of building enterprise chains on top
+                of the Rubix chain. For example, a consumer goods company can
+                download the free Rubix software on all its internal computing
+                nodes to run internal applications. Some of the internal nodes
+                can easily be switched or be added to a consortium network
+                without any time delay or additional costs. This makes
+                enterprises highly adaptable to Web3 without necessarily
+                committing at one go or doing costly PoCs. Since Rubix Chain is
+                a resource-subdued, lightweight blockchain and easier to setup
+                compared to other heavier public blockchains, it becomes cheaper
+                to run as additional resources like parallel computing machines
+                or ultra-spec systems are not necessarily required. Any normal
+                machine that is capable of running normal applications and tools
+                will be able to run Rubix Network on their machine. Another key
+                requirement for enterprises is handling identity & KYC. Rubix is
+                the only protocol with Decentralized Identity (DID) built from
+                scratch. It is easier to build Identity & Access Management
+                (IAM) & KYC applications using Rubix. From cost-effective to
+                flexibility and security to scalability Rubix Chain is a project
+                anyone can bet upon, unlike other blockchains that claims to be
+                decentralized but are centralized by infrastructure Rubix
+                network maintains the integrity of being decentralized. Setup
+                instructions are available with all files here, repo also can be
+                cloned from here. There is already significant interest from
+                enterprises in building various applications including document
+                management, finance, HR, ESG provenance, supply chain management
+                & media. Rubix could be the protocol that helps enterprises
+                quickly adapt to the inevitable rise of Web3.
+              </Text>
+            </Box>
+          </Box>
+        </Box>
+      </Box>
+    </>
+  );
+};
+
+export default EventsInternal;
diff --git a/src/components/MobileComponent/MobileCommunityCard.jsx b/src/components/MobileComponent/MobileCommunityCard.jsx
index 0117bc5..eb293db 100644
--- a/src/components/MobileComponent/MobileCommunityCard.jsx
+++ b/src/components/MobileComponent/MobileCommunityCard.jsx
@@ -42,7 +42,7 @@ const individuals = [
   {
     location: "india",
     name: "Hari Krishnan",
-    jobTitle: "Chief Growth Officer",
+    jobTitle: "Head of Technology",
     description:
       "Deeply passionate about Cryptography, Zero Knowledge Proofs, and Number Theory.",
     imageUrl: imgthree,
@@ -51,7 +51,7 @@ const individuals = [
   {
     location: "india",
     name: "Eser Torun, CFA",
-    jobTitle: "Head of Technology",
+    jobTitle: "Chief Growth Officer",
     description:
       "Expert at balancing risk-taking with sound business judgment in decision-making.",
     imageUrl: imgten,
@@ -95,7 +95,7 @@ const individuals = [
   },
   {
     location: "india",
-    name: "ASHITA GUPTA",
+    name: "Ashita Gupta",
     jobTitle: "Blockchain Developer",
     description:
       "Enthusiastic blockchain developer who pushes herself every day to excel at work.",
diff --git a/src/components/MobileComponent/MobilePlace.jsx b/src/components/MobileComponent/MobilePlace.jsx
index 8bdb630..b2c84f1 100644
--- a/src/components/MobileComponent/MobilePlace.jsx
+++ b/src/components/MobileComponent/MobilePlace.jsx
@@ -56,7 +56,7 @@ const MobilePlace = () => {
             textTransform={"capitalize"}
             color={"#fff"}
           >
-            Tools And Resources To Help You Succeed
+            Find Your Place At The Table
           </Text>
           <Swiper
             spaceBetween={20}
diff --git a/src/components/MobileComponent/MobileSolve.jsx b/src/components/MobileComponent/MobileSolve.jsx
index b947ee6..be0a823 100644
--- a/src/components/MobileComponent/MobileSolve.jsx
+++ b/src/components/MobileComponent/MobileSolve.jsx
@@ -90,10 +90,7 @@ const MobileSolve = () => {
   return (
     <>
       <Box backgroundColor={"#00020E"}>
-        <Container
-          maxW={"container.xl"}
-          padding={"4rem 1rem"}
-        >
+        <Container maxW={"container.xl"} padding={"4rem 1rem"}>
           <Text
             as={"h2"}
             paddingBottom={"30px"}
@@ -104,7 +101,7 @@ const MobileSolve = () => {
             textTransform={"capitalize"}
             color={"#fff"}
           >
-            Tools And Resources To Help You Succeed
+            Solving Real-World Issues And Business Problems
           </Text>
           <Swiper
             spaceBetween={20}
@@ -124,11 +121,9 @@ const MobileSolve = () => {
                 background={"#00020E"}
                 backgroundSize={"cover"}
                 backgroundRepeat={"no-repeat"}
+                key={item.id}
               >
-                <Card
-                  backgroundColor={"#00020E"}
-                  key={item.id}
-                >
+                <Card backgroundColor={"#00020E"}>
                   <CardHeader paddingLeft={"0px"} paddingRight={"0px"}>
                     <Image src={item.img} marginBottom={"20px"} />
                     <Heading
diff --git a/src/pages/Events.jsx b/src/pages/Events.jsx
index e5dc203..3491ab7 100644
--- a/src/pages/Events.jsx
+++ b/src/pages/Events.jsx
@@ -1,4 +1,3 @@
-import React from "react";
 import EventsSec from "../components/EventsPage/EventsSec";
 import NewestEvent from "../components/EventsPage/NewestEvents";
 import UpcomingEvents from "../components/EventsPage/UpcomingEvents";
diff --git a/src/pages/EventsInternnal.jsx b/src/pages/EventsInternnal.jsx
new file mode 100644
index 0000000..219d06d
--- /dev/null
+++ b/src/pages/EventsInternnal.jsx
@@ -0,0 +1,11 @@
+import EventsInternal from "../components/EventsInternal/EventsInternal";
+
+const EventsInternnal = () => {
+  return (
+    <>
+      <EventsInternal />
+    </>
+  );
+};
+
+export default EventsInternnal;
diff --git a/src/routes/_routes.jsx b/src/routes/_routes.jsx
index 82c0c68..db8e910 100644
--- a/src/routes/_routes.jsx
+++ b/src/routes/_routes.jsx
@@ -27,6 +27,7 @@ import VideoInternal from "../components/VideoInternal/VideoInternal";
 import Ecosystem from "../pages/Ecosystem";
 import Events from "../pages/Events";
 import NewsPage from "../pages/NewsPage";
+import EventsInternnal from "../pages/EventsInternnal";
 
 export const route = [
   {
@@ -98,6 +99,10 @@ export const route = [
     path: "news",
     element: <NewsPage />,
   },
+  {
+    path: "events-internal",
+    element: <EventsInternnal />,
+  },
   {
     path: "*",
     element: <NotFound />,