¿Qué es el desarrollo de software a la medida?

Es la creación de aplicaciones, plataformas o sistemas diseñados específicamente para las necesidades de su empresa, a diferencia del software genérico. En Axentia Technologies construimos soluciones 100% personalizadas: desde una landing page hasta una plataforma SaaS completa, adaptada a su modelo de negocio.

¿Cuánto cuesta una página web para empresa en Colombia?

El costo varía según la complejidad. Una landing page profesional puede arrancar desde $800.000 COP, una página institucional completa desde $2.000.000 COP, y una plataforma SaaS o sistema web a medida desde $5.000.000 COP. Contáctenos para recibir una cotización sin costo según su proyecto.

¿Desarrollan software para facturación electrónica DIAN?

Sí. Construimos integraciones con la DIAN para facturación electrónica, documentos equivalentes y nómina electrónica. Nuestras soluciones cumplen con la resolución vigente y se integran con los sistemas de gestión existentes de su empresa.

¿Cuánto tarda en estar lista mi página web o aplicación?

Una landing page o página web informativa puede estar lista en 1 a 2 semanas. Un sistema web a medida o plataforma SaaS, según su alcance, entre 4 semanas y 3 meses. Definimos plazos claros en el contrato antes de iniciar.

¿Trabajan con empresas de toda Colombia o solo de Barranquilla?

Atendemos clientes en toda Colombia de forma remota. Tenemos sede en Sabanalarga y Barranquilla, Atlántico, pero hemos trabajado con empresas de Bogotá, Medellín, Cali y otras ciudades. La comunicación y entrega se hacen 100% en línea.

¿Qué tecnologías usan para desarrollar software?

Usamos tecnologías modernas y probadas: Next.js y React para el frontend, Django y Python para el backend, MongoDB y PostgreSQL para bases de datos, y Vercel o AWS para el despliegue. Elegimos el stack según las necesidades de cada proyecto.

¿Ofrecen soporte y mantenimiento después de entregar el proyecto?

Sí. Ofrecemos planes de soporte y mantenimiento mensual para garantizar que su software funcione correctamente, se mantenga actualizado y reciba mejoras continuas. Los detalles del SLA se acuerdan en cada contrato.

¿Puedo contratar solo el diseño de mi página web?

Sí. Ofrecemos diseño y desarrollo web por separado. Si ya tiene un diseño y necesita desarrollo, o si necesita diseño sin desarrollo, podemos adaptarnos. También rediseñamos sitios existentes que necesitan modernizarse.

¿Qué tan seguras son las páginas y aplicaciones que desarrollan?

La seguridad es parte de nuestro proceso, no un extra. Todos nuestros desarrollos aplican el OWASP Top 10, el estándar internacional que protege contra los ataques más comunes de la web: robo de datos, inyección de código, secuestro de sesiones y suplantación de sitios. En la práctica esto significa que su página maneja conexión cifrada HTTPS, valida toda la información que recibe, protege los datos de sus clientes y bloquea las técnicas que usan los atacantes. Nuestro fundador tiene formación en ciberseguridad y redes de datos, y revisa personalmente la seguridad de cada proyecto antes de entregarlo.

2import { NextResponse } from 'next/server'

3export async function POST(req: Request) {

4 const { email } = await req.json()

5 return NextResponse.json({ ok: true })

8const useStack = <T,>(): Stack<T> => {

9 const [items, setItems] = useState<T[]>([])

10 const push = (item: T) => setItems(p => [...p, item])

11 return { items, push }

12}

14class FacturaElectronica(models.Model):

15 cufe = models.CharField(max_length=96, unique=True)

16 prefijo = models.CharField(max_length=4)

17 consecutivo = models.PositiveIntegerField()

18 total = models.DecimalField(max_digits=18, decimal_places=2)

20SELECT u.id, u.nombre, COUNT(p.id) as total_pedidos

21FROM usuarios u

22LEFT JOIN pedidos p ON p.usuario_id = u.id

23WHERE u.activo = true GROUP BY u.id;

25{

26 "servicio": "halu-medic",

27 "version": "2.4.1",

28 "runtime": "python3.12",

29 "region": "us-east-1"

30}

32const App: FC = () => (

33 <Layout>

34 <Hero />

35 <Services />

36 </Layout>

37)

39@app.route('/api/facturas', methods=['POST'])

40def crear_factura():

41 data = request.get_json()

42 return jsonify(servicio.crear(data))

44interface Cliente {

45 id: string

46 nombre: string

47 nit: string

48 activo: boolean

49}

51docker compose up -d --build

52nginx -s reload

53pytest tests/ -v --cov=app

54npm run build && npm run start

56await celery.send_task('rips.procesar', args=[batch_id])

57cache.set(key, value, timeout=3600)

59import { NextResponse } from 'next/server'

60export async function POST(req: Request) {

61 const { email } = await req.json()

62 return NextResponse.json({ ok: true })

63}

65const useStack = <T,>(): Stack<T> => {

66 const [items, setItems] = useState<T[]>([])

67 const push = (item: T) => setItems(p => [...p, item])

68 return { items, push }

69}

71class FacturaElectronica(models.Model):

72 cufe = models.CharField(max_length=96, unique=True)

73 prefijo = models.CharField(max_length=4)

74 consecutivo = models.PositiveIntegerField()

75 total = models.DecimalField(max_digits=18, decimal_places=2)

77SELECT u.id, u.nombre, COUNT(p.id) as total_pedidos

78FROM usuarios u

79LEFT JOIN pedidos p ON p.usuario_id = u.id

80WHERE u.activo = true GROUP BY u.id;

82{

83 "servicio": "halu-medic",

84 "version": "2.4.1",

85 "runtime": "python3.12",

86 "region": "us-east-1"

87}

89const App: FC = () => (

90 <Layout>

91 <Hero />

92 <Services />

93 </Layout>

94)

96@app.route('/api/facturas', methods=['POST'])

97def crear_factura():

98 data = request.get_json()

99 return jsonify(servicio.crear(data))

100

101interface Cliente {

102 id: string

103 nombre: string

104 nit: string

105 activo: boolean

106}

107

108docker compose up -d --build

109nginx -s reload

110pytest tests/ -v --cov=app

111npm run build && npm run start

112

113await celery.send_task('rips.procesar', args=[batch_id])

114cache.set(key, value, timeout=3600)

115

43import { NextResponse } from 'next/server'

44export async function POST(req: Request) {

45 const { email } = await req.json()

46 return NextResponse.json({ ok: true })

47}

49const useStack = <T,>(): Stack<T> => {

50 const [items, setItems] = useState<T[]>([])

51 const push = (item: T) => setItems(p => [...p, item])

52 return { items, push }

53}

55class FacturaElectronica(models.Model):

56 cufe = models.CharField(max_length=96, unique=True)

57 prefijo = models.CharField(max_length=4)

58 consecutivo = models.PositiveIntegerField()

59 total = models.DecimalField(max_digits=18, decimal_places=2)

61SELECT u.id, u.nombre, COUNT(p.id) as total_pedidos

62FROM usuarios u

63LEFT JOIN pedidos p ON p.usuario_id = u.id

64WHERE u.activo = true GROUP BY u.id;

66{

67 "servicio": "halu-medic",

68 "version": "2.4.1",

69 "runtime": "python3.12",

70 "region": "us-east-1"

71}

73const App: FC = () => (

74 <Layout>

75 <Hero />

76 <Services />

77 </Layout>

78)

80@app.route('/api/facturas', methods=['POST'])

81def crear_factura():

82 data = request.get_json()

83 return jsonify(servicio.crear(data))

85interface Cliente {

86 id: string

87 nombre: string

88 nit: string

89 activo: boolean

90}

92docker compose up -d --build

93nginx -s reload

94pytest tests/ -v --cov=app

95npm run build && npm run start

97await celery.send_task('rips.procesar', args=[batch_id])

98cache.set(key, value, timeout=3600)

100import { NextResponse } from 'next/server'

101export async function POST(req: Request) {

102 const { email } = await req.json()

103 return NextResponse.json({ ok: true })

104}

105

106const useStack = <T,>(): Stack<T> => {

107 const [items, setItems] = useState<T[]>([])

108 const push = (item: T) => setItems(p => [...p, item])

109 return { items, push }

110}

111

112class FacturaElectronica(models.Model):

113 cufe = models.CharField(max_length=96, unique=True)

114 prefijo = models.CharField(max_length=4)

115 consecutivo = models.PositiveIntegerField()

116 total = models.DecimalField(max_digits=18, decimal_places=2)

117

118SELECT u.id, u.nombre, COUNT(p.id) as total_pedidos

119FROM usuarios u

120LEFT JOIN pedidos p ON p.usuario_id = u.id

121WHERE u.activo = true GROUP BY u.id;

122

123{

124 "servicio": "halu-medic",

125 "version": "2.4.1",

126 "runtime": "python3.12",

127 "region": "us-east-1"

128}

129

130const App: FC = () => (

131 <Layout>

132 <Hero />

133 <Services />

134 </Layout>

135)

136

137@app.route('/api/facturas', methods=['POST'])

138def crear_factura():

139 data = request.get_json()

140 return jsonify(servicio.crear(data))

141

142interface Cliente {

143 id: string

144 nombre: string

145 nit: string

146 activo: boolean

147}

148

149docker compose up -d --build

150nginx -s reload

151pytest tests/ -v --cov=app

152npm run build && npm run start

153

154await celery.send_task('rips.procesar', args=[batch_id])

155cache.set(key, value, timeout=3600)

156

85import { NextResponse } from 'next/server'

86export async function POST(req: Request) {

87 const { email } = await req.json()

88 return NextResponse.json({ ok: true })

89}

91const useStack = <T,>(): Stack<T> => {

92 const [items, setItems] = useState<T[]>([])

93 const push = (item: T) => setItems(p => [...p, item])

94 return { items, push }

95}

97class FacturaElectronica(models.Model):

98 cufe = models.CharField(max_length=96, unique=True)

99 prefijo = models.CharField(max_length=4)

100 consecutivo = models.PositiveIntegerField()

101 total = models.DecimalField(max_digits=18, decimal_places=2)

102

103SELECT u.id, u.nombre, COUNT(p.id) as total_pedidos

104FROM usuarios u

105LEFT JOIN pedidos p ON p.usuario_id = u.id

106WHERE u.activo = true GROUP BY u.id;

107

108{

109 "servicio": "halu-medic",

110 "version": "2.4.1",

111 "runtime": "python3.12",

112 "region": "us-east-1"

113}

114

115const App: FC = () => (

116 <Layout>

117 <Hero />

118 <Services />

119 </Layout>

120)

121

122@app.route('/api/facturas', methods=['POST'])

123def crear_factura():

124 data = request.get_json()

125 return jsonify(servicio.crear(data))

126

127interface Cliente {

128 id: string

129 nombre: string

130 nit: string

131 activo: boolean

132}

133

134docker compose up -d --build

135nginx -s reload

136pytest tests/ -v --cov=app

137npm run build && npm run start

138

139await celery.send_task('rips.procesar', args=[batch_id])

140cache.set(key, value, timeout=3600)

141

142import { NextResponse } from 'next/server'

143export async function POST(req: Request) {

144 const { email } = await req.json()

145 return NextResponse.json({ ok: true })

146}

147

148const useStack = <T,>(): Stack<T> => {

149 const [items, setItems] = useState<T[]>([])

150 const push = (item: T) => setItems(p => [...p, item])

151 return { items, push }

152}

153

154class FacturaElectronica(models.Model):

155 cufe = models.CharField(max_length=96, unique=True)

156 prefijo = models.CharField(max_length=4)

157 consecutivo = models.PositiveIntegerField()

158 total = models.DecimalField(max_digits=18, decimal_places=2)

159

160SELECT u.id, u.nombre, COUNT(p.id) as total_pedidos

161FROM usuarios u

162LEFT JOIN pedidos p ON p.usuario_id = u.id

163WHERE u.activo = true GROUP BY u.id;

164

165{

166 "servicio": "halu-medic",

167 "version": "2.4.1",

168 "runtime": "python3.12",

169 "region": "us-east-1"

170}

171

172const App: FC = () => (

173 <Layout>

174 <Hero />

175 <Services />

176 </Layout>

177)

178

179@app.route('/api/facturas', methods=['POST'])

180def crear_factura():

181 data = request.get_json()

182 return jsonify(servicio.crear(data))

183

184interface Cliente {

185 id: string

186 nombre: string

187 nit: string

188 activo: boolean

189}

190

191docker compose up -d --build

192nginx -s reload

193pytest tests/ -v --cov=app

194npm run build && npm run start

195

196await celery.send_task('rips.procesar', args=[batch_id])

197cache.set(key, value, timeout=3600)

198

127import { NextResponse } from 'next/server'

128export async function POST(req: Request) {

129 const { email } = await req.json()

130 return NextResponse.json({ ok: true })

131}

132

133const useStack = <T,>(): Stack<T> => {

134 const [items, setItems] = useState<T[]>([])

135 const push = (item: T) => setItems(p => [...p, item])

136 return { items, push }

137}

138

139class FacturaElectronica(models.Model):

140 cufe = models.CharField(max_length=96, unique=True)

141 prefijo = models.CharField(max_length=4)

142 consecutivo = models.PositiveIntegerField()

143 total = models.DecimalField(max_digits=18, decimal_places=2)

144

145SELECT u.id, u.nombre, COUNT(p.id) as total_pedidos

146FROM usuarios u

147LEFT JOIN pedidos p ON p.usuario_id = u.id

148WHERE u.activo = true GROUP BY u.id;

149

150{

151 "servicio": "halu-medic",

152 "version": "2.4.1",

153 "runtime": "python3.12",

154 "region": "us-east-1"

155}

156

157const App: FC = () => (

158 <Layout>

159 <Hero />

160 <Services />

161 </Layout>

162)

163

164@app.route('/api/facturas', methods=['POST'])

165def crear_factura():

166 data = request.get_json()

167 return jsonify(servicio.crear(data))

168

169interface Cliente {

170 id: string

171 nombre: string

172 nit: string

173 activo: boolean

174}

175

176docker compose up -d --build

177nginx -s reload

178pytest tests/ -v --cov=app

179npm run build && npm run start

180

181await celery.send_task('rips.procesar', args=[batch_id])

182cache.set(key, value, timeout=3600)

183

184import { NextResponse } from 'next/server'

185export async function POST(req: Request) {

186 const { email } = await req.json()

187 return NextResponse.json({ ok: true })

188}

189

190const useStack = <T,>(): Stack<T> => {

191 const [items, setItems] = useState<T[]>([])

192 const push = (item: T) => setItems(p => [...p, item])

193 return { items, push }

194}

195

196class FacturaElectronica(models.Model):

197 cufe = models.CharField(max_length=96, unique=True)

198 prefijo = models.CharField(max_length=4)

199 consecutivo = models.PositiveIntegerField()

200 total = models.DecimalField(max_digits=18, decimal_places=2)

201

202SELECT u.id, u.nombre, COUNT(p.id) as total_pedidos

203FROM usuarios u

204LEFT JOIN pedidos p ON p.usuario_id = u.id

205WHERE u.activo = true GROUP BY u.id;

206

207{

208 "servicio": "halu-medic",

209 "version": "2.4.1",

210 "runtime": "python3.12",

211 "region": "us-east-1"

212}

213

214const App: FC = () => (

215 <Layout>

216 <Hero />

217 <Services />

218 </Layout>

219)

220

221@app.route('/api/facturas', methods=['POST'])

222def crear_factura():

223 data = request.get_json()

224 return jsonify(servicio.crear(data))

225

226interface Cliente {

227 id: string

228 nombre: string

229 nit: string

230 activo: boolean

231}

232

233docker compose up -d --build

234nginx -s reload

235pytest tests/ -v --cov=app

236npm run build && npm run start

237

238await celery.send_task('rips.procesar', args=[batch_id])

239cache.set(key, value, timeout=3600)

240

169import { NextResponse } from 'next/server'

170export async function POST(req: Request) {

171 const { email } = await req.json()

172 return NextResponse.json({ ok: true })

173}

174

175const useStack = <T,>(): Stack<T> => {

176 const [items, setItems] = useState<T[]>([])

177 const push = (item: T) => setItems(p => [...p, item])

178 return { items, push }

179}

180

181class FacturaElectronica(models.Model):

182 cufe = models.CharField(max_length=96, unique=True)

183 prefijo = models.CharField(max_length=4)

184 consecutivo = models.PositiveIntegerField()

185 total = models.DecimalField(max_digits=18, decimal_places=2)

186

187SELECT u.id, u.nombre, COUNT(p.id) as total_pedidos

188FROM usuarios u

189LEFT JOIN pedidos p ON p.usuario_id = u.id

190WHERE u.activo = true GROUP BY u.id;

191

192{

193 "servicio": "halu-medic",

194 "version": "2.4.1",

195 "runtime": "python3.12",

196 "region": "us-east-1"

197}

198

199const App: FC = () => (

200 <Layout>

201 <Hero />

202 <Services />

203 </Layout>

204)

205

206@app.route('/api/facturas', methods=['POST'])

207def crear_factura():

208 data = request.get_json()

209 return jsonify(servicio.crear(data))

210

211interface Cliente {

212 id: string

213 nombre: string

214 nit: string

215 activo: boolean

216}

217

218docker compose up -d --build

219nginx -s reload

220pytest tests/ -v --cov=app

221npm run build && npm run start

222

223await celery.send_task('rips.procesar', args=[batch_id])

224cache.set(key, value, timeout=3600)

225

226import { NextResponse } from 'next/server'

227export async function POST(req: Request) {

228 const { email } = await req.json()

229 return NextResponse.json({ ok: true })

230}

231

232const useStack = <T,>(): Stack<T> => {

233 const [items, setItems] = useState<T[]>([])

234 const push = (item: T) => setItems(p => [...p, item])

235 return { items, push }

236}

237

238class FacturaElectronica(models.Model):

239 cufe = models.CharField(max_length=96, unique=True)

240 prefijo = models.CharField(max_length=4)

241 consecutivo = models.PositiveIntegerField()

242 total = models.DecimalField(max_digits=18, decimal_places=2)

243

244SELECT u.id, u.nombre, COUNT(p.id) as total_pedidos

245FROM usuarios u

246LEFT JOIN pedidos p ON p.usuario_id = u.id

247WHERE u.activo = true GROUP BY u.id;

248

249{

250 "servicio": "halu-medic",

251 "version": "2.4.1",

252 "runtime": "python3.12",

253 "region": "us-east-1"

254}

255

256const App: FC = () => (

257 <Layout>

258 <Hero />

259 <Services />

260 </Layout>

261)

262

263@app.route('/api/facturas', methods=['POST'])

264def crear_factura():

265 data = request.get_json()

266 return jsonify(servicio.crear(data))

267

268interface Cliente {

269 id: string

270 nombre: string

271 nit: string

272 activo: boolean

273}

274

275docker compose up -d --build

276nginx -s reload

277pytest tests/ -v --cov=app

278npm run build && npm run start

279

280await celery.send_task('rips.procesar', args=[batch_id])

281cache.set(key, value, timeout=3600)

282

211import { NextResponse } from 'next/server'

212export async function POST(req: Request) {

213 const { email } = await req.json()

214 return NextResponse.json({ ok: true })

215}

216

217const useStack = <T,>(): Stack<T> => {

218 const [items, setItems] = useState<T[]>([])

219 const push = (item: T) => setItems(p => [...p, item])

220 return { items, push }

221}

222

223class FacturaElectronica(models.Model):

224 cufe = models.CharField(max_length=96, unique=True)

225 prefijo = models.CharField(max_length=4)

226 consecutivo = models.PositiveIntegerField()

227 total = models.DecimalField(max_digits=18, decimal_places=2)

228

229SELECT u.id, u.nombre, COUNT(p.id) as total_pedidos

230FROM usuarios u

231LEFT JOIN pedidos p ON p.usuario_id = u.id

232WHERE u.activo = true GROUP BY u.id;

233

234{

235 "servicio": "halu-medic",

236 "version": "2.4.1",

237 "runtime": "python3.12",

238 "region": "us-east-1"

239}

240

241const App: FC = () => (

242 <Layout>

243 <Hero />

244 <Services />

245 </Layout>

246)

247

248@app.route('/api/facturas', methods=['POST'])

249def crear_factura():

250 data = request.get_json()

251 return jsonify(servicio.crear(data))

252

253interface Cliente {

254 id: string

255 nombre: string

256 nit: string

257 activo: boolean

258}

259

260docker compose up -d --build

261nginx -s reload

262pytest tests/ -v --cov=app

263npm run build && npm run start

264

265await celery.send_task('rips.procesar', args=[batch_id])

266cache.set(key, value, timeout=3600)

267

268import { NextResponse } from 'next/server'

269export async function POST(req: Request) {

270 const { email } = await req.json()

271 return NextResponse.json({ ok: true })

272}

273

274const useStack = <T,>(): Stack<T> => {

275 const [items, setItems] = useState<T[]>([])

276 const push = (item: T) => setItems(p => [...p, item])

277 return { items, push }

278}

279

280class FacturaElectronica(models.Model):

281 cufe = models.CharField(max_length=96, unique=True)

282 prefijo = models.CharField(max_length=4)

283 consecutivo = models.PositiveIntegerField()

284 total = models.DecimalField(max_digits=18, decimal_places=2)

285

286SELECT u.id, u.nombre, COUNT(p.id) as total_pedidos

287FROM usuarios u

288LEFT JOIN pedidos p ON p.usuario_id = u.id

289WHERE u.activo = true GROUP BY u.id;

290

291{

292 "servicio": "halu-medic",

293 "version": "2.4.1",

294 "runtime": "python3.12",

295 "region": "us-east-1"

296}

297

298const App: FC = () => (

299 <Layout>

300 <Hero />

301 <Services />

302 </Layout>

303)

304

305@app.route('/api/facturas', methods=['POST'])

306def crear_factura():

307 data = request.get_json()

308 return jsonify(servicio.crear(data))

309

310interface Cliente {

311 id: string

312 nombre: string

313 nit: string

314 activo: boolean

315}

316

317docker compose up -d --build

318nginx -s reload

319pytest tests/ -v --cov=app

320npm run build && npm run start

321

322await celery.send_task('rips.procesar', args=[batch_id])

323cache.set(key, value, timeout=3600)

324

AXENTIATECHNOLOGIES

Hablemos

Desde Sabanalarga y Barranquilla, para toda Colombia

Construimos el software que su empresa necesita para crecer.

Somos un equipo colombiano que desarrolla páginas web, sistemas y plataformas a la medida. Usted habla directamente con quien programa su proyecto — sin vendedores de por medio.

Ver lo que hacemos Contáctanos

Dirigida por Habid Acuña, desarrollador con 3 años de experiencia. Cada proyecto pasa por sus manos, de principio a fin.

~/axentia — zsh — 80×24

axentia@dev:~$ ▍

Lo que hacemos

Servicios construidos para que su negocio crezca.

Cada proyecto es código real, mantenible y escalable. Nada de plantillas genéricas: software hecho a la medida de su operación.

Páginas web institucionales

Presencia profesional, rápida y posicionada en Google. Diseño que comunica y convierte.

SEONext.jsCMS

Landing pages

Páginas de conversión de alto impacto para campañas, lanzamientos y productos.

A/B TestAnalyticsCRO

Software web a medida

Sistemas hechos a la medida de cada proceso de negocio. Sin atajos, sin plantillas.

DjangoPostgreSQLSeguridad OWASP

Aplicaciones web & SaaS

Plataformas multi-tenant, escalables y seguras. Listas para crecer con su empresa.

Multi-tenantScaleSSO

Integraciones & APIs

DIAN / facturación electrónica, pasarelas de pago, conexión con servicios externos.

DIANPSEREST

Mantenimiento & SEO

Soporte continuo, métricas claras y posicionamiento sostenido en buscadores.

SLAMonitoringSEO

Stack tecnológico

Las herramientas reales con las que construimos.

No improvisamos. Usamos tecnologías probadas que escalan con su negocio y permiten mantener el código durante años.

axentia / stack

// Capa de presentación · UI rápida y reactiva

export const frontend = {

framework: "Next.js 14",

library: "React 18",

language: "TypeScript",

styling: "Tailwind CSS",

motion: "Framer Motion",

icons: "lucide-react",

state: "React Query + Zustand",

}

▍

Tecnologías que componen nuestro trabajo

PythonJavaScript / TypeScriptNext.jsReactDjangoTailwind CSS

Ecosistema Halu

No solo construimos sitios. Construimos productos.

Halu Group es nuestro propio portafolio de plataformas SaaS en producción. Es la prueba de que sabemos lo que hacemos.

~/halu-edie

En producción

Halu Plataforma Escolar EDIE

Gestión escolar integral: admisiones, financiero, portales académicos e IA de bienestar estudiantil.